1/* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21/*@@ This file should be rewritten to use an arbitrary precision
22 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
23 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
24 @@ The routines that translate from the ap rep should
25 @@ warn if precision et. al. is lost.
26 @@ This would also make life easier when this technology is used
27 @@ for cross-compilers. */
28
29
30/* The entry points in this file are fold, size_int_wide, size_binop
31 and force_fit_type.
32
33 fold takes a tree as argument and returns a simplified tree.
34
35 size_binop takes a tree code for an arithmetic operation
36 and two operands that are trees, and produces a tree for the
37 result, assuming the type comes from `sizetype'.
38
39 size_int takes an integer value, and creates a tree constant
40 with type from `sizetype'.
41
42 force_fit_type takes a constant and prior overflow indicator, and
43 forces the value to fit the type. It returns an overflow indicator. */
44
45#include "config.h"
46#include "system.h"
47#include <setjmp.h>
48#include "flags.h"
49#include "tree.h"
| 1/* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21/*@@ This file should be rewritten to use an arbitrary precision
22 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
23 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
24 @@ The routines that translate from the ap rep should
25 @@ warn if precision et. al. is lost.
26 @@ This would also make life easier when this technology is used
27 @@ for cross-compilers. */
28
29
30/* The entry points in this file are fold, size_int_wide, size_binop
31 and force_fit_type.
32
33 fold takes a tree as argument and returns a simplified tree.
34
35 size_binop takes a tree code for an arithmetic operation
36 and two operands that are trees, and produces a tree for the
37 result, assuming the type comes from `sizetype'.
38
39 size_int takes an integer value, and creates a tree constant
40 with type from `sizetype'.
41
42 force_fit_type takes a constant and prior overflow indicator, and
43 forces the value to fit the type. It returns an overflow indicator. */
44
45#include "config.h"
46#include "system.h"
47#include <setjmp.h>
48#include "flags.h"
49#include "tree.h"
|
| 50#include "rtl.h"
|
50#include "toplev.h"
51
| 51#include "toplev.h"
52
|
52/* Handle floating overflow for `const_binop'. */
53static jmp_buf float_error;
54
| |
55static void encode PROTO((HOST_WIDE_INT *,
56 HOST_WIDE_INT, HOST_WIDE_INT));
57static void decode PROTO((HOST_WIDE_INT *,
58 HOST_WIDE_INT *, HOST_WIDE_INT *));
59int div_and_round_double PROTO((enum tree_code, int, HOST_WIDE_INT,
60 HOST_WIDE_INT, HOST_WIDE_INT,
61 HOST_WIDE_INT, HOST_WIDE_INT *,
62 HOST_WIDE_INT *, HOST_WIDE_INT *,
63 HOST_WIDE_INT *));
64static int split_tree PROTO((tree, enum tree_code, tree *,
65 tree *, int *));
66static tree int_const_binop PROTO((enum tree_code, tree, tree, int, int));
67static tree const_binop PROTO((enum tree_code, tree, tree, int));
68static tree fold_convert PROTO((tree, tree));
69static enum tree_code invert_tree_comparison PROTO((enum tree_code));
70static enum tree_code swap_tree_comparison PROTO((enum tree_code));
71static int truth_value_p PROTO((enum tree_code));
72static int operand_equal_for_comparison_p PROTO((tree, tree, tree));
73static int twoval_comparison_p PROTO((tree, tree *, tree *, int *));
74static tree eval_subst PROTO((tree, tree, tree, tree, tree));
75static tree omit_one_operand PROTO((tree, tree, tree));
76static tree pedantic_omit_one_operand PROTO((tree, tree, tree));
77static tree distribute_bit_expr PROTO((enum tree_code, tree, tree, tree));
78static tree make_bit_field_ref PROTO((tree, tree, int, int, int));
79static tree optimize_bit_field_compare PROTO((enum tree_code, tree,
80 tree, tree));
81static tree decode_field_reference PROTO((tree, int *, int *,
82 enum machine_mode *, int *,
83 int *, tree *, tree *));
84static int all_ones_mask_p PROTO((tree, int));
85static int simple_operand_p PROTO((tree));
86static tree range_binop PROTO((enum tree_code, tree, tree, int,
87 tree, int));
88static tree make_range PROTO((tree, int *, tree *, tree *));
89static tree build_range_check PROTO((tree, tree, int, tree, tree));
90static int merge_ranges PROTO((int *, tree *, tree *, int, tree, tree,
91 int, tree, tree));
92static tree fold_range_test PROTO((tree));
93static tree unextend PROTO((tree, int, int, tree));
94static tree fold_truthop PROTO((enum tree_code, tree, tree, tree));
95static tree strip_compound_expr PROTO((tree, tree));
96static int multiple_of_p PROTO((tree, tree, tree));
97static tree constant_boolean_node PROTO((int, tree));
| 53static void encode PROTO((HOST_WIDE_INT *,
54 HOST_WIDE_INT, HOST_WIDE_INT));
55static void decode PROTO((HOST_WIDE_INT *,
56 HOST_WIDE_INT *, HOST_WIDE_INT *));
57int div_and_round_double PROTO((enum tree_code, int, HOST_WIDE_INT,
58 HOST_WIDE_INT, HOST_WIDE_INT,
59 HOST_WIDE_INT, HOST_WIDE_INT *,
60 HOST_WIDE_INT *, HOST_WIDE_INT *,
61 HOST_WIDE_INT *));
62static int split_tree PROTO((tree, enum tree_code, tree *,
63 tree *, int *));
64static tree int_const_binop PROTO((enum tree_code, tree, tree, int, int));
65static tree const_binop PROTO((enum tree_code, tree, tree, int));
66static tree fold_convert PROTO((tree, tree));
67static enum tree_code invert_tree_comparison PROTO((enum tree_code));
68static enum tree_code swap_tree_comparison PROTO((enum tree_code));
69static int truth_value_p PROTO((enum tree_code));
70static int operand_equal_for_comparison_p PROTO((tree, tree, tree));
71static int twoval_comparison_p PROTO((tree, tree *, tree *, int *));
72static tree eval_subst PROTO((tree, tree, tree, tree, tree));
73static tree omit_one_operand PROTO((tree, tree, tree));
74static tree pedantic_omit_one_operand PROTO((tree, tree, tree));
75static tree distribute_bit_expr PROTO((enum tree_code, tree, tree, tree));
76static tree make_bit_field_ref PROTO((tree, tree, int, int, int));
77static tree optimize_bit_field_compare PROTO((enum tree_code, tree,
78 tree, tree));
79static tree decode_field_reference PROTO((tree, int *, int *,
80 enum machine_mode *, int *,
81 int *, tree *, tree *));
82static int all_ones_mask_p PROTO((tree, int));
83static int simple_operand_p PROTO((tree));
84static tree range_binop PROTO((enum tree_code, tree, tree, int,
85 tree, int));
86static tree make_range PROTO((tree, int *, tree *, tree *));
87static tree build_range_check PROTO((tree, tree, int, tree, tree));
88static int merge_ranges PROTO((int *, tree *, tree *, int, tree, tree,
89 int, tree, tree));
90static tree fold_range_test PROTO((tree));
91static tree unextend PROTO((tree, int, int, tree));
92static tree fold_truthop PROTO((enum tree_code, tree, tree, tree));
93static tree strip_compound_expr PROTO((tree, tree));
94static int multiple_of_p PROTO((tree, tree, tree));
95static tree constant_boolean_node PROTO((int, tree));
|
| 96static int count_cond PROTO((tree, int));
97static void const_binop_1 PROTO((PTR));
98static void fold_convert_1 PROTO((PTR));
|
98
99#ifndef BRANCH_COST
100#define BRANCH_COST 1
101#endif
102
103/* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
104 Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
105 Then this yields nonzero if overflow occurred during the addition.
106 Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
107 Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
108#define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
109
110/* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
111 We do that by representing the two-word integer in 4 words, with only
112 HOST_BITS_PER_WIDE_INT/2 bits stored in each word, as a positive number. */
113
114#define LOWPART(x) \
115 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT/2)) - 1))
116#define HIGHPART(x) \
117 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT/2)
118#define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT/2)
119
120/* Unpack a two-word integer into 4 words.
121 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
122 WORDS points to the array of HOST_WIDE_INTs. */
123
124static void
125encode (words, low, hi)
126 HOST_WIDE_INT *words;
127 HOST_WIDE_INT low, hi;
128{
129 words[0] = LOWPART (low);
130 words[1] = HIGHPART (low);
131 words[2] = LOWPART (hi);
132 words[3] = HIGHPART (hi);
133}
134
135/* Pack an array of 4 words into a two-word integer.
136 WORDS points to the array of words.
137 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
138
139static void
140decode (words, low, hi)
141 HOST_WIDE_INT *words;
142 HOST_WIDE_INT *low, *hi;
143{
144 *low = words[0] | words[1] * BASE;
145 *hi = words[2] | words[3] * BASE;
146}
147
148/* Make the integer constant T valid for its type
149 by setting to 0 or 1 all the bits in the constant
150 that don't belong in the type.
151 Yield 1 if a signed overflow occurs, 0 otherwise.
152 If OVERFLOW is nonzero, a signed overflow has already occurred
153 in calculating T, so propagate it.
154
155 Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
156 if it exists. */
157
158int
159force_fit_type (t, overflow)
160 tree t;
161 int overflow;
162{
163 HOST_WIDE_INT low, high;
164 register int prec;
165
166 if (TREE_CODE (t) == REAL_CST)
167 {
168#ifdef CHECK_FLOAT_VALUE
169 CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t)), TREE_REAL_CST (t),
170 overflow);
171#endif
172 return overflow;
173 }
174
175 else if (TREE_CODE (t) != INTEGER_CST)
176 return overflow;
177
178 low = TREE_INT_CST_LOW (t);
179 high = TREE_INT_CST_HIGH (t);
180
181 if (POINTER_TYPE_P (TREE_TYPE (t)))
182 prec = POINTER_SIZE;
183 else
184 prec = TYPE_PRECISION (TREE_TYPE (t));
185
186 /* First clear all bits that are beyond the type's precision. */
187
188 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
189 ;
190 else if (prec > HOST_BITS_PER_WIDE_INT)
191 {
192 TREE_INT_CST_HIGH (t)
193 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
194 }
195 else
196 {
197 TREE_INT_CST_HIGH (t) = 0;
198 if (prec < HOST_BITS_PER_WIDE_INT)
199 TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
200 }
201
202 /* Unsigned types do not suffer sign extension or overflow. */
203 if (TREE_UNSIGNED (TREE_TYPE (t)))
204 return overflow;
205
206 /* If the value's sign bit is set, extend the sign. */
207 if (prec != 2 * HOST_BITS_PER_WIDE_INT
208 && (prec > HOST_BITS_PER_WIDE_INT
209 ? (TREE_INT_CST_HIGH (t)
210 & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
211 : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
212 {
213 /* Value is negative:
214 set to 1 all the bits that are outside this type's precision. */
215 if (prec > HOST_BITS_PER_WIDE_INT)
216 {
217 TREE_INT_CST_HIGH (t)
218 |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
219 }
220 else
221 {
222 TREE_INT_CST_HIGH (t) = -1;
223 if (prec < HOST_BITS_PER_WIDE_INT)
224 TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
225 }
226 }
227
228 /* Yield nonzero if signed overflow occurred. */
229 return
230 ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
231 != 0);
232}
233
234/* Add two doubleword integers with doubleword result.
235 Each argument is given as two `HOST_WIDE_INT' pieces.
236 One argument is L1 and H1; the other, L2 and H2.
237 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
238
239int
240add_double (l1, h1, l2, h2, lv, hv)
241 HOST_WIDE_INT l1, h1, l2, h2;
242 HOST_WIDE_INT *lv, *hv;
243{
244 HOST_WIDE_INT l, h;
245
246 l = l1 + l2;
247 h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < l1);
248
249 *lv = l;
250 *hv = h;
251 return overflow_sum_sign (h1, h2, h);
252}
253
254/* Negate a doubleword integer with doubleword result.
255 Return nonzero if the operation overflows, assuming it's signed.
256 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
257 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
258
259int
260neg_double (l1, h1, lv, hv)
261 HOST_WIDE_INT l1, h1;
262 HOST_WIDE_INT *lv, *hv;
263{
264 if (l1 == 0)
265 {
266 *lv = 0;
267 *hv = - h1;
268 return (*hv & h1) < 0;
269 }
270 else
271 {
272 *lv = - l1;
273 *hv = ~ h1;
274 return 0;
275 }
276}
277
278/* Multiply two doubleword integers with doubleword result.
279 Return nonzero if the operation overflows, assuming it's signed.
280 Each argument is given as two `HOST_WIDE_INT' pieces.
281 One argument is L1 and H1; the other, L2 and H2.
282 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
283
284int
285mul_double (l1, h1, l2, h2, lv, hv)
286 HOST_WIDE_INT l1, h1, l2, h2;
287 HOST_WIDE_INT *lv, *hv;
288{
289 HOST_WIDE_INT arg1[4];
290 HOST_WIDE_INT arg2[4];
291 HOST_WIDE_INT prod[4 * 2];
292 register unsigned HOST_WIDE_INT carry;
293 register int i, j, k;
294 HOST_WIDE_INT toplow, tophigh, neglow, neghigh;
295
296 encode (arg1, l1, h1);
297 encode (arg2, l2, h2);
298
299 bzero ((char *) prod, sizeof prod);
300
301 for (i = 0; i < 4; i++)
302 {
303 carry = 0;
304 for (j = 0; j < 4; j++)
305 {
306 k = i + j;
307 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
308 carry += arg1[i] * arg2[j];
309 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
310 carry += prod[k];
311 prod[k] = LOWPART (carry);
312 carry = HIGHPART (carry);
313 }
314 prod[i + 4] = carry;
315 }
316
317 decode (prod, lv, hv); /* This ignores prod[4] through prod[4*2-1] */
318
319 /* Check for overflow by calculating the top half of the answer in full;
320 it should agree with the low half's sign bit. */
321 decode (prod+4, &toplow, &tophigh);
322 if (h1 < 0)
323 {
324 neg_double (l2, h2, &neglow, &neghigh);
325 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
326 }
327 if (h2 < 0)
328 {
329 neg_double (l1, h1, &neglow, &neghigh);
330 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
331 }
332 return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
333}
334
335/* Shift the doubleword integer in L1, H1 left by COUNT places
336 keeping only PREC bits of result.
337 Shift right if COUNT is negative.
338 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
339 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
340
341void
342lshift_double (l1, h1, count, prec, lv, hv, arith)
343 HOST_WIDE_INT l1, h1, count;
344 int prec;
345 HOST_WIDE_INT *lv, *hv;
346 int arith;
347{
348 if (count < 0)
349 {
350 rshift_double (l1, h1, - count, prec, lv, hv, arith);
351 return;
352 }
353
354#ifdef SHIFT_COUNT_TRUNCATED
355 if (SHIFT_COUNT_TRUNCATED)
356 count %= prec;
357#endif
358
359 if (count >= HOST_BITS_PER_WIDE_INT)
360 {
361 *hv = (unsigned HOST_WIDE_INT) l1 << (count - HOST_BITS_PER_WIDE_INT);
362 *lv = 0;
363 }
364 else
365 {
366 *hv = (((unsigned HOST_WIDE_INT) h1 << count)
367 | ((unsigned HOST_WIDE_INT) l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
368 *lv = (unsigned HOST_WIDE_INT) l1 << count;
369 }
370}
371
372/* Shift the doubleword integer in L1, H1 right by COUNT places
373 keeping only PREC bits of result. COUNT must be positive.
374 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
375 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
376
377void
378rshift_double (l1, h1, count, prec, lv, hv, arith)
379 HOST_WIDE_INT l1, h1, count;
| 99
100#ifndef BRANCH_COST
101#define BRANCH_COST 1
102#endif
103
104/* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
105 Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
106 Then this yields nonzero if overflow occurred during the addition.
107 Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
108 Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
109#define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
110
111/* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
112 We do that by representing the two-word integer in 4 words, with only
113 HOST_BITS_PER_WIDE_INT/2 bits stored in each word, as a positive number. */
114
115#define LOWPART(x) \
116 ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT/2)) - 1))
117#define HIGHPART(x) \
118 ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT/2)
119#define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT/2)
120
121/* Unpack a two-word integer into 4 words.
122 LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
123 WORDS points to the array of HOST_WIDE_INTs. */
124
125static void
126encode (words, low, hi)
127 HOST_WIDE_INT *words;
128 HOST_WIDE_INT low, hi;
129{
130 words[0] = LOWPART (low);
131 words[1] = HIGHPART (low);
132 words[2] = LOWPART (hi);
133 words[3] = HIGHPART (hi);
134}
135
136/* Pack an array of 4 words into a two-word integer.
137 WORDS points to the array of words.
138 The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
139
140static void
141decode (words, low, hi)
142 HOST_WIDE_INT *words;
143 HOST_WIDE_INT *low, *hi;
144{
145 *low = words[0] | words[1] * BASE;
146 *hi = words[2] | words[3] * BASE;
147}
148
149/* Make the integer constant T valid for its type
150 by setting to 0 or 1 all the bits in the constant
151 that don't belong in the type.
152 Yield 1 if a signed overflow occurs, 0 otherwise.
153 If OVERFLOW is nonzero, a signed overflow has already occurred
154 in calculating T, so propagate it.
155
156 Make the real constant T valid for its type by calling CHECK_FLOAT_VALUE,
157 if it exists. */
158
159int
160force_fit_type (t, overflow)
161 tree t;
162 int overflow;
163{
164 HOST_WIDE_INT low, high;
165 register int prec;
166
167 if (TREE_CODE (t) == REAL_CST)
168 {
169#ifdef CHECK_FLOAT_VALUE
170 CHECK_FLOAT_VALUE (TYPE_MODE (TREE_TYPE (t)), TREE_REAL_CST (t),
171 overflow);
172#endif
173 return overflow;
174 }
175
176 else if (TREE_CODE (t) != INTEGER_CST)
177 return overflow;
178
179 low = TREE_INT_CST_LOW (t);
180 high = TREE_INT_CST_HIGH (t);
181
182 if (POINTER_TYPE_P (TREE_TYPE (t)))
183 prec = POINTER_SIZE;
184 else
185 prec = TYPE_PRECISION (TREE_TYPE (t));
186
187 /* First clear all bits that are beyond the type's precision. */
188
189 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
190 ;
191 else if (prec > HOST_BITS_PER_WIDE_INT)
192 {
193 TREE_INT_CST_HIGH (t)
194 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
195 }
196 else
197 {
198 TREE_INT_CST_HIGH (t) = 0;
199 if (prec < HOST_BITS_PER_WIDE_INT)
200 TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
201 }
202
203 /* Unsigned types do not suffer sign extension or overflow. */
204 if (TREE_UNSIGNED (TREE_TYPE (t)))
205 return overflow;
206
207 /* If the value's sign bit is set, extend the sign. */
208 if (prec != 2 * HOST_BITS_PER_WIDE_INT
209 && (prec > HOST_BITS_PER_WIDE_INT
210 ? (TREE_INT_CST_HIGH (t)
211 & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
212 : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
213 {
214 /* Value is negative:
215 set to 1 all the bits that are outside this type's precision. */
216 if (prec > HOST_BITS_PER_WIDE_INT)
217 {
218 TREE_INT_CST_HIGH (t)
219 |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
220 }
221 else
222 {
223 TREE_INT_CST_HIGH (t) = -1;
224 if (prec < HOST_BITS_PER_WIDE_INT)
225 TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
226 }
227 }
228
229 /* Yield nonzero if signed overflow occurred. */
230 return
231 ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
232 != 0);
233}
234
235/* Add two doubleword integers with doubleword result.
236 Each argument is given as two `HOST_WIDE_INT' pieces.
237 One argument is L1 and H1; the other, L2 and H2.
238 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
239
240int
241add_double (l1, h1, l2, h2, lv, hv)
242 HOST_WIDE_INT l1, h1, l2, h2;
243 HOST_WIDE_INT *lv, *hv;
244{
245 HOST_WIDE_INT l, h;
246
247 l = l1 + l2;
248 h = h1 + h2 + ((unsigned HOST_WIDE_INT) l < l1);
249
250 *lv = l;
251 *hv = h;
252 return overflow_sum_sign (h1, h2, h);
253}
254
255/* Negate a doubleword integer with doubleword result.
256 Return nonzero if the operation overflows, assuming it's signed.
257 The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
258 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
259
260int
261neg_double (l1, h1, lv, hv)
262 HOST_WIDE_INT l1, h1;
263 HOST_WIDE_INT *lv, *hv;
264{
265 if (l1 == 0)
266 {
267 *lv = 0;
268 *hv = - h1;
269 return (*hv & h1) < 0;
270 }
271 else
272 {
273 *lv = - l1;
274 *hv = ~ h1;
275 return 0;
276 }
277}
278
279/* Multiply two doubleword integers with doubleword result.
280 Return nonzero if the operation overflows, assuming it's signed.
281 Each argument is given as two `HOST_WIDE_INT' pieces.
282 One argument is L1 and H1; the other, L2 and H2.
283 The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV. */
284
285int
286mul_double (l1, h1, l2, h2, lv, hv)
287 HOST_WIDE_INT l1, h1, l2, h2;
288 HOST_WIDE_INT *lv, *hv;
289{
290 HOST_WIDE_INT arg1[4];
291 HOST_WIDE_INT arg2[4];
292 HOST_WIDE_INT prod[4 * 2];
293 register unsigned HOST_WIDE_INT carry;
294 register int i, j, k;
295 HOST_WIDE_INT toplow, tophigh, neglow, neghigh;
296
297 encode (arg1, l1, h1);
298 encode (arg2, l2, h2);
299
300 bzero ((char *) prod, sizeof prod);
301
302 for (i = 0; i < 4; i++)
303 {
304 carry = 0;
305 for (j = 0; j < 4; j++)
306 {
307 k = i + j;
308 /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000. */
309 carry += arg1[i] * arg2[j];
310 /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF. */
311 carry += prod[k];
312 prod[k] = LOWPART (carry);
313 carry = HIGHPART (carry);
314 }
315 prod[i + 4] = carry;
316 }
317
318 decode (prod, lv, hv); /* This ignores prod[4] through prod[4*2-1] */
319
320 /* Check for overflow by calculating the top half of the answer in full;
321 it should agree with the low half's sign bit. */
322 decode (prod+4, &toplow, &tophigh);
323 if (h1 < 0)
324 {
325 neg_double (l2, h2, &neglow, &neghigh);
326 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
327 }
328 if (h2 < 0)
329 {
330 neg_double (l1, h1, &neglow, &neghigh);
331 add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
332 }
333 return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
334}
335
336/* Shift the doubleword integer in L1, H1 left by COUNT places
337 keeping only PREC bits of result.
338 Shift right if COUNT is negative.
339 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
340 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
341
342void
343lshift_double (l1, h1, count, prec, lv, hv, arith)
344 HOST_WIDE_INT l1, h1, count;
345 int prec;
346 HOST_WIDE_INT *lv, *hv;
347 int arith;
348{
349 if (count < 0)
350 {
351 rshift_double (l1, h1, - count, prec, lv, hv, arith);
352 return;
353 }
354
355#ifdef SHIFT_COUNT_TRUNCATED
356 if (SHIFT_COUNT_TRUNCATED)
357 count %= prec;
358#endif
359
360 if (count >= HOST_BITS_PER_WIDE_INT)
361 {
362 *hv = (unsigned HOST_WIDE_INT) l1 << (count - HOST_BITS_PER_WIDE_INT);
363 *lv = 0;
364 }
365 else
366 {
367 *hv = (((unsigned HOST_WIDE_INT) h1 << count)
368 | ((unsigned HOST_WIDE_INT) l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
369 *lv = (unsigned HOST_WIDE_INT) l1 << count;
370 }
371}
372
373/* Shift the doubleword integer in L1, H1 right by COUNT places
374 keeping only PREC bits of result. COUNT must be positive.
375 ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
376 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
377
378void
379rshift_double (l1, h1, count, prec, lv, hv, arith)
380 HOST_WIDE_INT l1, h1, count;
|
380 int prec;
| 381 int prec ATTRIBUTE_UNUSED;
|
381 HOST_WIDE_INT *lv, *hv;
382 int arith;
383{
384 unsigned HOST_WIDE_INT signmask;
385 signmask = (arith
386 ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
387 : 0);
388
389#ifdef SHIFT_COUNT_TRUNCATED
390 if (SHIFT_COUNT_TRUNCATED)
391 count %= prec;
392#endif
393
394 if (count >= HOST_BITS_PER_WIDE_INT)
395 {
396 *hv = signmask;
397 *lv = ((signmask << (2 * HOST_BITS_PER_WIDE_INT - count - 1) << 1)
398 | ((unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT)));
399 }
400 else
401 {
402 *lv = (((unsigned HOST_WIDE_INT) l1 >> count)
403 | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
404 *hv = ((signmask << (HOST_BITS_PER_WIDE_INT - count))
405 | ((unsigned HOST_WIDE_INT) h1 >> count));
406 }
407}
408
409/* Rotate the doubleword integer in L1, H1 left by COUNT places
410 keeping only PREC bits of result.
411 Rotate right if COUNT is negative.
412 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
413
414void
415lrotate_double (l1, h1, count, prec, lv, hv)
416 HOST_WIDE_INT l1, h1, count;
417 int prec;
418 HOST_WIDE_INT *lv, *hv;
419{
420 HOST_WIDE_INT s1l, s1h, s2l, s2h;
421
422 count %= prec;
423 if (count < 0)
424 count += prec;
425
426 lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
427 rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
428 *lv = s1l | s2l;
429 *hv = s1h | s2h;
430}
431
432/* Rotate the doubleword integer in L1, H1 left by COUNT places
433 keeping only PREC bits of result. COUNT must be positive.
434 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
435
436void
437rrotate_double (l1, h1, count, prec, lv, hv)
438 HOST_WIDE_INT l1, h1, count;
439 int prec;
440 HOST_WIDE_INT *lv, *hv;
441{
442 HOST_WIDE_INT s1l, s1h, s2l, s2h;
443
444 count %= prec;
445 if (count < 0)
446 count += prec;
447
448 rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
449 lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
450 *lv = s1l | s2l;
451 *hv = s1h | s2h;
452}
453
454/* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
455 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
456 CODE is a tree code for a kind of division, one of
457 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
458 or EXACT_DIV_EXPR
459 It controls how the quotient is rounded to a integer.
460 Return nonzero if the operation overflows.
461 UNS nonzero says do unsigned division. */
462
463int
464div_and_round_double (code, uns,
465 lnum_orig, hnum_orig, lden_orig, hden_orig,
466 lquo, hquo, lrem, hrem)
467 enum tree_code code;
468 int uns;
469 HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
470 HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
471 HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
472{
473 int quo_neg = 0;
474 HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
475 HOST_WIDE_INT den[4], quo[4];
476 register int i, j;
477 unsigned HOST_WIDE_INT work;
478 register unsigned HOST_WIDE_INT carry = 0;
479 HOST_WIDE_INT lnum = lnum_orig;
480 HOST_WIDE_INT hnum = hnum_orig;
481 HOST_WIDE_INT lden = lden_orig;
482 HOST_WIDE_INT hden = hden_orig;
483 int overflow = 0;
484
485 if ((hden == 0) && (lden == 0))
486 overflow = 1, lden = 1;
487
488 /* calculate quotient sign and convert operands to unsigned. */
489 if (!uns)
490 {
491 if (hnum < 0)
492 {
493 quo_neg = ~ quo_neg;
494 /* (minimum integer) / (-1) is the only overflow case. */
495 if (neg_double (lnum, hnum, &lnum, &hnum) && (lden & hden) == -1)
496 overflow = 1;
497 }
498 if (hden < 0)
499 {
500 quo_neg = ~ quo_neg;
501 neg_double (lden, hden, &lden, &hden);
502 }
503 }
504
505 if (hnum == 0 && hden == 0)
506 { /* single precision */
507 *hquo = *hrem = 0;
508 /* This unsigned division rounds toward zero. */
509 *lquo = lnum / (unsigned HOST_WIDE_INT) lden;
510 goto finish_up;
511 }
512
513 if (hnum == 0)
514 { /* trivial case: dividend < divisor */
515 /* hden != 0 already checked. */
516 *hquo = *lquo = 0;
517 *hrem = hnum;
518 *lrem = lnum;
519 goto finish_up;
520 }
521
522 bzero ((char *) quo, sizeof quo);
523
524 bzero ((char *) num, sizeof num); /* to zero 9th element */
525 bzero ((char *) den, sizeof den);
526
527 encode (num, lnum, hnum);
528 encode (den, lden, hden);
529
530 /* Special code for when the divisor < BASE. */
| 382 HOST_WIDE_INT *lv, *hv;
383 int arith;
384{
385 unsigned HOST_WIDE_INT signmask;
386 signmask = (arith
387 ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
388 : 0);
389
390#ifdef SHIFT_COUNT_TRUNCATED
391 if (SHIFT_COUNT_TRUNCATED)
392 count %= prec;
393#endif
394
395 if (count >= HOST_BITS_PER_WIDE_INT)
396 {
397 *hv = signmask;
398 *lv = ((signmask << (2 * HOST_BITS_PER_WIDE_INT - count - 1) << 1)
399 | ((unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT)));
400 }
401 else
402 {
403 *lv = (((unsigned HOST_WIDE_INT) l1 >> count)
404 | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
405 *hv = ((signmask << (HOST_BITS_PER_WIDE_INT - count))
406 | ((unsigned HOST_WIDE_INT) h1 >> count));
407 }
408}
409
410/* Rotate the doubleword integer in L1, H1 left by COUNT places
411 keeping only PREC bits of result.
412 Rotate right if COUNT is negative.
413 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
414
415void
416lrotate_double (l1, h1, count, prec, lv, hv)
417 HOST_WIDE_INT l1, h1, count;
418 int prec;
419 HOST_WIDE_INT *lv, *hv;
420{
421 HOST_WIDE_INT s1l, s1h, s2l, s2h;
422
423 count %= prec;
424 if (count < 0)
425 count += prec;
426
427 lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
428 rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
429 *lv = s1l | s2l;
430 *hv = s1h | s2h;
431}
432
433/* Rotate the doubleword integer in L1, H1 left by COUNT places
434 keeping only PREC bits of result. COUNT must be positive.
435 Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
436
437void
438rrotate_double (l1, h1, count, prec, lv, hv)
439 HOST_WIDE_INT l1, h1, count;
440 int prec;
441 HOST_WIDE_INT *lv, *hv;
442{
443 HOST_WIDE_INT s1l, s1h, s2l, s2h;
444
445 count %= prec;
446 if (count < 0)
447 count += prec;
448
449 rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
450 lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
451 *lv = s1l | s2l;
452 *hv = s1h | s2h;
453}
454
455/* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
456 for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
457 CODE is a tree code for a kind of division, one of
458 TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
459 or EXACT_DIV_EXPR
460 It controls how the quotient is rounded to a integer.
461 Return nonzero if the operation overflows.
462 UNS nonzero says do unsigned division. */
463
464int
465div_and_round_double (code, uns,
466 lnum_orig, hnum_orig, lden_orig, hden_orig,
467 lquo, hquo, lrem, hrem)
468 enum tree_code code;
469 int uns;
470 HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
471 HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
472 HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
473{
474 int quo_neg = 0;
475 HOST_WIDE_INT num[4 + 1]; /* extra element for scaling. */
476 HOST_WIDE_INT den[4], quo[4];
477 register int i, j;
478 unsigned HOST_WIDE_INT work;
479 register unsigned HOST_WIDE_INT carry = 0;
480 HOST_WIDE_INT lnum = lnum_orig;
481 HOST_WIDE_INT hnum = hnum_orig;
482 HOST_WIDE_INT lden = lden_orig;
483 HOST_WIDE_INT hden = hden_orig;
484 int overflow = 0;
485
486 if ((hden == 0) && (lden == 0))
487 overflow = 1, lden = 1;
488
489 /* calculate quotient sign and convert operands to unsigned. */
490 if (!uns)
491 {
492 if (hnum < 0)
493 {
494 quo_neg = ~ quo_neg;
495 /* (minimum integer) / (-1) is the only overflow case. */
496 if (neg_double (lnum, hnum, &lnum, &hnum) && (lden & hden) == -1)
497 overflow = 1;
498 }
499 if (hden < 0)
500 {
501 quo_neg = ~ quo_neg;
502 neg_double (lden, hden, &lden, &hden);
503 }
504 }
505
506 if (hnum == 0 && hden == 0)
507 { /* single precision */
508 *hquo = *hrem = 0;
509 /* This unsigned division rounds toward zero. */
510 *lquo = lnum / (unsigned HOST_WIDE_INT) lden;
511 goto finish_up;
512 }
513
514 if (hnum == 0)
515 { /* trivial case: dividend < divisor */
516 /* hden != 0 already checked. */
517 *hquo = *lquo = 0;
518 *hrem = hnum;
519 *lrem = lnum;
520 goto finish_up;
521 }
522
523 bzero ((char *) quo, sizeof quo);
524
525 bzero ((char *) num, sizeof num); /* to zero 9th element */
526 bzero ((char *) den, sizeof den);
527
528 encode (num, lnum, hnum);
529 encode (den, lden, hden);
530
531 /* Special code for when the divisor < BASE. */
|
531 if (hden == 0 && lden < BASE)
| 532 if (hden == 0 && lden < (HOST_WIDE_INT) BASE)
|
532 {
533 /* hnum != 0 already checked. */
534 for (i = 4 - 1; i >= 0; i--)
535 {
536 work = num[i] + carry * BASE;
537 quo[i] = work / (unsigned HOST_WIDE_INT) lden;
538 carry = work % (unsigned HOST_WIDE_INT) lden;
539 }
540 }
541 else
542 {
543 /* Full double precision division,
544 with thanks to Don Knuth's "Seminumerical Algorithms". */
545 int num_hi_sig, den_hi_sig;
546 unsigned HOST_WIDE_INT quo_est, scale;
547
548 /* Find the highest non-zero divisor digit. */
549 for (i = 4 - 1; ; i--)
550 if (den[i] != 0) {
551 den_hi_sig = i;
552 break;
553 }
554
555 /* Insure that the first digit of the divisor is at least BASE/2.
556 This is required by the quotient digit estimation algorithm. */
557
558 scale = BASE / (den[den_hi_sig] + 1);
559 if (scale > 1) { /* scale divisor and dividend */
560 carry = 0;
561 for (i = 0; i <= 4 - 1; i++) {
562 work = (num[i] * scale) + carry;
563 num[i] = LOWPART (work);
564 carry = HIGHPART (work);
565 } num[4] = carry;
566 carry = 0;
567 for (i = 0; i <= 4 - 1; i++) {
568 work = (den[i] * scale) + carry;
569 den[i] = LOWPART (work);
570 carry = HIGHPART (work);
571 if (den[i] != 0) den_hi_sig = i;
572 }
573 }
574
575 num_hi_sig = 4;
576
577 /* Main loop */
578 for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--) {
579 /* guess the next quotient digit, quo_est, by dividing the first
580 two remaining dividend digits by the high order quotient digit.
581 quo_est is never low and is at most 2 high. */
582 unsigned HOST_WIDE_INT tmp;
583
584 num_hi_sig = i + den_hi_sig + 1;
585 work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
586 if (num[num_hi_sig] != den[den_hi_sig])
587 quo_est = work / den[den_hi_sig];
588 else
589 quo_est = BASE - 1;
590
591 /* refine quo_est so it's usually correct, and at most one high. */
592 tmp = work - quo_est * den[den_hi_sig];
593 if (tmp < BASE
594 && den[den_hi_sig - 1] * quo_est > (tmp * BASE + num[num_hi_sig - 2]))
595 quo_est--;
596
597 /* Try QUO_EST as the quotient digit, by multiplying the
598 divisor by QUO_EST and subtracting from the remaining dividend.
599 Keep in mind that QUO_EST is the I - 1st digit. */
600
601 carry = 0;
602 for (j = 0; j <= den_hi_sig; j++)
603 {
604 work = quo_est * den[j] + carry;
605 carry = HIGHPART (work);
606 work = num[i + j] - LOWPART (work);
607 num[i + j] = LOWPART (work);
608 carry += HIGHPART (work) != 0;
609 }
610
611 /* if quo_est was high by one, then num[i] went negative and
612 we need to correct things. */
613
614 if (num[num_hi_sig] < carry)
615 {
616 quo_est--;
617 carry = 0; /* add divisor back in */
618 for (j = 0; j <= den_hi_sig; j++)
619 {
620 work = num[i + j] + den[j] + carry;
621 carry = HIGHPART (work);
622 num[i + j] = LOWPART (work);
623 }
624 num [num_hi_sig] += carry;
625 }
626
627 /* store the quotient digit. */
628 quo[i] = quo_est;
629 }
630 }
631
632 decode (quo, lquo, hquo);
633
634 finish_up:
635 /* if result is negative, make it so. */
636 if (quo_neg)
637 neg_double (*lquo, *hquo, lquo, hquo);
638
639 /* compute trial remainder: rem = num - (quo * den) */
640 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
641 neg_double (*lrem, *hrem, lrem, hrem);
642 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
643
644 switch (code)
645 {
646 case TRUNC_DIV_EXPR:
647 case TRUNC_MOD_EXPR: /* round toward zero */
648 case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
649 return overflow;
650
651 case FLOOR_DIV_EXPR:
652 case FLOOR_MOD_EXPR: /* round toward negative infinity */
653 if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
654 {
655 /* quo = quo - 1; */
656 add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
657 lquo, hquo);
658 }
659 else return overflow;
660 break;
661
662 case CEIL_DIV_EXPR:
663 case CEIL_MOD_EXPR: /* round toward positive infinity */
664 if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
665 {
666 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
667 lquo, hquo);
668 }
669 else return overflow;
670 break;
671
672 case ROUND_DIV_EXPR:
673 case ROUND_MOD_EXPR: /* round to closest integer */
674 {
675 HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
676 HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
677
678 /* get absolute values */
679 if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
680 if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
681
682 /* if (2 * abs (lrem) >= abs (lden)) */
683 mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
684 labs_rem, habs_rem, <wice, &htwice);
685 if (((unsigned HOST_WIDE_INT) habs_den
686 < (unsigned HOST_WIDE_INT) htwice)
687 || (((unsigned HOST_WIDE_INT) habs_den
688 == (unsigned HOST_WIDE_INT) htwice)
689 && ((HOST_WIDE_INT unsigned) labs_den
690 < (unsigned HOST_WIDE_INT) ltwice)))
691 {
692 if (*hquo < 0)
693 /* quo = quo - 1; */
694 add_double (*lquo, *hquo,
695 (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
696 else
697 /* quo = quo + 1; */
698 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
699 lquo, hquo);
700 }
701 else return overflow;
702 }
703 break;
704
705 default:
706 abort ();
707 }
708
709 /* compute true remainder: rem = num - (quo * den) */
710 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
711 neg_double (*lrem, *hrem, lrem, hrem);
712 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
713 return overflow;
714}
715
716#ifndef REAL_ARITHMETIC
717/* Effectively truncate a real value to represent the nearest possible value
718 in a narrower mode. The result is actually represented in the same data
719 type as the argument, but its value is usually different.
720
721 A trap may occur during the FP operations and it is the responsibility
722 of the calling function to have a handler established. */
723
724REAL_VALUE_TYPE
725real_value_truncate (mode, arg)
726 enum machine_mode mode;
727 REAL_VALUE_TYPE arg;
728{
729 return REAL_VALUE_TRUNCATE (mode, arg);
730}
731
732#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
733
734/* Check for infinity in an IEEE double precision number. */
735
736int
737target_isinf (x)
738 REAL_VALUE_TYPE x;
739{
740 /* The IEEE 64-bit double format. */
741 union {
742 REAL_VALUE_TYPE d;
743 struct {
744 unsigned sign : 1;
745 unsigned exponent : 11;
746 unsigned mantissa1 : 20;
747 unsigned mantissa2;
748 } little_endian;
749 struct {
750 unsigned mantissa2;
751 unsigned mantissa1 : 20;
752 unsigned exponent : 11;
753 unsigned sign : 1;
754 } big_endian;
755 } u;
756
757 u.d = dconstm1;
758 if (u.big_endian.sign == 1)
759 {
760 u.d = x;
761 return (u.big_endian.exponent == 2047
762 && u.big_endian.mantissa1 == 0
763 && u.big_endian.mantissa2 == 0);
764 }
765 else
766 {
767 u.d = x;
768 return (u.little_endian.exponent == 2047
769 && u.little_endian.mantissa1 == 0
770 && u.little_endian.mantissa2 == 0);
771 }
772}
773
774/* Check whether an IEEE double precision number is a NaN. */
775
776int
777target_isnan (x)
778 REAL_VALUE_TYPE x;
779{
780 /* The IEEE 64-bit double format. */
781 union {
782 REAL_VALUE_TYPE d;
783 struct {
784 unsigned sign : 1;
785 unsigned exponent : 11;
786 unsigned mantissa1 : 20;
787 unsigned mantissa2;
788 } little_endian;
789 struct {
790 unsigned mantissa2;
791 unsigned mantissa1 : 20;
792 unsigned exponent : 11;
793 unsigned sign : 1;
794 } big_endian;
795 } u;
796
797 u.d = dconstm1;
798 if (u.big_endian.sign == 1)
799 {
800 u.d = x;
801 return (u.big_endian.exponent == 2047
802 && (u.big_endian.mantissa1 != 0
803 || u.big_endian.mantissa2 != 0));
804 }
805 else
806 {
807 u.d = x;
808 return (u.little_endian.exponent == 2047
809 && (u.little_endian.mantissa1 != 0
810 || u.little_endian.mantissa2 != 0));
811 }
812}
813
814/* Check for a negative IEEE double precision number. */
815
816int
817target_negative (x)
818 REAL_VALUE_TYPE x;
819{
820 /* The IEEE 64-bit double format. */
821 union {
822 REAL_VALUE_TYPE d;
823 struct {
824 unsigned sign : 1;
825 unsigned exponent : 11;
826 unsigned mantissa1 : 20;
827 unsigned mantissa2;
828 } little_endian;
829 struct {
830 unsigned mantissa2;
831 unsigned mantissa1 : 20;
832 unsigned exponent : 11;
833 unsigned sign : 1;
834 } big_endian;
835 } u;
836
837 u.d = dconstm1;
838 if (u.big_endian.sign == 1)
839 {
840 u.d = x;
841 return u.big_endian.sign;
842 }
843 else
844 {
845 u.d = x;
846 return u.little_endian.sign;
847 }
848}
849#else /* Target not IEEE */
850
851/* Let's assume other float formats don't have infinity.
852 (This can be overridden by redefining REAL_VALUE_ISINF.) */
853
854target_isinf (x)
855 REAL_VALUE_TYPE x;
856{
857 return 0;
858}
859
860/* Let's assume other float formats don't have NaNs.
861 (This can be overridden by redefining REAL_VALUE_ISNAN.) */
862
863target_isnan (x)
864 REAL_VALUE_TYPE x;
865{
866 return 0;
867}
868
869/* Let's assume other float formats don't have minus zero.
870 (This can be overridden by redefining REAL_VALUE_NEGATIVE.) */
871
872target_negative (x)
873 REAL_VALUE_TYPE x;
874{
875 return x < 0;
876}
877#endif /* Target not IEEE */
878
879/* Try to change R into its exact multiplicative inverse in machine mode
880 MODE. Return nonzero function value if successful. */
881
882int
883exact_real_inverse (mode, r)
884 enum machine_mode mode;
885 REAL_VALUE_TYPE *r;
886{
| 533 {
534 /* hnum != 0 already checked. */
535 for (i = 4 - 1; i >= 0; i--)
536 {
537 work = num[i] + carry * BASE;
538 quo[i] = work / (unsigned HOST_WIDE_INT) lden;
539 carry = work % (unsigned HOST_WIDE_INT) lden;
540 }
541 }
542 else
543 {
544 /* Full double precision division,
545 with thanks to Don Knuth's "Seminumerical Algorithms". */
546 int num_hi_sig, den_hi_sig;
547 unsigned HOST_WIDE_INT quo_est, scale;
548
549 /* Find the highest non-zero divisor digit. */
550 for (i = 4 - 1; ; i--)
551 if (den[i] != 0) {
552 den_hi_sig = i;
553 break;
554 }
555
556 /* Insure that the first digit of the divisor is at least BASE/2.
557 This is required by the quotient digit estimation algorithm. */
558
559 scale = BASE / (den[den_hi_sig] + 1);
560 if (scale > 1) { /* scale divisor and dividend */
561 carry = 0;
562 for (i = 0; i <= 4 - 1; i++) {
563 work = (num[i] * scale) + carry;
564 num[i] = LOWPART (work);
565 carry = HIGHPART (work);
566 } num[4] = carry;
567 carry = 0;
568 for (i = 0; i <= 4 - 1; i++) {
569 work = (den[i] * scale) + carry;
570 den[i] = LOWPART (work);
571 carry = HIGHPART (work);
572 if (den[i] != 0) den_hi_sig = i;
573 }
574 }
575
576 num_hi_sig = 4;
577
578 /* Main loop */
579 for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--) {
580 /* guess the next quotient digit, quo_est, by dividing the first
581 two remaining dividend digits by the high order quotient digit.
582 quo_est is never low and is at most 2 high. */
583 unsigned HOST_WIDE_INT tmp;
584
585 num_hi_sig = i + den_hi_sig + 1;
586 work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
587 if (num[num_hi_sig] != den[den_hi_sig])
588 quo_est = work / den[den_hi_sig];
589 else
590 quo_est = BASE - 1;
591
592 /* refine quo_est so it's usually correct, and at most one high. */
593 tmp = work - quo_est * den[den_hi_sig];
594 if (tmp < BASE
595 && den[den_hi_sig - 1] * quo_est > (tmp * BASE + num[num_hi_sig - 2]))
596 quo_est--;
597
598 /* Try QUO_EST as the quotient digit, by multiplying the
599 divisor by QUO_EST and subtracting from the remaining dividend.
600 Keep in mind that QUO_EST is the I - 1st digit. */
601
602 carry = 0;
603 for (j = 0; j <= den_hi_sig; j++)
604 {
605 work = quo_est * den[j] + carry;
606 carry = HIGHPART (work);
607 work = num[i + j] - LOWPART (work);
608 num[i + j] = LOWPART (work);
609 carry += HIGHPART (work) != 0;
610 }
611
612 /* if quo_est was high by one, then num[i] went negative and
613 we need to correct things. */
614
615 if (num[num_hi_sig] < carry)
616 {
617 quo_est--;
618 carry = 0; /* add divisor back in */
619 for (j = 0; j <= den_hi_sig; j++)
620 {
621 work = num[i + j] + den[j] + carry;
622 carry = HIGHPART (work);
623 num[i + j] = LOWPART (work);
624 }
625 num [num_hi_sig] += carry;
626 }
627
628 /* store the quotient digit. */
629 quo[i] = quo_est;
630 }
631 }
632
633 decode (quo, lquo, hquo);
634
635 finish_up:
636 /* if result is negative, make it so. */
637 if (quo_neg)
638 neg_double (*lquo, *hquo, lquo, hquo);
639
640 /* compute trial remainder: rem = num - (quo * den) */
641 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
642 neg_double (*lrem, *hrem, lrem, hrem);
643 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
644
645 switch (code)
646 {
647 case TRUNC_DIV_EXPR:
648 case TRUNC_MOD_EXPR: /* round toward zero */
649 case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
650 return overflow;
651
652 case FLOOR_DIV_EXPR:
653 case FLOOR_MOD_EXPR: /* round toward negative infinity */
654 if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
655 {
656 /* quo = quo - 1; */
657 add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
658 lquo, hquo);
659 }
660 else return overflow;
661 break;
662
663 case CEIL_DIV_EXPR:
664 case CEIL_MOD_EXPR: /* round toward positive infinity */
665 if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
666 {
667 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
668 lquo, hquo);
669 }
670 else return overflow;
671 break;
672
673 case ROUND_DIV_EXPR:
674 case ROUND_MOD_EXPR: /* round to closest integer */
675 {
676 HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
677 HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
678
679 /* get absolute values */
680 if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
681 if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
682
683 /* if (2 * abs (lrem) >= abs (lden)) */
684 mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
685 labs_rem, habs_rem, <wice, &htwice);
686 if (((unsigned HOST_WIDE_INT) habs_den
687 < (unsigned HOST_WIDE_INT) htwice)
688 || (((unsigned HOST_WIDE_INT) habs_den
689 == (unsigned HOST_WIDE_INT) htwice)
690 && ((HOST_WIDE_INT unsigned) labs_den
691 < (unsigned HOST_WIDE_INT) ltwice)))
692 {
693 if (*hquo < 0)
694 /* quo = quo - 1; */
695 add_double (*lquo, *hquo,
696 (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
697 else
698 /* quo = quo + 1; */
699 add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
700 lquo, hquo);
701 }
702 else return overflow;
703 }
704 break;
705
706 default:
707 abort ();
708 }
709
710 /* compute true remainder: rem = num - (quo * den) */
711 mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
712 neg_double (*lrem, *hrem, lrem, hrem);
713 add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
714 return overflow;
715}
716
717#ifndef REAL_ARITHMETIC
718/* Effectively truncate a real value to represent the nearest possible value
719 in a narrower mode. The result is actually represented in the same data
720 type as the argument, but its value is usually different.
721
722 A trap may occur during the FP operations and it is the responsibility
723 of the calling function to have a handler established. */
724
725REAL_VALUE_TYPE
726real_value_truncate (mode, arg)
727 enum machine_mode mode;
728 REAL_VALUE_TYPE arg;
729{
730 return REAL_VALUE_TRUNCATE (mode, arg);
731}
732
733#if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
734
735/* Check for infinity in an IEEE double precision number. */
736
737int
738target_isinf (x)
739 REAL_VALUE_TYPE x;
740{
741 /* The IEEE 64-bit double format. */
742 union {
743 REAL_VALUE_TYPE d;
744 struct {
745 unsigned sign : 1;
746 unsigned exponent : 11;
747 unsigned mantissa1 : 20;
748 unsigned mantissa2;
749 } little_endian;
750 struct {
751 unsigned mantissa2;
752 unsigned mantissa1 : 20;
753 unsigned exponent : 11;
754 unsigned sign : 1;
755 } big_endian;
756 } u;
757
758 u.d = dconstm1;
759 if (u.big_endian.sign == 1)
760 {
761 u.d = x;
762 return (u.big_endian.exponent == 2047
763 && u.big_endian.mantissa1 == 0
764 && u.big_endian.mantissa2 == 0);
765 }
766 else
767 {
768 u.d = x;
769 return (u.little_endian.exponent == 2047
770 && u.little_endian.mantissa1 == 0
771 && u.little_endian.mantissa2 == 0);
772 }
773}
774
775/* Check whether an IEEE double precision number is a NaN. */
776
777int
778target_isnan (x)
779 REAL_VALUE_TYPE x;
780{
781 /* The IEEE 64-bit double format. */
782 union {
783 REAL_VALUE_TYPE d;
784 struct {
785 unsigned sign : 1;
786 unsigned exponent : 11;
787 unsigned mantissa1 : 20;
788 unsigned mantissa2;
789 } little_endian;
790 struct {
791 unsigned mantissa2;
792 unsigned mantissa1 : 20;
793 unsigned exponent : 11;
794 unsigned sign : 1;
795 } big_endian;
796 } u;
797
798 u.d = dconstm1;
799 if (u.big_endian.sign == 1)
800 {
801 u.d = x;
802 return (u.big_endian.exponent == 2047
803 && (u.big_endian.mantissa1 != 0
804 || u.big_endian.mantissa2 != 0));
805 }
806 else
807 {
808 u.d = x;
809 return (u.little_endian.exponent == 2047
810 && (u.little_endian.mantissa1 != 0
811 || u.little_endian.mantissa2 != 0));
812 }
813}
814
815/* Check for a negative IEEE double precision number. */
816
817int
818target_negative (x)
819 REAL_VALUE_TYPE x;
820{
821 /* The IEEE 64-bit double format. */
822 union {
823 REAL_VALUE_TYPE d;
824 struct {
825 unsigned sign : 1;
826 unsigned exponent : 11;
827 unsigned mantissa1 : 20;
828 unsigned mantissa2;
829 } little_endian;
830 struct {
831 unsigned mantissa2;
832 unsigned mantissa1 : 20;
833 unsigned exponent : 11;
834 unsigned sign : 1;
835 } big_endian;
836 } u;
837
838 u.d = dconstm1;
839 if (u.big_endian.sign == 1)
840 {
841 u.d = x;
842 return u.big_endian.sign;
843 }
844 else
845 {
846 u.d = x;
847 return u.little_endian.sign;
848 }
849}
850#else /* Target not IEEE */
851
852/* Let's assume other float formats don't have infinity.
853 (This can be overridden by redefining REAL_VALUE_ISINF.) */
854
855target_isinf (x)
856 REAL_VALUE_TYPE x;
857{
858 return 0;
859}
860
861/* Let's assume other float formats don't have NaNs.
862 (This can be overridden by redefining REAL_VALUE_ISNAN.) */
863
864target_isnan (x)
865 REAL_VALUE_TYPE x;
866{
867 return 0;
868}
869
870/* Let's assume other float formats don't have minus zero.
871 (This can be overridden by redefining REAL_VALUE_NEGATIVE.) */
872
873target_negative (x)
874 REAL_VALUE_TYPE x;
875{
876 return x < 0;
877}
878#endif /* Target not IEEE */
879
880/* Try to change R into its exact multiplicative inverse in machine mode
881 MODE. Return nonzero function value if successful. */
882
883int
884exact_real_inverse (mode, r)
885 enum machine_mode mode;
886 REAL_VALUE_TYPE *r;
887{
|
| 888 jmp_buf float_error;
|
887 union
888 {
889 double d;
890 unsigned short i[4];
891 }x, t, y;
892 int i;
893
894 /* Usually disable if bounds checks are not reliable. */
895 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT) && !flag_pretend_float)
896 return 0;
897
898 /* Set array index to the less significant bits in the unions, depending
899 on the endian-ness of the host doubles.
900 Disable if insufficient information on the data structure. */
901#if HOST_FLOAT_FORMAT == UNKNOWN_FLOAT_FORMAT
902 return 0;
903#else
904#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
905#define K 2
906#else
907#if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
908#define K 2
909#else
910#define K (2 * HOST_FLOAT_WORDS_BIG_ENDIAN)
911#endif
912#endif
913#endif
914
915 if (setjmp (float_error))
916 {
917 /* Don't do the optimization if there was an arithmetic error. */
918fail:
919 set_float_handler (NULL_PTR);
920 return 0;
921 }
922 set_float_handler (float_error);
923
924 /* Domain check the argument. */
925 x.d = *r;
926 if (x.d == 0.0)
927 goto fail;
928
929#ifdef REAL_INFINITY
930 if (REAL_VALUE_ISINF (x.d) || REAL_VALUE_ISNAN (x.d))
931 goto fail;
932#endif
933
934 /* Compute the reciprocal and check for numerical exactness.
935 It is unnecessary to check all the significand bits to determine
936 whether X is a power of 2. If X is not, then it is impossible for
937 the bottom half significand of both X and 1/X to be all zero bits.
938 Hence we ignore the data structure of the top half and examine only
939 the low order bits of the two significands. */
940 t.d = 1.0 / x.d;
941 if (x.i[K] != 0 || x.i[K + 1] != 0 || t.i[K] != 0 || t.i[K + 1] != 0)
942 goto fail;
943
944 /* Truncate to the required mode and range-check the result. */
945 y.d = REAL_VALUE_TRUNCATE (mode, t.d);
946#ifdef CHECK_FLOAT_VALUE
947 i = 0;
948 if (CHECK_FLOAT_VALUE (mode, y.d, i))
949 goto fail;
950#endif
951
952 /* Fail if truncation changed the value. */
953 if (y.d != t.d || y.d == 0.0)
954 goto fail;
955
956#ifdef REAL_INFINITY
957 if (REAL_VALUE_ISINF (y.d) || REAL_VALUE_ISNAN (y.d))
958 goto fail;
959#endif
960
961 /* Output the reciprocal and return success flag. */
962 set_float_handler (NULL_PTR);
963 *r = y.d;
964 return 1;
965}
| 889 union
890 {
891 double d;
892 unsigned short i[4];
893 }x, t, y;
894 int i;
895
896 /* Usually disable if bounds checks are not reliable. */
897 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT) && !flag_pretend_float)
898 return 0;
899
900 /* Set array index to the less significant bits in the unions, depending
901 on the endian-ness of the host doubles.
902 Disable if insufficient information on the data structure. */
903#if HOST_FLOAT_FORMAT == UNKNOWN_FLOAT_FORMAT
904 return 0;
905#else
906#if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
907#define K 2
908#else
909#if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
910#define K 2
911#else
912#define K (2 * HOST_FLOAT_WORDS_BIG_ENDIAN)
913#endif
914#endif
915#endif
916
917 if (setjmp (float_error))
918 {
919 /* Don't do the optimization if there was an arithmetic error. */
920fail:
921 set_float_handler (NULL_PTR);
922 return 0;
923 }
924 set_float_handler (float_error);
925
926 /* Domain check the argument. */
927 x.d = *r;
928 if (x.d == 0.0)
929 goto fail;
930
931#ifdef REAL_INFINITY
932 if (REAL_VALUE_ISINF (x.d) || REAL_VALUE_ISNAN (x.d))
933 goto fail;
934#endif
935
936 /* Compute the reciprocal and check for numerical exactness.
937 It is unnecessary to check all the significand bits to determine
938 whether X is a power of 2. If X is not, then it is impossible for
939 the bottom half significand of both X and 1/X to be all zero bits.
940 Hence we ignore the data structure of the top half and examine only
941 the low order bits of the two significands. */
942 t.d = 1.0 / x.d;
943 if (x.i[K] != 0 || x.i[K + 1] != 0 || t.i[K] != 0 || t.i[K + 1] != 0)
944 goto fail;
945
946 /* Truncate to the required mode and range-check the result. */
947 y.d = REAL_VALUE_TRUNCATE (mode, t.d);
948#ifdef CHECK_FLOAT_VALUE
949 i = 0;
950 if (CHECK_FLOAT_VALUE (mode, y.d, i))
951 goto fail;
952#endif
953
954 /* Fail if truncation changed the value. */
955 if (y.d != t.d || y.d == 0.0)
956 goto fail;
957
958#ifdef REAL_INFINITY
959 if (REAL_VALUE_ISINF (y.d) || REAL_VALUE_ISNAN (y.d))
960 goto fail;
961#endif
962
963 /* Output the reciprocal and return success flag. */
964 set_float_handler (NULL_PTR);
965 *r = y.d;
966 return 1;
967}
|
| 968
969
970/* Convert C9X hexadecimal floating point string constant S. Return
971 real value type in mode MODE. This function uses the host computer's
972 fp arithmetic when there is no REAL_ARITHMETIC. */
973
974REAL_VALUE_TYPE
975real_hex_to_f (s, mode)
976 char *s;
977 enum machine_mode mode;
978{
979 REAL_VALUE_TYPE ip;
980 char *p = s;
981 unsigned HOST_WIDE_INT low, high;
982 int frexpon, expon, shcount, nrmcount, k;
983 int sign, expsign, decpt, isfloat, isldouble, gotp, lost;
984 char c;
985
986 isldouble = 0;
987 isfloat = 0;
988 frexpon = 0;
989 expon = 0;
990 expsign = 1;
991 ip = 0.0;
992
993 while (*p == ' ' || *p == '\t')
994 ++p;
995
996 /* Sign, if any, comes first. */
997 sign = 1;
998 if (*p == '-')
999 {
1000 sign = -1;
1001 ++p;
1002 }
1003
1004 /* The string is supposed to start with 0x or 0X . */
1005 if (*p == '0')
1006 {
1007 ++p;
1008 if (*p == 'x' || *p == 'X')
1009 ++p;
1010 else
1011 abort ();
1012 }
1013 else
1014 abort ();
1015
1016 while (*p == '0')
1017 ++p;
1018
1019 high = 0;
1020 low = 0;
1021 lost = 0; /* Nonzero low order bits shifted out and discarded. */
1022 frexpon = 0; /* Bits after the decimal point. */
1023 expon = 0; /* Value of exponent. */
1024 decpt = 0; /* How many decimal points. */
1025 gotp = 0; /* How many P's. */
1026 shcount = 0;
1027 while ((c = *p) != '\0')
1028 {
1029 if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
1030 || (c >= 'a' && c <= 'f'))
1031 {
1032 k = c & 0x7f;
1033 if (k >= 'a')
1034 k = k - 'a' + 10;
1035 else if (k >= 'A')
1036 k = k - 'A' + 10;
1037 else
1038 k = k - '0';
1039
1040 if ((high & 0xf0000000) == 0)
1041 {
1042 high = (high << 4) + ((low >> 28) & 15);
1043 low = (low << 4) + k;
1044 shcount += 4;
1045 if (decpt)
1046 frexpon += 4;
1047 }
1048 else
1049 {
1050 /* Record nonzero lost bits. */
1051 lost |= k;
1052 if (!decpt)
1053 frexpon -= 4;
1054 }
1055 ++p;
1056 }
1057 else if ( c == '.')
1058 {
1059 ++decpt;
1060 ++p;
1061 }
1062 else if (c == 'p' || c == 'P')
1063 {
1064 ++gotp;
1065 ++p;
1066 /* Sign of exponent. */
1067 if (*p == '-')
1068 {
1069 expsign = -1;
1070 ++p;
1071 }
1072 /* Value of exponent.
1073 The exponent field is a decimal integer. */
1074 while (isdigit(*p))
1075 {
1076 k = (*p++ & 0x7f) - '0';
1077 expon = 10 * expon + k;
1078 }
1079 expon *= expsign;
1080 /* F suffix is ambiguous in the significand part
1081 so it must appear after the decimal exponent field. */
1082 if (*p == 'f' || *p == 'F')
1083 {
1084 isfloat = 1;
1085 ++p;
1086 break;
1087 }
1088 }
1089 else if (c == 'l' || c == 'L')
1090 {
1091 isldouble = 1;
1092 ++p;
1093 break;
1094 }
1095 else
1096 break;
1097 }
1098 /* Abort if last character read was not legitimate. */
1099 c = *p;
1100 if ((c != '\0' && c != ' ' && c != '\n' && c != '\r') || (decpt > 1))
1101 abort ();
1102 /* There must be either one decimal point or one p. */
1103 if (decpt == 0 && gotp == 0)
1104 abort ();
1105 shcount -= 4;
1106 if ((high == 0) && (low == 0))
1107 {
1108 return dconst0;
1109 }
1110
1111 /* Normalize. */
1112 nrmcount = 0;
1113 if (high == 0)
1114 {
1115 high = low;
1116 low = 0;
1117 nrmcount += 32;
1118 }
1119 /* Leave a high guard bit for carry-out. */
1120 if ((high & 0x80000000) != 0)
1121 {
1122 lost |= low & 1;
1123 low = (low >> 1) | (high << 31);
1124 high = high >> 1;
1125 nrmcount -= 1;
1126 }
1127 if ((high & 0xffff8000) == 0)
1128 {
1129 high = (high << 16) + ((low >> 16) & 0xffff);
1130 low = low << 16;
1131 nrmcount += 16;
1132 }
1133 while ((high & 0xc0000000) == 0)
1134 {
1135 high = (high << 1) + ((low >> 31) & 1);
1136 low = low << 1;
1137 nrmcount += 1;
1138 }
1139 if (isfloat || GET_MODE_SIZE(mode) == UNITS_PER_WORD)
1140 {
1141 /* Keep 24 bits precision, bits 0x7fffff80.
1142 Rounding bit is 0x40. */
1143 lost = lost | low | (high & 0x3f);
1144 low = 0;
1145 if (high & 0x40)
1146 {
1147 if ((high & 0x80) || lost)
1148 high += 0x40;
1149 }
1150 high &= 0xffffff80;
1151 }
1152 else
1153 {
1154 /* We need real.c to do long double formats, so here default
1155 to double precision. */
1156#if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1157 /* IEEE double.
1158 Keep 53 bits precision, bits 0x7fffffff fffffc00.
1159 Rounding bit is low word 0x200. */
1160 lost = lost | (low & 0x1ff);
1161 if (low & 0x200)
1162 {
1163 if ((low & 0x400) || lost)
1164 {
1165 low = (low + 0x200) & 0xfffffc00;
1166 if (low == 0)
1167 high += 1;
1168 }
1169 }
1170 low &= 0xfffffc00;
1171#else
1172 /* Assume it's a VAX with 56-bit significand,
1173 bits 0x7fffffff ffffff80. */
1174 lost = lost | (low & 0x7f);
1175 if (low & 0x40)
1176 {
1177 if ((low & 0x80) || lost)
1178 {
1179 low = (low + 0x40) & 0xffffff80;
1180 if (low == 0)
1181 high += 1;
1182 }
1183 }
1184 low &= 0xffffff80;
1185#endif
1186 }
1187 ip = (double) high;
1188 ip = REAL_VALUE_LDEXP (ip, 32) + (double) low;
1189 /* Apply shifts and exponent value as power of 2. */
1190 ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
1191
1192 if (sign < 0)
1193 ip = -ip;
1194 return ip;
1195}
1196
|
966#endif /* no REAL_ARITHMETIC */
967
968/* Split a tree IN into a constant and a variable part
969 that could be combined with CODE to make IN.
970 CODE must be a commutative arithmetic operation.
971 Store the constant part into *CONP and the variable in &VARP.
972 Return 1 if this was done; zero means the tree IN did not decompose
973 this way.
974
975 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
976 Therefore, we must tell the caller whether the variable part
977 was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
978 The value stored is the coefficient for the variable term.
979 The constant term we return should always be added;
980 we negate it if necessary. */
981
982static int
983split_tree (in, code, varp, conp, varsignp)
984 tree in;
985 enum tree_code code;
986 tree *varp, *conp;
987 int *varsignp;
988{
989 register tree outtype = TREE_TYPE (in);
990 *varp = 0;
991 *conp = 0;
992
993 /* Strip any conversions that don't change the machine mode. */
994 while ((TREE_CODE (in) == NOP_EXPR
995 || TREE_CODE (in) == CONVERT_EXPR)
996 && (TYPE_MODE (TREE_TYPE (in))
997 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
998 in = TREE_OPERAND (in, 0);
999
1000 if (TREE_CODE (in) == code
1001 || (! FLOAT_TYPE_P (TREE_TYPE (in))
1002 /* We can associate addition and subtraction together
1003 (even though the C standard doesn't say so)
1004 for integers because the value is not affected.
1005 For reals, the value might be affected, so we can't. */
1006 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1007 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1008 {
1009 enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
1010 if (code == INTEGER_CST)
1011 {
1012 *conp = TREE_OPERAND (in, 0);
1013 *varp = TREE_OPERAND (in, 1);
1014 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1015 && TREE_TYPE (*varp) != outtype)
1016 *varp = convert (outtype, *varp);
1017 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1018 return 1;
1019 }
1020 if (TREE_CONSTANT (TREE_OPERAND (in, 1)))
1021 {
1022 *conp = TREE_OPERAND (in, 1);
1023 *varp = TREE_OPERAND (in, 0);
1024 *varsignp = 1;
1025 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1026 && TREE_TYPE (*varp) != outtype)
1027 *varp = convert (outtype, *varp);
1028 if (TREE_CODE (in) == MINUS_EXPR)
1029 {
1030 /* If operation is subtraction and constant is second,
1031 must negate it to get an additive constant.
1032 And this cannot be done unless it is a manifest constant.
1033 It could also be the address of a static variable.
1034 We cannot negate that, so give up. */
1035 if (TREE_CODE (*conp) == INTEGER_CST)
1036 /* Subtracting from integer_zero_node loses for long long. */
1037 *conp = fold (build1 (NEGATE_EXPR, TREE_TYPE (*conp), *conp));
1038 else
1039 return 0;
1040 }
1041 return 1;
1042 }
1043 if (TREE_CONSTANT (TREE_OPERAND (in, 0)))
1044 {
1045 *conp = TREE_OPERAND (in, 0);
1046 *varp = TREE_OPERAND (in, 1);
1047 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1048 && TREE_TYPE (*varp) != outtype)
1049 *varp = convert (outtype, *varp);
1050 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1051 return 1;
1052 }
1053 }
1054 return 0;
1055}
1056
1057/* Combine two integer constants ARG1 and ARG2 under operation CODE
1058 to produce a new constant.
1059
1060 If NOTRUNC is nonzero, do not truncate the result to fit the data type.
1061 If FORSIZE is nonzero, compute overflow for unsigned types. */
1062
1063static tree
1064int_const_binop (code, arg1, arg2, notrunc, forsize)
1065 enum tree_code code;
1066 register tree arg1, arg2;
1067 int notrunc, forsize;
1068{
1069 HOST_WIDE_INT int1l, int1h, int2l, int2h;
1070 HOST_WIDE_INT low, hi;
1071 HOST_WIDE_INT garbagel, garbageh;
1072 register tree t;
1073 int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1074 int overflow = 0;
1075 int no_overflow = 0;
1076
1077 int1l = TREE_INT_CST_LOW (arg1);
1078 int1h = TREE_INT_CST_HIGH (arg1);
1079 int2l = TREE_INT_CST_LOW (arg2);
1080 int2h = TREE_INT_CST_HIGH (arg2);
1081
1082 switch (code)
1083 {
1084 case BIT_IOR_EXPR:
1085 low = int1l | int2l, hi = int1h | int2h;
1086 break;
1087
1088 case BIT_XOR_EXPR:
1089 low = int1l ^ int2l, hi = int1h ^ int2h;
1090 break;
1091
1092 case BIT_AND_EXPR:
1093 low = int1l & int2l, hi = int1h & int2h;
1094 break;
1095
1096 case BIT_ANDTC_EXPR:
1097 low = int1l & ~int2l, hi = int1h & ~int2h;
1098 break;
1099
1100 case RSHIFT_EXPR:
1101 int2l = - int2l;
1102 case LSHIFT_EXPR:
1103 /* It's unclear from the C standard whether shifts can overflow.
1104 The following code ignores overflow; perhaps a C standard
1105 interpretation ruling is needed. */
1106 lshift_double (int1l, int1h, int2l,
1107 TYPE_PRECISION (TREE_TYPE (arg1)),
1108 &low, &hi,
1109 !uns);
1110 no_overflow = 1;
1111 break;
1112
1113 case RROTATE_EXPR:
1114 int2l = - int2l;
1115 case LROTATE_EXPR:
1116 lrotate_double (int1l, int1h, int2l,
1117 TYPE_PRECISION (TREE_TYPE (arg1)),
1118 &low, &hi);
1119 break;
1120
1121 case PLUS_EXPR:
1122 overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1123 break;
1124
1125 case MINUS_EXPR:
1126 neg_double (int2l, int2h, &low, &hi);
1127 add_double (int1l, int1h, low, hi, &low, &hi);
1128 overflow = overflow_sum_sign (hi, int2h, int1h);
1129 break;
1130
1131 case MULT_EXPR:
1132 overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1133 break;
1134
1135 case TRUNC_DIV_EXPR:
1136 case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1137 case EXACT_DIV_EXPR:
1138 /* This is a shortcut for a common special case. */
1139 if (int2h == 0 && int2l > 0
1140 && ! TREE_CONSTANT_OVERFLOW (arg1)
1141 && ! TREE_CONSTANT_OVERFLOW (arg2)
1142 && int1h == 0 && int1l >= 0)
1143 {
1144 if (code == CEIL_DIV_EXPR)
1145 int1l += int2l - 1;
1146 low = int1l / int2l, hi = 0;
1147 break;
1148 }
1149
1150 /* ... fall through ... */
1151
1152 case ROUND_DIV_EXPR:
1153 if (int2h == 0 && int2l == 1)
1154 {
1155 low = int1l, hi = int1h;
1156 break;
1157 }
1158 if (int1l == int2l && int1h == int2h
1159 && ! (int1l == 0 && int1h == 0))
1160 {
1161 low = 1, hi = 0;
1162 break;
1163 }
1164 overflow = div_and_round_double (code, uns,
1165 int1l, int1h, int2l, int2h,
1166 &low, &hi, &garbagel, &garbageh);
1167 break;
1168
1169 case TRUNC_MOD_EXPR:
1170 case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1171 /* This is a shortcut for a common special case. */
1172 if (int2h == 0 && int2l > 0
1173 && ! TREE_CONSTANT_OVERFLOW (arg1)
1174 && ! TREE_CONSTANT_OVERFLOW (arg2)
1175 && int1h == 0 && int1l >= 0)
1176 {
1177 if (code == CEIL_MOD_EXPR)
1178 int1l += int2l - 1;
1179 low = int1l % int2l, hi = 0;
1180 break;
1181 }
1182
1183 /* ... fall through ... */
1184
1185 case ROUND_MOD_EXPR:
1186 overflow = div_and_round_double (code, uns,
1187 int1l, int1h, int2l, int2h,
1188 &garbagel, &garbageh, &low, &hi);
1189 break;
1190
1191 case MIN_EXPR:
1192 case MAX_EXPR:
1193 if (uns)
1194 {
1195 low = (((unsigned HOST_WIDE_INT) int1h
1196 < (unsigned HOST_WIDE_INT) int2h)
1197 || (((unsigned HOST_WIDE_INT) int1h
1198 == (unsigned HOST_WIDE_INT) int2h)
1199 && ((unsigned HOST_WIDE_INT) int1l
1200 < (unsigned HOST_WIDE_INT) int2l)));
1201 }
1202 else
1203 {
1204 low = ((int1h < int2h)
1205 || ((int1h == int2h)
1206 && ((unsigned HOST_WIDE_INT) int1l
1207 < (unsigned HOST_WIDE_INT) int2l)));
1208 }
1209 if (low == (code == MIN_EXPR))
1210 low = int1l, hi = int1h;
1211 else
1212 low = int2l, hi = int2h;
1213 break;
1214
1215 default:
1216 abort ();
1217 }
1218
1219 if (TREE_TYPE (arg1) == sizetype && hi == 0
1220 && low >= 0
1221 && (TYPE_MAX_VALUE (sizetype) == NULL
1222 || low <= TREE_INT_CST_LOW (TYPE_MAX_VALUE (sizetype)))
1223 && ! overflow
1224 && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
1225 t = size_int (low);
1226 else
1227 {
1228 t = build_int_2 (low, hi);
1229 TREE_TYPE (t) = TREE_TYPE (arg1);
1230 }
1231
1232 TREE_OVERFLOW (t)
1233 = ((notrunc ? (!uns || forsize) && overflow
1234 : force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
1235 | TREE_OVERFLOW (arg1)
1236 | TREE_OVERFLOW (arg2));
1237 /* If we're doing a size calculation, unsigned arithmetic does overflow.
1238 So check if force_fit_type truncated the value. */
1239 if (forsize
1240 && ! TREE_OVERFLOW (t)
1241 && (TREE_INT_CST_HIGH (t) != hi
1242 || TREE_INT_CST_LOW (t) != low))
1243 TREE_OVERFLOW (t) = 1;
1244 TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1245 | TREE_CONSTANT_OVERFLOW (arg1)
1246 | TREE_CONSTANT_OVERFLOW (arg2));
1247 return t;
1248}
1249
| 1197#endif /* no REAL_ARITHMETIC */
1198
1199/* Split a tree IN into a constant and a variable part
1200 that could be combined with CODE to make IN.
1201 CODE must be a commutative arithmetic operation.
1202 Store the constant part into *CONP and the variable in &VARP.
1203 Return 1 if this was done; zero means the tree IN did not decompose
1204 this way.
1205
1206 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
1207 Therefore, we must tell the caller whether the variable part
1208 was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
1209 The value stored is the coefficient for the variable term.
1210 The constant term we return should always be added;
1211 we negate it if necessary. */
1212
1213static int
1214split_tree (in, code, varp, conp, varsignp)
1215 tree in;
1216 enum tree_code code;
1217 tree *varp, *conp;
1218 int *varsignp;
1219{
1220 register tree outtype = TREE_TYPE (in);
1221 *varp = 0;
1222 *conp = 0;
1223
1224 /* Strip any conversions that don't change the machine mode. */
1225 while ((TREE_CODE (in) == NOP_EXPR
1226 || TREE_CODE (in) == CONVERT_EXPR)
1227 && (TYPE_MODE (TREE_TYPE (in))
1228 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
1229 in = TREE_OPERAND (in, 0);
1230
1231 if (TREE_CODE (in) == code
1232 || (! FLOAT_TYPE_P (TREE_TYPE (in))
1233 /* We can associate addition and subtraction together
1234 (even though the C standard doesn't say so)
1235 for integers because the value is not affected.
1236 For reals, the value might be affected, so we can't. */
1237 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1238 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1239 {
1240 enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
1241 if (code == INTEGER_CST)
1242 {
1243 *conp = TREE_OPERAND (in, 0);
1244 *varp = TREE_OPERAND (in, 1);
1245 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1246 && TREE_TYPE (*varp) != outtype)
1247 *varp = convert (outtype, *varp);
1248 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1249 return 1;
1250 }
1251 if (TREE_CONSTANT (TREE_OPERAND (in, 1)))
1252 {
1253 *conp = TREE_OPERAND (in, 1);
1254 *varp = TREE_OPERAND (in, 0);
1255 *varsignp = 1;
1256 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1257 && TREE_TYPE (*varp) != outtype)
1258 *varp = convert (outtype, *varp);
1259 if (TREE_CODE (in) == MINUS_EXPR)
1260 {
1261 /* If operation is subtraction and constant is second,
1262 must negate it to get an additive constant.
1263 And this cannot be done unless it is a manifest constant.
1264 It could also be the address of a static variable.
1265 We cannot negate that, so give up. */
1266 if (TREE_CODE (*conp) == INTEGER_CST)
1267 /* Subtracting from integer_zero_node loses for long long. */
1268 *conp = fold (build1 (NEGATE_EXPR, TREE_TYPE (*conp), *conp));
1269 else
1270 return 0;
1271 }
1272 return 1;
1273 }
1274 if (TREE_CONSTANT (TREE_OPERAND (in, 0)))
1275 {
1276 *conp = TREE_OPERAND (in, 0);
1277 *varp = TREE_OPERAND (in, 1);
1278 if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1279 && TREE_TYPE (*varp) != outtype)
1280 *varp = convert (outtype, *varp);
1281 *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1282 return 1;
1283 }
1284 }
1285 return 0;
1286}
1287
1288/* Combine two integer constants ARG1 and ARG2 under operation CODE
1289 to produce a new constant.
1290
1291 If NOTRUNC is nonzero, do not truncate the result to fit the data type.
1292 If FORSIZE is nonzero, compute overflow for unsigned types. */
1293
1294static tree
1295int_const_binop (code, arg1, arg2, notrunc, forsize)
1296 enum tree_code code;
1297 register tree arg1, arg2;
1298 int notrunc, forsize;
1299{
1300 HOST_WIDE_INT int1l, int1h, int2l, int2h;
1301 HOST_WIDE_INT low, hi;
1302 HOST_WIDE_INT garbagel, garbageh;
1303 register tree t;
1304 int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1305 int overflow = 0;
1306 int no_overflow = 0;
1307
1308 int1l = TREE_INT_CST_LOW (arg1);
1309 int1h = TREE_INT_CST_HIGH (arg1);
1310 int2l = TREE_INT_CST_LOW (arg2);
1311 int2h = TREE_INT_CST_HIGH (arg2);
1312
1313 switch (code)
1314 {
1315 case BIT_IOR_EXPR:
1316 low = int1l | int2l, hi = int1h | int2h;
1317 break;
1318
1319 case BIT_XOR_EXPR:
1320 low = int1l ^ int2l, hi = int1h ^ int2h;
1321 break;
1322
1323 case BIT_AND_EXPR:
1324 low = int1l & int2l, hi = int1h & int2h;
1325 break;
1326
1327 case BIT_ANDTC_EXPR:
1328 low = int1l & ~int2l, hi = int1h & ~int2h;
1329 break;
1330
1331 case RSHIFT_EXPR:
1332 int2l = - int2l;
1333 case LSHIFT_EXPR:
1334 /* It's unclear from the C standard whether shifts can overflow.
1335 The following code ignores overflow; perhaps a C standard
1336 interpretation ruling is needed. */
1337 lshift_double (int1l, int1h, int2l,
1338 TYPE_PRECISION (TREE_TYPE (arg1)),
1339 &low, &hi,
1340 !uns);
1341 no_overflow = 1;
1342 break;
1343
1344 case RROTATE_EXPR:
1345 int2l = - int2l;
1346 case LROTATE_EXPR:
1347 lrotate_double (int1l, int1h, int2l,
1348 TYPE_PRECISION (TREE_TYPE (arg1)),
1349 &low, &hi);
1350 break;
1351
1352 case PLUS_EXPR:
1353 overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1354 break;
1355
1356 case MINUS_EXPR:
1357 neg_double (int2l, int2h, &low, &hi);
1358 add_double (int1l, int1h, low, hi, &low, &hi);
1359 overflow = overflow_sum_sign (hi, int2h, int1h);
1360 break;
1361
1362 case MULT_EXPR:
1363 overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1364 break;
1365
1366 case TRUNC_DIV_EXPR:
1367 case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1368 case EXACT_DIV_EXPR:
1369 /* This is a shortcut for a common special case. */
1370 if (int2h == 0 && int2l > 0
1371 && ! TREE_CONSTANT_OVERFLOW (arg1)
1372 && ! TREE_CONSTANT_OVERFLOW (arg2)
1373 && int1h == 0 && int1l >= 0)
1374 {
1375 if (code == CEIL_DIV_EXPR)
1376 int1l += int2l - 1;
1377 low = int1l / int2l, hi = 0;
1378 break;
1379 }
1380
1381 /* ... fall through ... */
1382
1383 case ROUND_DIV_EXPR:
1384 if (int2h == 0 && int2l == 1)
1385 {
1386 low = int1l, hi = int1h;
1387 break;
1388 }
1389 if (int1l == int2l && int1h == int2h
1390 && ! (int1l == 0 && int1h == 0))
1391 {
1392 low = 1, hi = 0;
1393 break;
1394 }
1395 overflow = div_and_round_double (code, uns,
1396 int1l, int1h, int2l, int2h,
1397 &low, &hi, &garbagel, &garbageh);
1398 break;
1399
1400 case TRUNC_MOD_EXPR:
1401 case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1402 /* This is a shortcut for a common special case. */
1403 if (int2h == 0 && int2l > 0
1404 && ! TREE_CONSTANT_OVERFLOW (arg1)
1405 && ! TREE_CONSTANT_OVERFLOW (arg2)
1406 && int1h == 0 && int1l >= 0)
1407 {
1408 if (code == CEIL_MOD_EXPR)
1409 int1l += int2l - 1;
1410 low = int1l % int2l, hi = 0;
1411 break;
1412 }
1413
1414 /* ... fall through ... */
1415
1416 case ROUND_MOD_EXPR:
1417 overflow = div_and_round_double (code, uns,
1418 int1l, int1h, int2l, int2h,
1419 &garbagel, &garbageh, &low, &hi);
1420 break;
1421
1422 case MIN_EXPR:
1423 case MAX_EXPR:
1424 if (uns)
1425 {
1426 low = (((unsigned HOST_WIDE_INT) int1h
1427 < (unsigned HOST_WIDE_INT) int2h)
1428 || (((unsigned HOST_WIDE_INT) int1h
1429 == (unsigned HOST_WIDE_INT) int2h)
1430 && ((unsigned HOST_WIDE_INT) int1l
1431 < (unsigned HOST_WIDE_INT) int2l)));
1432 }
1433 else
1434 {
1435 low = ((int1h < int2h)
1436 || ((int1h == int2h)
1437 && ((unsigned HOST_WIDE_INT) int1l
1438 < (unsigned HOST_WIDE_INT) int2l)));
1439 }
1440 if (low == (code == MIN_EXPR))
1441 low = int1l, hi = int1h;
1442 else
1443 low = int2l, hi = int2h;
1444 break;
1445
1446 default:
1447 abort ();
1448 }
1449
1450 if (TREE_TYPE (arg1) == sizetype && hi == 0
1451 && low >= 0
1452 && (TYPE_MAX_VALUE (sizetype) == NULL
1453 || low <= TREE_INT_CST_LOW (TYPE_MAX_VALUE (sizetype)))
1454 && ! overflow
1455 && ! TREE_OVERFLOW (arg1) && ! TREE_OVERFLOW (arg2))
1456 t = size_int (low);
1457 else
1458 {
1459 t = build_int_2 (low, hi);
1460 TREE_TYPE (t) = TREE_TYPE (arg1);
1461 }
1462
1463 TREE_OVERFLOW (t)
1464 = ((notrunc ? (!uns || forsize) && overflow
1465 : force_fit_type (t, (!uns || forsize) && overflow) && ! no_overflow)
1466 | TREE_OVERFLOW (arg1)
1467 | TREE_OVERFLOW (arg2));
1468 /* If we're doing a size calculation, unsigned arithmetic does overflow.
1469 So check if force_fit_type truncated the value. */
1470 if (forsize
1471 && ! TREE_OVERFLOW (t)
1472 && (TREE_INT_CST_HIGH (t) != hi
1473 || TREE_INT_CST_LOW (t) != low))
1474 TREE_OVERFLOW (t) = 1;
1475 TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1476 | TREE_CONSTANT_OVERFLOW (arg1)
1477 | TREE_CONSTANT_OVERFLOW (arg2));
1478 return t;
1479}
1480
|
| 1481struct cb_args
1482{
1483 /* Input */
1484 tree arg1;
1485 REAL_VALUE_TYPE d1, d2;
1486 enum tree_code code;
1487 /* Output */
1488 tree t;
1489};
1490
1491static void
1492const_binop_1 (data)
1493 PTR data;
1494{
1495 struct cb_args * args = (struct cb_args *) data;
1496 REAL_VALUE_TYPE value;
1497
1498#ifdef REAL_ARITHMETIC
1499 REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
1500#else
1501 switch (args->code)
1502 {
1503 case PLUS_EXPR:
1504 value = args->d1 + args->d2;
1505 break;
1506
1507 case MINUS_EXPR:
1508 value = args->d1 - args->d2;
1509 break;
1510
1511 case MULT_EXPR:
1512 value = args->d1 * args->d2;
1513 break;
1514
1515 case RDIV_EXPR:
1516#ifndef REAL_INFINITY
1517 if (args->d2 == 0)
1518 abort ();
1519#endif
1520
1521 value = args->d1 / args->d2;
1522 break;
1523
1524 case MIN_EXPR:
1525 value = MIN (args->d1, args->d2);
1526 break;
1527
1528 case MAX_EXPR:
1529 value = MAX (args->d1, args->d2);
1530 break;
1531
1532 default:
1533 abort ();
1534 }
1535#endif /* no REAL_ARITHMETIC */
1536 args->t =
1537 build_real (TREE_TYPE (args->arg1),
1538 real_value_truncate (TYPE_MODE (TREE_TYPE (args->arg1)),
1539 value));
1540}
1541
|
1250/* Combine two constants ARG1 and ARG2 under operation CODE
1251 to produce a new constant.
1252 We assume ARG1 and ARG2 have the same data type,
1253 or at least are the same kind of constant and the same machine mode.
1254
1255 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1256
1257static tree
1258const_binop (code, arg1, arg2, notrunc)
1259 enum tree_code code;
1260 register tree arg1, arg2;
1261 int notrunc;
1262{
1263 STRIP_NOPS (arg1); STRIP_NOPS (arg2);
1264
1265 if (TREE_CODE (arg1) == INTEGER_CST)
1266 return int_const_binop (code, arg1, arg2, notrunc, 0);
1267
1268#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1269 if (TREE_CODE (arg1) == REAL_CST)
1270 {
1271 REAL_VALUE_TYPE d1;
1272 REAL_VALUE_TYPE d2;
1273 int overflow = 0;
| 1542/* Combine two constants ARG1 and ARG2 under operation CODE
1543 to produce a new constant.
1544 We assume ARG1 and ARG2 have the same data type,
1545 or at least are the same kind of constant and the same machine mode.
1546
1547 If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1548
1549static tree
1550const_binop (code, arg1, arg2, notrunc)
1551 enum tree_code code;
1552 register tree arg1, arg2;
1553 int notrunc;
1554{
1555 STRIP_NOPS (arg1); STRIP_NOPS (arg2);
1556
1557 if (TREE_CODE (arg1) == INTEGER_CST)
1558 return int_const_binop (code, arg1, arg2, notrunc, 0);
1559
1560#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1561 if (TREE_CODE (arg1) == REAL_CST)
1562 {
1563 REAL_VALUE_TYPE d1;
1564 REAL_VALUE_TYPE d2;
1565 int overflow = 0;
|
1274 REAL_VALUE_TYPE value;
| |
1275 tree t;
| 1566 tree t;
|
| 1567 struct cb_args args;
|
1276
1277 d1 = TREE_REAL_CST (arg1);
1278 d2 = TREE_REAL_CST (arg2);
1279
1280 /* If either operand is a NaN, just return it. Otherwise, set up
1281 for floating-point trap; we return an overflow. */
1282 if (REAL_VALUE_ISNAN (d1))
1283 return arg1;
1284 else if (REAL_VALUE_ISNAN (d2))
1285 return arg2;
| 1568
1569 d1 = TREE_REAL_CST (arg1);
1570 d2 = TREE_REAL_CST (arg2);
1571
1572 /* If either operand is a NaN, just return it. Otherwise, set up
1573 for floating-point trap; we return an overflow. */
1574 if (REAL_VALUE_ISNAN (d1))
1575 return arg1;
1576 else if (REAL_VALUE_ISNAN (d2))
1577 return arg2;
|
1286 else if (setjmp (float_error))
| 1578
1579 /* Setup input for const_binop_1() */
1580 args.arg1 = arg1;
1581 args.d1 = d1;
1582 args.d2 = d2;
1583 args.code = code;
1584
1585 if (do_float_handler (const_binop_1, (PTR) &args))
|
1287 {
| 1586 {
|
| 1587 /* Receive output from const_binop_1() */
1588 t = args.t;
1589 }
1590 else
1591 {
1592 /* We got an exception from const_binop_1() */
|
1288 t = copy_node (arg1);
1289 overflow = 1;
| 1593 t = copy_node (arg1);
1594 overflow = 1;
|
1290 goto got_float;
| |
1291 }
1292
| 1595 }
1596
|
1293 set_float_handler (float_error);
1294
1295#ifdef REAL_ARITHMETIC
1296 REAL_ARITHMETIC (value, code, d1, d2);
1297#else
1298 switch (code)
1299 {
1300 case PLUS_EXPR:
1301 value = d1 + d2;
1302 break;
1303
1304 case MINUS_EXPR:
1305 value = d1 - d2;
1306 break;
1307
1308 case MULT_EXPR:
1309 value = d1 * d2;
1310 break;
1311
1312 case RDIV_EXPR:
1313#ifndef REAL_INFINITY
1314 if (d2 == 0)
1315 abort ();
1316#endif
1317
1318 value = d1 / d2;
1319 break;
1320
1321 case MIN_EXPR:
1322 value = MIN (d1, d2);
1323 break;
1324
1325 case MAX_EXPR:
1326 value = MAX (d1, d2);
1327 break;
1328
1329 default:
1330 abort ();
1331 }
1332#endif /* no REAL_ARITHMETIC */
1333 t = build_real (TREE_TYPE (arg1),
1334 real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
1335 got_float:
1336 set_float_handler (NULL_PTR);
1337
| |
1338 TREE_OVERFLOW (t)
1339 = (force_fit_type (t, overflow)
1340 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1341 TREE_CONSTANT_OVERFLOW (t)
1342 = TREE_OVERFLOW (t)
1343 | TREE_CONSTANT_OVERFLOW (arg1)
1344 | TREE_CONSTANT_OVERFLOW (arg2);
1345 return t;
1346 }
1347#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1348 if (TREE_CODE (arg1) == COMPLEX_CST)
1349 {
1350 register tree type = TREE_TYPE (arg1);
1351 register tree r1 = TREE_REALPART (arg1);
1352 register tree i1 = TREE_IMAGPART (arg1);
1353 register tree r2 = TREE_REALPART (arg2);
1354 register tree i2 = TREE_IMAGPART (arg2);
1355 register tree t;
1356
1357 switch (code)
1358 {
1359 case PLUS_EXPR:
1360 t = build_complex (type,
1361 const_binop (PLUS_EXPR, r1, r2, notrunc),
1362 const_binop (PLUS_EXPR, i1, i2, notrunc));
1363 break;
1364
1365 case MINUS_EXPR:
1366 t = build_complex (type,
1367 const_binop (MINUS_EXPR, r1, r2, notrunc),
1368 const_binop (MINUS_EXPR, i1, i2, notrunc));
1369 break;
1370
1371 case MULT_EXPR:
1372 t = build_complex (type,
1373 const_binop (MINUS_EXPR,
1374 const_binop (MULT_EXPR,
1375 r1, r2, notrunc),
1376 const_binop (MULT_EXPR,
1377 i1, i2, notrunc),
1378 notrunc),
1379 const_binop (PLUS_EXPR,
1380 const_binop (MULT_EXPR,
1381 r1, i2, notrunc),
1382 const_binop (MULT_EXPR,
1383 i1, r2, notrunc),
1384 notrunc));
1385 break;
1386
1387 case RDIV_EXPR:
1388 {
1389 register tree magsquared
1390 = const_binop (PLUS_EXPR,
1391 const_binop (MULT_EXPR, r2, r2, notrunc),
1392 const_binop (MULT_EXPR, i2, i2, notrunc),
1393 notrunc);
1394
1395 t = build_complex (type,
1396 const_binop
1397 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1398 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1399 const_binop (PLUS_EXPR,
1400 const_binop (MULT_EXPR, r1, r2,
1401 notrunc),
1402 const_binop (MULT_EXPR, i1, i2,
1403 notrunc),
1404 notrunc),
1405 magsquared, notrunc),
1406 const_binop
1407 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1408 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1409 const_binop (MINUS_EXPR,
1410 const_binop (MULT_EXPR, i1, r2,
1411 notrunc),
1412 const_binop (MULT_EXPR, r1, i2,
1413 notrunc),
1414 notrunc),
1415 magsquared, notrunc));
1416 }
1417 break;
1418
1419 default:
1420 abort ();
1421 }
1422 return t;
1423 }
1424 return 0;
1425}
1426
1427/* Return an INTEGER_CST with value V . The type is determined by bit_p:
1428 if it is zero, the type is taken from sizetype; if it is one, the type
1429 is taken from bitsizetype. */
1430
1431tree
1432size_int_wide (number, high, bit_p)
1433 unsigned HOST_WIDE_INT number, high;
1434 int bit_p;
1435{
1436 register tree t;
1437 /* Type-size nodes already made for small sizes. */
1438 static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1][2];
1439
1440 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high
1441 && size_table[number][bit_p] != 0)
1442 return size_table[number][bit_p];
1443 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high)
1444 {
1445 push_obstacks_nochange ();
1446 /* Make this a permanent node. */
1447 end_temporary_allocation ();
1448 t = build_int_2 (number, 0);
1449 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1450 size_table[number][bit_p] = t;
1451 pop_obstacks ();
1452 }
1453 else
1454 {
1455 t = build_int_2 (number, high);
1456 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1457 TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
1458 }
1459 return t;
1460}
1461
1462/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1463 CODE is a tree code. Data type is taken from `sizetype',
1464 If the operands are constant, so is the result. */
1465
1466tree
1467size_binop (code, arg0, arg1)
1468 enum tree_code code;
1469 tree arg0, arg1;
1470{
1471 /* Handle the special case of two integer constants faster. */
1472 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1473 {
1474 /* And some specific cases even faster than that. */
1475 if (code == PLUS_EXPR && integer_zerop (arg0))
1476 return arg1;
1477 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1478 && integer_zerop (arg1))
1479 return arg0;
1480 else if (code == MULT_EXPR && integer_onep (arg0))
1481 return arg1;
1482
1483 /* Handle general case of two integer constants. */
1484 return int_const_binop (code, arg0, arg1, 0, 1);
1485 }
1486
1487 if (arg0 == error_mark_node || arg1 == error_mark_node)
1488 return error_mark_node;
1489
1490 return fold (build (code, sizetype, arg0, arg1));
1491}
1492
1493/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1494 CODE is a tree code. Data type is taken from `ssizetype',
1495 If the operands are constant, so is the result. */
1496
1497tree
1498ssize_binop (code, arg0, arg1)
1499 enum tree_code code;
1500 tree arg0, arg1;
1501{
1502 /* Handle the special case of two integer constants faster. */
1503 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1504 {
1505 /* And some specific cases even faster than that. */
1506 if (code == PLUS_EXPR && integer_zerop (arg0))
1507 return arg1;
1508 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1509 && integer_zerop (arg1))
1510 return arg0;
1511 else if (code == MULT_EXPR && integer_onep (arg0))
1512 return arg1;
1513
1514 /* Handle general case of two integer constants. We convert
1515 arg0 to ssizetype because int_const_binop uses its type for the
1516 return value. */
1517 arg0 = convert (ssizetype, arg0);
1518 return int_const_binop (code, arg0, arg1, 0, 0);
1519 }
1520
1521 if (arg0 == error_mark_node || arg1 == error_mark_node)
1522 return error_mark_node;
1523
1524 return fold (build (code, ssizetype, arg0, arg1));
1525}
1526
| 1597 TREE_OVERFLOW (t)
1598 = (force_fit_type (t, overflow)
1599 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1600 TREE_CONSTANT_OVERFLOW (t)
1601 = TREE_OVERFLOW (t)
1602 | TREE_CONSTANT_OVERFLOW (arg1)
1603 | TREE_CONSTANT_OVERFLOW (arg2);
1604 return t;
1605 }
1606#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1607 if (TREE_CODE (arg1) == COMPLEX_CST)
1608 {
1609 register tree type = TREE_TYPE (arg1);
1610 register tree r1 = TREE_REALPART (arg1);
1611 register tree i1 = TREE_IMAGPART (arg1);
1612 register tree r2 = TREE_REALPART (arg2);
1613 register tree i2 = TREE_IMAGPART (arg2);
1614 register tree t;
1615
1616 switch (code)
1617 {
1618 case PLUS_EXPR:
1619 t = build_complex (type,
1620 const_binop (PLUS_EXPR, r1, r2, notrunc),
1621 const_binop (PLUS_EXPR, i1, i2, notrunc));
1622 break;
1623
1624 case MINUS_EXPR:
1625 t = build_complex (type,
1626 const_binop (MINUS_EXPR, r1, r2, notrunc),
1627 const_binop (MINUS_EXPR, i1, i2, notrunc));
1628 break;
1629
1630 case MULT_EXPR:
1631 t = build_complex (type,
1632 const_binop (MINUS_EXPR,
1633 const_binop (MULT_EXPR,
1634 r1, r2, notrunc),
1635 const_binop (MULT_EXPR,
1636 i1, i2, notrunc),
1637 notrunc),
1638 const_binop (PLUS_EXPR,
1639 const_binop (MULT_EXPR,
1640 r1, i2, notrunc),
1641 const_binop (MULT_EXPR,
1642 i1, r2, notrunc),
1643 notrunc));
1644 break;
1645
1646 case RDIV_EXPR:
1647 {
1648 register tree magsquared
1649 = const_binop (PLUS_EXPR,
1650 const_binop (MULT_EXPR, r2, r2, notrunc),
1651 const_binop (MULT_EXPR, i2, i2, notrunc),
1652 notrunc);
1653
1654 t = build_complex (type,
1655 const_binop
1656 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1657 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1658 const_binop (PLUS_EXPR,
1659 const_binop (MULT_EXPR, r1, r2,
1660 notrunc),
1661 const_binop (MULT_EXPR, i1, i2,
1662 notrunc),
1663 notrunc),
1664 magsquared, notrunc),
1665 const_binop
1666 (INTEGRAL_TYPE_P (TREE_TYPE (r1))
1667 ? TRUNC_DIV_EXPR : RDIV_EXPR,
1668 const_binop (MINUS_EXPR,
1669 const_binop (MULT_EXPR, i1, r2,
1670 notrunc),
1671 const_binop (MULT_EXPR, r1, i2,
1672 notrunc),
1673 notrunc),
1674 magsquared, notrunc));
1675 }
1676 break;
1677
1678 default:
1679 abort ();
1680 }
1681 return t;
1682 }
1683 return 0;
1684}
1685
1686/* Return an INTEGER_CST with value V . The type is determined by bit_p:
1687 if it is zero, the type is taken from sizetype; if it is one, the type
1688 is taken from bitsizetype. */
1689
1690tree
1691size_int_wide (number, high, bit_p)
1692 unsigned HOST_WIDE_INT number, high;
1693 int bit_p;
1694{
1695 register tree t;
1696 /* Type-size nodes already made for small sizes. */
1697 static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1][2];
1698
1699 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high
1700 && size_table[number][bit_p] != 0)
1701 return size_table[number][bit_p];
1702 if (number < 2*HOST_BITS_PER_WIDE_INT + 1 && ! high)
1703 {
1704 push_obstacks_nochange ();
1705 /* Make this a permanent node. */
1706 end_temporary_allocation ();
1707 t = build_int_2 (number, 0);
1708 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1709 size_table[number][bit_p] = t;
1710 pop_obstacks ();
1711 }
1712 else
1713 {
1714 t = build_int_2 (number, high);
1715 TREE_TYPE (t) = bit_p ? bitsizetype : sizetype;
1716 TREE_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (t) = force_fit_type (t, 0);
1717 }
1718 return t;
1719}
1720
1721/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1722 CODE is a tree code. Data type is taken from `sizetype',
1723 If the operands are constant, so is the result. */
1724
1725tree
1726size_binop (code, arg0, arg1)
1727 enum tree_code code;
1728 tree arg0, arg1;
1729{
1730 /* Handle the special case of two integer constants faster. */
1731 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1732 {
1733 /* And some specific cases even faster than that. */
1734 if (code == PLUS_EXPR && integer_zerop (arg0))
1735 return arg1;
1736 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1737 && integer_zerop (arg1))
1738 return arg0;
1739 else if (code == MULT_EXPR && integer_onep (arg0))
1740 return arg1;
1741
1742 /* Handle general case of two integer constants. */
1743 return int_const_binop (code, arg0, arg1, 0, 1);
1744 }
1745
1746 if (arg0 == error_mark_node || arg1 == error_mark_node)
1747 return error_mark_node;
1748
1749 return fold (build (code, sizetype, arg0, arg1));
1750}
1751
1752/* Combine operands OP1 and OP2 with arithmetic operation CODE.
1753 CODE is a tree code. Data type is taken from `ssizetype',
1754 If the operands are constant, so is the result. */
1755
1756tree
1757ssize_binop (code, arg0, arg1)
1758 enum tree_code code;
1759 tree arg0, arg1;
1760{
1761 /* Handle the special case of two integer constants faster. */
1762 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1763 {
1764 /* And some specific cases even faster than that. */
1765 if (code == PLUS_EXPR && integer_zerop (arg0))
1766 return arg1;
1767 else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1768 && integer_zerop (arg1))
1769 return arg0;
1770 else if (code == MULT_EXPR && integer_onep (arg0))
1771 return arg1;
1772
1773 /* Handle general case of two integer constants. We convert
1774 arg0 to ssizetype because int_const_binop uses its type for the
1775 return value. */
1776 arg0 = convert (ssizetype, arg0);
1777 return int_const_binop (code, arg0, arg1, 0, 0);
1778 }
1779
1780 if (arg0 == error_mark_node || arg1 == error_mark_node)
1781 return error_mark_node;
1782
1783 return fold (build (code, ssizetype, arg0, arg1));
1784}
1785
|
| 1786struct fc_args
1787{
1788 /* Input */
1789 tree arg1, type;
1790 /* Output */
1791 tree t;
1792};
1793
1794static void
1795fold_convert_1 (data)
1796 PTR data;
1797{
1798 struct fc_args * args = (struct fc_args *) data;
1799
1800 args->t = build_real (args->type,
1801 real_value_truncate (TYPE_MODE (args->type),
1802 TREE_REAL_CST (args->arg1)));
1803}
1804
|
1527/* Given T, a tree representing type conversion of ARG1, a constant,
1528 return a constant tree representing the result of conversion. */
1529
1530static tree
1531fold_convert (t, arg1)
1532 register tree t;
1533 register tree arg1;
1534{
1535 register tree type = TREE_TYPE (t);
1536 int overflow = 0;
1537
1538 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1539 {
1540 if (TREE_CODE (arg1) == INTEGER_CST)
1541 {
1542 /* If we would build a constant wider than GCC supports,
1543 leave the conversion unfolded. */
1544 if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1545 return t;
1546
1547 /* Given an integer constant, make new constant with new type,
1548 appropriately sign-extended or truncated. */
1549 t = build_int_2 (TREE_INT_CST_LOW (arg1),
1550 TREE_INT_CST_HIGH (arg1));
1551 TREE_TYPE (t) = type;
1552 /* Indicate an overflow if (1) ARG1 already overflowed,
1553 or (2) force_fit_type indicates an overflow.
1554 Tell force_fit_type that an overflow has already occurred
1555 if ARG1 is a too-large unsigned value and T is signed.
1556 But don't indicate an overflow if converting a pointer. */
1557 TREE_OVERFLOW (t)
1558 = ((force_fit_type (t,
1559 (TREE_INT_CST_HIGH (arg1) < 0
1560 && (TREE_UNSIGNED (type)
1561 < TREE_UNSIGNED (TREE_TYPE (arg1)))))
1562 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
1563 || TREE_OVERFLOW (arg1));
1564 TREE_CONSTANT_OVERFLOW (t)
1565 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1566 }
1567#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1568 else if (TREE_CODE (arg1) == REAL_CST)
1569 {
1570 /* Don't initialize these, use assignments.
1571 Initialized local aggregates don't work on old compilers. */
1572 REAL_VALUE_TYPE x;
1573 REAL_VALUE_TYPE l;
1574 REAL_VALUE_TYPE u;
1575 tree type1 = TREE_TYPE (arg1);
1576 int no_upper_bound;
1577
1578 x = TREE_REAL_CST (arg1);
1579 l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
1580
1581 no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
1582 if (!no_upper_bound)
1583 u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
1584
1585 /* See if X will be in range after truncation towards 0.
1586 To compensate for truncation, move the bounds away from 0,
1587 but reject if X exactly equals the adjusted bounds. */
1588#ifdef REAL_ARITHMETIC
1589 REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
1590 if (!no_upper_bound)
1591 REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
1592#else
1593 l--;
1594 if (!no_upper_bound)
1595 u++;
1596#endif
1597 /* If X is a NaN, use zero instead and show we have an overflow.
1598 Otherwise, range check. */
1599 if (REAL_VALUE_ISNAN (x))
1600 overflow = 1, x = dconst0;
1601 else if (! (REAL_VALUES_LESS (l, x)
1602 && !no_upper_bound
1603 && REAL_VALUES_LESS (x, u)))
1604 overflow = 1;
1605
1606#ifndef REAL_ARITHMETIC
1607 {
1608 HOST_WIDE_INT low, high;
1609 HOST_WIDE_INT half_word
1610 = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
1611
1612 if (x < 0)
1613 x = -x;
1614
1615 high = (HOST_WIDE_INT) (x / half_word / half_word);
1616 x -= (REAL_VALUE_TYPE) high * half_word * half_word;
1617 if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
1618 {
1619 low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
1620 low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
1621 }
1622 else
1623 low = (HOST_WIDE_INT) x;
1624 if (TREE_REAL_CST (arg1) < 0)
1625 neg_double (low, high, &low, &high);
1626 t = build_int_2 (low, high);
1627 }
1628#else
1629 {
1630 HOST_WIDE_INT low, high;
1631 REAL_VALUE_TO_INT (&low, &high, x);
1632 t = build_int_2 (low, high);
1633 }
1634#endif
1635 TREE_TYPE (t) = type;
1636 TREE_OVERFLOW (t)
1637 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1638 TREE_CONSTANT_OVERFLOW (t)
1639 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1640 }
1641#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1642 TREE_TYPE (t) = type;
1643 }
1644 else if (TREE_CODE (type) == REAL_TYPE)
1645 {
1646#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1647 if (TREE_CODE (arg1) == INTEGER_CST)
1648 return build_real_from_int_cst (type, arg1);
1649#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1650 if (TREE_CODE (arg1) == REAL_CST)
1651 {
| 1805/* Given T, a tree representing type conversion of ARG1, a constant,
1806 return a constant tree representing the result of conversion. */
1807
1808static tree
1809fold_convert (t, arg1)
1810 register tree t;
1811 register tree arg1;
1812{
1813 register tree type = TREE_TYPE (t);
1814 int overflow = 0;
1815
1816 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
1817 {
1818 if (TREE_CODE (arg1) == INTEGER_CST)
1819 {
1820 /* If we would build a constant wider than GCC supports,
1821 leave the conversion unfolded. */
1822 if (TYPE_PRECISION (type) > 2 * HOST_BITS_PER_WIDE_INT)
1823 return t;
1824
1825 /* Given an integer constant, make new constant with new type,
1826 appropriately sign-extended or truncated. */
1827 t = build_int_2 (TREE_INT_CST_LOW (arg1),
1828 TREE_INT_CST_HIGH (arg1));
1829 TREE_TYPE (t) = type;
1830 /* Indicate an overflow if (1) ARG1 already overflowed,
1831 or (2) force_fit_type indicates an overflow.
1832 Tell force_fit_type that an overflow has already occurred
1833 if ARG1 is a too-large unsigned value and T is signed.
1834 But don't indicate an overflow if converting a pointer. */
1835 TREE_OVERFLOW (t)
1836 = ((force_fit_type (t,
1837 (TREE_INT_CST_HIGH (arg1) < 0
1838 && (TREE_UNSIGNED (type)
1839 < TREE_UNSIGNED (TREE_TYPE (arg1)))))
1840 && ! POINTER_TYPE_P (TREE_TYPE (arg1)))
1841 || TREE_OVERFLOW (arg1));
1842 TREE_CONSTANT_OVERFLOW (t)
1843 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1844 }
1845#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1846 else if (TREE_CODE (arg1) == REAL_CST)
1847 {
1848 /* Don't initialize these, use assignments.
1849 Initialized local aggregates don't work on old compilers. */
1850 REAL_VALUE_TYPE x;
1851 REAL_VALUE_TYPE l;
1852 REAL_VALUE_TYPE u;
1853 tree type1 = TREE_TYPE (arg1);
1854 int no_upper_bound;
1855
1856 x = TREE_REAL_CST (arg1);
1857 l = real_value_from_int_cst (type1, TYPE_MIN_VALUE (type));
1858
1859 no_upper_bound = (TYPE_MAX_VALUE (type) == NULL);
1860 if (!no_upper_bound)
1861 u = real_value_from_int_cst (type1, TYPE_MAX_VALUE (type));
1862
1863 /* See if X will be in range after truncation towards 0.
1864 To compensate for truncation, move the bounds away from 0,
1865 but reject if X exactly equals the adjusted bounds. */
1866#ifdef REAL_ARITHMETIC
1867 REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
1868 if (!no_upper_bound)
1869 REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
1870#else
1871 l--;
1872 if (!no_upper_bound)
1873 u++;
1874#endif
1875 /* If X is a NaN, use zero instead and show we have an overflow.
1876 Otherwise, range check. */
1877 if (REAL_VALUE_ISNAN (x))
1878 overflow = 1, x = dconst0;
1879 else if (! (REAL_VALUES_LESS (l, x)
1880 && !no_upper_bound
1881 && REAL_VALUES_LESS (x, u)))
1882 overflow = 1;
1883
1884#ifndef REAL_ARITHMETIC
1885 {
1886 HOST_WIDE_INT low, high;
1887 HOST_WIDE_INT half_word
1888 = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
1889
1890 if (x < 0)
1891 x = -x;
1892
1893 high = (HOST_WIDE_INT) (x / half_word / half_word);
1894 x -= (REAL_VALUE_TYPE) high * half_word * half_word;
1895 if (x >= (REAL_VALUE_TYPE) half_word * half_word / 2)
1896 {
1897 low = x - (REAL_VALUE_TYPE) half_word * half_word / 2;
1898 low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
1899 }
1900 else
1901 low = (HOST_WIDE_INT) x;
1902 if (TREE_REAL_CST (arg1) < 0)
1903 neg_double (low, high, &low, &high);
1904 t = build_int_2 (low, high);
1905 }
1906#else
1907 {
1908 HOST_WIDE_INT low, high;
1909 REAL_VALUE_TO_INT (&low, &high, x);
1910 t = build_int_2 (low, high);
1911 }
1912#endif
1913 TREE_TYPE (t) = type;
1914 TREE_OVERFLOW (t)
1915 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1916 TREE_CONSTANT_OVERFLOW (t)
1917 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1918 }
1919#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1920 TREE_TYPE (t) = type;
1921 }
1922 else if (TREE_CODE (type) == REAL_TYPE)
1923 {
1924#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1925 if (TREE_CODE (arg1) == INTEGER_CST)
1926 return build_real_from_int_cst (type, arg1);
1927#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1928 if (TREE_CODE (arg1) == REAL_CST)
1929 {
|
| 1930 struct fc_args args;
1931
|
1652 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
1653 {
1654 t = arg1;
1655 TREE_TYPE (arg1) = type;
1656 return t;
1657 }
| 1932 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
1933 {
1934 t = arg1;
1935 TREE_TYPE (arg1) = type;
1936 return t;
1937 }
|
1658 else if (setjmp (float_error))
| 1938
1939 /* Setup input for fold_convert_1() */
1940 args.arg1 = arg1;
1941 args.type = type;
1942
1943 if (do_float_handler (fold_convert_1, (PTR) &args))
|
1659 {
| 1944 {
|
| 1945 /* Receive output from fold_convert_1() */
1946 t = args.t;
1947 }
1948 else
1949 {
1950 /* We got an exception from fold_convert_1() */
|
1660 overflow = 1;
1661 t = copy_node (arg1);
| 1951 overflow = 1;
1952 t = copy_node (arg1);
|
1662 goto got_it;
| |
1663 }
| 1953 }
|
1664 set_float_handler (float_error);
| |
1665
| 1954
|
1666 t = build_real (type, real_value_truncate (TYPE_MODE (type),
1667 TREE_REAL_CST (arg1)));
1668 set_float_handler (NULL_PTR);
1669
1670 got_it:
| |
1671 TREE_OVERFLOW (t)
1672 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1673 TREE_CONSTANT_OVERFLOW (t)
1674 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1675 return t;
1676 }
1677 }
1678 TREE_CONSTANT (t) = 1;
1679 return t;
1680}
1681
| 1955 TREE_OVERFLOW (t)
1956 = TREE_OVERFLOW (arg1) | force_fit_type (t, overflow);
1957 TREE_CONSTANT_OVERFLOW (t)
1958 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1959 return t;
1960 }
1961 }
1962 TREE_CONSTANT (t) = 1;
1963 return t;
1964}
1965
|
1682/* Return an expr equal to X but certainly not valid as an lvalue.
1683 Also make sure it is not valid as an null pointer constant. */
| 1966/* Return an expr equal to X but certainly not valid as an lvalue. */
|
1684
1685tree
1686non_lvalue (x)
1687 tree x;
1688{
1689 tree result;
1690
1691 /* These things are certainly not lvalues. */
1692 if (TREE_CODE (x) == NON_LVALUE_EXPR
1693 || TREE_CODE (x) == INTEGER_CST
1694 || TREE_CODE (x) == REAL_CST
1695 || TREE_CODE (x) == STRING_CST
1696 || TREE_CODE (x) == ADDR_EXPR)
| 1967
1968tree
1969non_lvalue (x)
1970 tree x;
1971{
1972 tree result;
1973
1974 /* These things are certainly not lvalues. */
1975 if (TREE_CODE (x) == NON_LVALUE_EXPR
1976 || TREE_CODE (x) == INTEGER_CST
1977 || TREE_CODE (x) == REAL_CST
1978 || TREE_CODE (x) == STRING_CST
1979 || TREE_CODE (x) == ADDR_EXPR)
|
1697 {
1698 if (TREE_CODE (x) == INTEGER_CST && integer_zerop (x))
1699 {
1700 /* Use NOP_EXPR instead of NON_LVALUE_EXPR
1701 so convert_for_assignment won't strip it.
1702 This is so this 0 won't be treated as a null pointer constant. */
1703 result = build1 (NOP_EXPR, TREE_TYPE (x), x);
1704 TREE_CONSTANT (result) = TREE_CONSTANT (x);
1705 return result;
1706 }
1707 return x;
1708 }
| 1980 return x;
|
1709
1710 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1711 TREE_CONSTANT (result) = TREE_CONSTANT (x);
1712 return result;
1713}
1714
1715/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
1716 Zero means allow extended lvalues. */
1717
1718int pedantic_lvalues;
1719
1720/* When pedantic, return an expr equal to X but certainly not valid as a
1721 pedantic lvalue. Otherwise, return X. */
1722
1723tree
1724pedantic_non_lvalue (x)
1725 tree x;
1726{
1727 if (pedantic_lvalues)
1728 return non_lvalue (x);
1729 else
1730 return x;
1731}
1732
1733/* Given a tree comparison code, return the code that is the logical inverse
1734 of the given code. It is not safe to do this for floating-point
1735 comparisons, except for NE_EXPR and EQ_EXPR. */
1736
1737static enum tree_code
1738invert_tree_comparison (code)
1739 enum tree_code code;
1740{
1741 switch (code)
1742 {
1743 case EQ_EXPR:
1744 return NE_EXPR;
1745 case NE_EXPR:
1746 return EQ_EXPR;
1747 case GT_EXPR:
1748 return LE_EXPR;
1749 case GE_EXPR:
1750 return LT_EXPR;
1751 case LT_EXPR:
1752 return GE_EXPR;
1753 case LE_EXPR:
1754 return GT_EXPR;
1755 default:
1756 abort ();
1757 }
1758}
1759
1760/* Similar, but return the comparison that results if the operands are
1761 swapped. This is safe for floating-point. */
1762
1763static enum tree_code
1764swap_tree_comparison (code)
1765 enum tree_code code;
1766{
1767 switch (code)
1768 {
1769 case EQ_EXPR:
1770 case NE_EXPR:
1771 return code;
1772 case GT_EXPR:
1773 return LT_EXPR;
1774 case GE_EXPR:
1775 return LE_EXPR;
1776 case LT_EXPR:
1777 return GT_EXPR;
1778 case LE_EXPR:
1779 return GE_EXPR;
1780 default:
1781 abort ();
1782 }
1783}
1784
1785/* Return nonzero if CODE is a tree code that represents a truth value. */
1786
1787static int
1788truth_value_p (code)
1789 enum tree_code code;
1790{
1791 return (TREE_CODE_CLASS (code) == '<'
1792 || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
1793 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
1794 || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
1795}
1796
1797/* Return nonzero if two operands are necessarily equal.
1798 If ONLY_CONST is non-zero, only return non-zero for constants.
1799 This function tests whether the operands are indistinguishable;
1800 it does not test whether they are equal using C's == operation.
1801 The distinction is important for IEEE floating point, because
1802 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
1803 (2) two NaNs may be indistinguishable, but NaN!=NaN. */
1804
1805int
1806operand_equal_p (arg0, arg1, only_const)
1807 tree arg0, arg1;
1808 int only_const;
1809{
1810 /* If both types don't have the same signedness, then we can't consider
1811 them equal. We must check this before the STRIP_NOPS calls
1812 because they may change the signedness of the arguments. */
1813 if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
1814 return 0;
1815
1816 STRIP_NOPS (arg0);
1817 STRIP_NOPS (arg1);
1818
1819 if (TREE_CODE (arg0) != TREE_CODE (arg1)
1820 /* This is needed for conversions and for COMPONENT_REF.
1821 Might as well play it safe and always test this. */
1822 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
1823 return 0;
1824
1825 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1826 We don't care about side effects in that case because the SAVE_EXPR
1827 takes care of that for us. In all other cases, two expressions are
1828 equal if they have no side effects. If we have two identical
1829 expressions with side effects that should be treated the same due
1830 to the only side effects being identical SAVE_EXPR's, that will
1831 be detected in the recursive calls below. */
1832 if (arg0 == arg1 && ! only_const
1833 && (TREE_CODE (arg0) == SAVE_EXPR
1834 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
1835 return 1;
1836
1837 /* Next handle constant cases, those for which we can return 1 even
1838 if ONLY_CONST is set. */
1839 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
1840 switch (TREE_CODE (arg0))
1841 {
1842 case INTEGER_CST:
1843 return (! TREE_CONSTANT_OVERFLOW (arg0)
1844 && ! TREE_CONSTANT_OVERFLOW (arg1)
1845 && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
1846 && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
1847
1848 case REAL_CST:
1849 return (! TREE_CONSTANT_OVERFLOW (arg0)
1850 && ! TREE_CONSTANT_OVERFLOW (arg1)
1851 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
1852 TREE_REAL_CST (arg1)));
1853
1854 case COMPLEX_CST:
1855 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
1856 only_const)
1857 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
1858 only_const));
1859
1860 case STRING_CST:
1861 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
1862 && ! strncmp (TREE_STRING_POINTER (arg0),
1863 TREE_STRING_POINTER (arg1),
1864 TREE_STRING_LENGTH (arg0)));
1865
1866 case ADDR_EXPR:
1867 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
1868 0);
1869 default:
1870 break;
1871 }
1872
1873 if (only_const)
1874 return 0;
1875
1876 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
1877 {
1878 case '1':
1879 /* Two conversions are equal only if signedness and modes match. */
1880 if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
1881 && (TREE_UNSIGNED (TREE_TYPE (arg0))
1882 != TREE_UNSIGNED (TREE_TYPE (arg1))))
1883 return 0;
1884
1885 return operand_equal_p (TREE_OPERAND (arg0, 0),
1886 TREE_OPERAND (arg1, 0), 0);
1887
1888 case '<':
1889 case '2':
1890 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
1891 && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
1892 0))
1893 return 1;
1894
1895 /* For commutative ops, allow the other order. */
1896 return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
1897 || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
1898 || TREE_CODE (arg0) == BIT_IOR_EXPR
1899 || TREE_CODE (arg0) == BIT_XOR_EXPR
1900 || TREE_CODE (arg0) == BIT_AND_EXPR
1901 || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
1902 && operand_equal_p (TREE_OPERAND (arg0, 0),
1903 TREE_OPERAND (arg1, 1), 0)
1904 && operand_equal_p (TREE_OPERAND (arg0, 1),
1905 TREE_OPERAND (arg1, 0), 0));
1906
1907 case 'r':
1908 switch (TREE_CODE (arg0))
1909 {
1910 case INDIRECT_REF:
1911 return operand_equal_p (TREE_OPERAND (arg0, 0),
1912 TREE_OPERAND (arg1, 0), 0);
1913
1914 case COMPONENT_REF:
1915 case ARRAY_REF:
1916 return (operand_equal_p (TREE_OPERAND (arg0, 0),
1917 TREE_OPERAND (arg1, 0), 0)
1918 && operand_equal_p (TREE_OPERAND (arg0, 1),
1919 TREE_OPERAND (arg1, 1), 0));
1920
1921 case BIT_FIELD_REF:
1922 return (operand_equal_p (TREE_OPERAND (arg0, 0),
1923 TREE_OPERAND (arg1, 0), 0)
1924 && operand_equal_p (TREE_OPERAND (arg0, 1),
1925 TREE_OPERAND (arg1, 1), 0)
1926 && operand_equal_p (TREE_OPERAND (arg0, 2),
1927 TREE_OPERAND (arg1, 2), 0));
1928 default:
1929 return 0;
1930 }
| 1981
1982 result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1983 TREE_CONSTANT (result) = TREE_CONSTANT (x);
1984 return result;
1985}
1986
1987/* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
1988 Zero means allow extended lvalues. */
1989
1990int pedantic_lvalues;
1991
1992/* When pedantic, return an expr equal to X but certainly not valid as a
1993 pedantic lvalue. Otherwise, return X. */
1994
1995tree
1996pedantic_non_lvalue (x)
1997 tree x;
1998{
1999 if (pedantic_lvalues)
2000 return non_lvalue (x);
2001 else
2002 return x;
2003}
2004
2005/* Given a tree comparison code, return the code that is the logical inverse
2006 of the given code. It is not safe to do this for floating-point
2007 comparisons, except for NE_EXPR and EQ_EXPR. */
2008
2009static enum tree_code
2010invert_tree_comparison (code)
2011 enum tree_code code;
2012{
2013 switch (code)
2014 {
2015 case EQ_EXPR:
2016 return NE_EXPR;
2017 case NE_EXPR:
2018 return EQ_EXPR;
2019 case GT_EXPR:
2020 return LE_EXPR;
2021 case GE_EXPR:
2022 return LT_EXPR;
2023 case LT_EXPR:
2024 return GE_EXPR;
2025 case LE_EXPR:
2026 return GT_EXPR;
2027 default:
2028 abort ();
2029 }
2030}
2031
2032/* Similar, but return the comparison that results if the operands are
2033 swapped. This is safe for floating-point. */
2034
2035static enum tree_code
2036swap_tree_comparison (code)
2037 enum tree_code code;
2038{
2039 switch (code)
2040 {
2041 case EQ_EXPR:
2042 case NE_EXPR:
2043 return code;
2044 case GT_EXPR:
2045 return LT_EXPR;
2046 case GE_EXPR:
2047 return LE_EXPR;
2048 case LT_EXPR:
2049 return GT_EXPR;
2050 case LE_EXPR:
2051 return GE_EXPR;
2052 default:
2053 abort ();
2054 }
2055}
2056
2057/* Return nonzero if CODE is a tree code that represents a truth value. */
2058
2059static int
2060truth_value_p (code)
2061 enum tree_code code;
2062{
2063 return (TREE_CODE_CLASS (code) == '<'
2064 || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2065 || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2066 || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2067}
2068
2069/* Return nonzero if two operands are necessarily equal.
2070 If ONLY_CONST is non-zero, only return non-zero for constants.
2071 This function tests whether the operands are indistinguishable;
2072 it does not test whether they are equal using C's == operation.
2073 The distinction is important for IEEE floating point, because
2074 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2075 (2) two NaNs may be indistinguishable, but NaN!=NaN. */
2076
2077int
2078operand_equal_p (arg0, arg1, only_const)
2079 tree arg0, arg1;
2080 int only_const;
2081{
2082 /* If both types don't have the same signedness, then we can't consider
2083 them equal. We must check this before the STRIP_NOPS calls
2084 because they may change the signedness of the arguments. */
2085 if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
2086 return 0;
2087
2088 STRIP_NOPS (arg0);
2089 STRIP_NOPS (arg1);
2090
2091 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2092 /* This is needed for conversions and for COMPONENT_REF.
2093 Might as well play it safe and always test this. */
2094 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2095 return 0;
2096
2097 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2098 We don't care about side effects in that case because the SAVE_EXPR
2099 takes care of that for us. In all other cases, two expressions are
2100 equal if they have no side effects. If we have two identical
2101 expressions with side effects that should be treated the same due
2102 to the only side effects being identical SAVE_EXPR's, that will
2103 be detected in the recursive calls below. */
2104 if (arg0 == arg1 && ! only_const
2105 && (TREE_CODE (arg0) == SAVE_EXPR
2106 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2107 return 1;
2108
2109 /* Next handle constant cases, those for which we can return 1 even
2110 if ONLY_CONST is set. */
2111 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2112 switch (TREE_CODE (arg0))
2113 {
2114 case INTEGER_CST:
2115 return (! TREE_CONSTANT_OVERFLOW (arg0)
2116 && ! TREE_CONSTANT_OVERFLOW (arg1)
2117 && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
2118 && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1));
2119
2120 case REAL_CST:
2121 return (! TREE_CONSTANT_OVERFLOW (arg0)
2122 && ! TREE_CONSTANT_OVERFLOW (arg1)
2123 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2124 TREE_REAL_CST (arg1)));
2125
2126 case COMPLEX_CST:
2127 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2128 only_const)
2129 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2130 only_const));
2131
2132 case STRING_CST:
2133 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2134 && ! strncmp (TREE_STRING_POINTER (arg0),
2135 TREE_STRING_POINTER (arg1),
2136 TREE_STRING_LENGTH (arg0)));
2137
2138 case ADDR_EXPR:
2139 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2140 0);
2141 default:
2142 break;
2143 }
2144
2145 if (only_const)
2146 return 0;
2147
2148 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2149 {
2150 case '1':
2151 /* Two conversions are equal only if signedness and modes match. */
2152 if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
2153 && (TREE_UNSIGNED (TREE_TYPE (arg0))
2154 != TREE_UNSIGNED (TREE_TYPE (arg1))))
2155 return 0;
2156
2157 return operand_equal_p (TREE_OPERAND (arg0, 0),
2158 TREE_OPERAND (arg1, 0), 0);
2159
2160 case '<':
2161 case '2':
2162 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0)
2163 && operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1),
2164 0))
2165 return 1;
2166
2167 /* For commutative ops, allow the other order. */
2168 return ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MULT_EXPR
2169 || TREE_CODE (arg0) == MIN_EXPR || TREE_CODE (arg0) == MAX_EXPR
2170 || TREE_CODE (arg0) == BIT_IOR_EXPR
2171 || TREE_CODE (arg0) == BIT_XOR_EXPR
2172 || TREE_CODE (arg0) == BIT_AND_EXPR
2173 || TREE_CODE (arg0) == NE_EXPR || TREE_CODE (arg0) == EQ_EXPR)
2174 && operand_equal_p (TREE_OPERAND (arg0, 0),
2175 TREE_OPERAND (arg1, 1), 0)
2176 && operand_equal_p (TREE_OPERAND (arg0, 1),
2177 TREE_OPERAND (arg1, 0), 0));
2178
2179 case 'r':
2180 switch (TREE_CODE (arg0))
2181 {
2182 case INDIRECT_REF:
2183 return operand_equal_p (TREE_OPERAND (arg0, 0),
2184 TREE_OPERAND (arg1, 0), 0);
2185
2186 case COMPONENT_REF:
2187 case ARRAY_REF:
2188 return (operand_equal_p (TREE_OPERAND (arg0, 0),
2189 TREE_OPERAND (arg1, 0), 0)
2190 && operand_equal_p (TREE_OPERAND (arg0, 1),
2191 TREE_OPERAND (arg1, 1), 0));
2192
2193 case BIT_FIELD_REF:
2194 return (operand_equal_p (TREE_OPERAND (arg0, 0),
2195 TREE_OPERAND (arg1, 0), 0)
2196 && operand_equal_p (TREE_OPERAND (arg0, 1),
2197 TREE_OPERAND (arg1, 1), 0)
2198 && operand_equal_p (TREE_OPERAND (arg0, 2),
2199 TREE_OPERAND (arg1, 2), 0));
2200 default:
2201 return 0;
2202 }
|
| 2203
2204 case 'e':
2205 if (TREE_CODE (arg0) == RTL_EXPR)
2206 return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
2207 return 0;
|
1931
1932 default:
1933 return 0;
1934 }
1935}
1936
1937/* Similar to operand_equal_p, but see if ARG0 might have been made by
1938 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
1939
1940 When in doubt, return 0. */
1941
1942static int
1943operand_equal_for_comparison_p (arg0, arg1, other)
1944 tree arg0, arg1;
1945 tree other;
1946{
1947 int unsignedp1, unsignedpo;
1948 tree primarg0, primarg1, primother;
1949 unsigned correct_width;
1950
1951 if (operand_equal_p (arg0, arg1, 0))
1952 return 1;
1953
1954 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
1955 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
1956 return 0;
1957
1958 /* Discard any conversions that don't change the modes of ARG0 and ARG1
1959 and see if the inner values are the same. This removes any
1960 signedness comparison, which doesn't matter here. */
1961 primarg0 = arg0, primarg1 = arg1;
1962 STRIP_NOPS (primarg0); STRIP_NOPS (primarg1);
1963 if (operand_equal_p (primarg0, primarg1, 0))
1964 return 1;
1965
1966 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
1967 actual comparison operand, ARG0.
1968
1969 First throw away any conversions to wider types
1970 already present in the operands. */
1971
1972 primarg1 = get_narrower (arg1, &unsignedp1);
1973 primother = get_narrower (other, &unsignedpo);
1974
1975 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
1976 if (unsignedp1 == unsignedpo
1977 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
1978 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
1979 {
1980 tree type = TREE_TYPE (arg0);
1981
1982 /* Make sure shorter operand is extended the right way
1983 to match the longer operand. */
1984 primarg1 = convert (signed_or_unsigned_type (unsignedp1,
1985 TREE_TYPE (primarg1)),
1986 primarg1);
1987
1988 if (operand_equal_p (arg0, convert (type, primarg1), 0))
1989 return 1;
1990 }
1991
1992 return 0;
1993}
1994
1995/* See if ARG is an expression that is either a comparison or is performing
1996 arithmetic on comparisons. The comparisons must only be comparing
1997 two different values, which will be stored in *CVAL1 and *CVAL2; if
1998 they are non-zero it means that some operands have already been found.
1999 No variables may be used anywhere else in the expression except in the
2000 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2001 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2002
2003 If this is true, return 1. Otherwise, return zero. */
2004
2005static int
2006twoval_comparison_p (arg, cval1, cval2, save_p)
2007 tree arg;
2008 tree *cval1, *cval2;
2009 int *save_p;
2010{
2011 enum tree_code code = TREE_CODE (arg);
2012 char class = TREE_CODE_CLASS (code);
2013
2014 /* We can handle some of the 'e' cases here. */
2015 if (class == 'e' && code == TRUTH_NOT_EXPR)
2016 class = '1';
2017 else if (class == 'e'
2018 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2019 || code == COMPOUND_EXPR))
2020 class = '2';
2021
2022 /* ??? Disable this since the SAVE_EXPR might already be in use outside
2023 the expression. There may be no way to make this work, but it needs
2024 to be looked at again for 2.6. */
2025#if 0
2026 else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0)
2027 {
2028 /* If we've already found a CVAL1 or CVAL2, this expression is
2029 two complex to handle. */
2030 if (*cval1 || *cval2)
2031 return 0;
2032
2033 class = '1';
2034 *save_p = 1;
2035 }
2036#endif
2037
2038 switch (class)
2039 {
2040 case '1':
2041 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2042
2043 case '2':
2044 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2045 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2046 cval1, cval2, save_p));
2047
2048 case 'c':
2049 return 1;
2050
2051 case 'e':
2052 if (code == COND_EXPR)
2053 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2054 cval1, cval2, save_p)
2055 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2056 cval1, cval2, save_p)
2057 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2058 cval1, cval2, save_p));
2059 return 0;
2060
2061 case '<':
2062 /* First see if we can handle the first operand, then the second. For
2063 the second operand, we know *CVAL1 can't be zero. It must be that
2064 one side of the comparison is each of the values; test for the
2065 case where this isn't true by failing if the two operands
2066 are the same. */
2067
2068 if (operand_equal_p (TREE_OPERAND (arg, 0),
2069 TREE_OPERAND (arg, 1), 0))
2070 return 0;
2071
2072 if (*cval1 == 0)
2073 *cval1 = TREE_OPERAND (arg, 0);
2074 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2075 ;
2076 else if (*cval2 == 0)
2077 *cval2 = TREE_OPERAND (arg, 0);
2078 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2079 ;
2080 else
2081 return 0;
2082
2083 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2084 ;
2085 else if (*cval2 == 0)
2086 *cval2 = TREE_OPERAND (arg, 1);
2087 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2088 ;
2089 else
2090 return 0;
2091
2092 return 1;
2093
2094 default:
2095 return 0;
2096 }
2097}
2098
2099/* ARG is a tree that is known to contain just arithmetic operations and
2100 comparisons. Evaluate the operations in the tree substituting NEW0 for
2101 any occurrence of OLD0 as an operand of a comparison and likewise for
2102 NEW1 and OLD1. */
2103
2104static tree
2105eval_subst (arg, old0, new0, old1, new1)
2106 tree arg;
2107 tree old0, new0, old1, new1;
2108{
2109 tree type = TREE_TYPE (arg);
2110 enum tree_code code = TREE_CODE (arg);
2111 char class = TREE_CODE_CLASS (code);
2112
2113 /* We can handle some of the 'e' cases here. */
2114 if (class == 'e' && code == TRUTH_NOT_EXPR)
2115 class = '1';
2116 else if (class == 'e'
2117 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2118 class = '2';
2119
2120 switch (class)
2121 {
2122 case '1':
2123 return fold (build1 (code, type,
2124 eval_subst (TREE_OPERAND (arg, 0),
2125 old0, new0, old1, new1)));
2126
2127 case '2':
2128 return fold (build (code, type,
2129 eval_subst (TREE_OPERAND (arg, 0),
2130 old0, new0, old1, new1),
2131 eval_subst (TREE_OPERAND (arg, 1),
2132 old0, new0, old1, new1)));
2133
2134 case 'e':
2135 switch (code)
2136 {
2137 case SAVE_EXPR:
2138 return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2139
2140 case COMPOUND_EXPR:
2141 return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2142
2143 case COND_EXPR:
2144 return fold (build (code, type,
2145 eval_subst (TREE_OPERAND (arg, 0),
2146 old0, new0, old1, new1),
2147 eval_subst (TREE_OPERAND (arg, 1),
2148 old0, new0, old1, new1),
2149 eval_subst (TREE_OPERAND (arg, 2),
2150 old0, new0, old1, new1)));
2151 default:
2152 break;
2153 }
| 2208
2209 default:
2210 return 0;
2211 }
2212}
2213
2214/* Similar to operand_equal_p, but see if ARG0 might have been made by
2215 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2216
2217 When in doubt, return 0. */
2218
2219static int
2220operand_equal_for_comparison_p (arg0, arg1, other)
2221 tree arg0, arg1;
2222 tree other;
2223{
2224 int unsignedp1, unsignedpo;
2225 tree primarg0, primarg1, primother;
2226 unsigned correct_width;
2227
2228 if (operand_equal_p (arg0, arg1, 0))
2229 return 1;
2230
2231 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2232 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2233 return 0;
2234
2235 /* Discard any conversions that don't change the modes of ARG0 and ARG1
2236 and see if the inner values are the same. This removes any
2237 signedness comparison, which doesn't matter here. */
2238 primarg0 = arg0, primarg1 = arg1;
2239 STRIP_NOPS (primarg0); STRIP_NOPS (primarg1);
2240 if (operand_equal_p (primarg0, primarg1, 0))
2241 return 1;
2242
2243 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2244 actual comparison operand, ARG0.
2245
2246 First throw away any conversions to wider types
2247 already present in the operands. */
2248
2249 primarg1 = get_narrower (arg1, &unsignedp1);
2250 primother = get_narrower (other, &unsignedpo);
2251
2252 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2253 if (unsignedp1 == unsignedpo
2254 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2255 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2256 {
2257 tree type = TREE_TYPE (arg0);
2258
2259 /* Make sure shorter operand is extended the right way
2260 to match the longer operand. */
2261 primarg1 = convert (signed_or_unsigned_type (unsignedp1,
2262 TREE_TYPE (primarg1)),
2263 primarg1);
2264
2265 if (operand_equal_p (arg0, convert (type, primarg1), 0))
2266 return 1;
2267 }
2268
2269 return 0;
2270}
2271
2272/* See if ARG is an expression that is either a comparison or is performing
2273 arithmetic on comparisons. The comparisons must only be comparing
2274 two different values, which will be stored in *CVAL1 and *CVAL2; if
2275 they are non-zero it means that some operands have already been found.
2276 No variables may be used anywhere else in the expression except in the
2277 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2278 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2279
2280 If this is true, return 1. Otherwise, return zero. */
2281
2282static int
2283twoval_comparison_p (arg, cval1, cval2, save_p)
2284 tree arg;
2285 tree *cval1, *cval2;
2286 int *save_p;
2287{
2288 enum tree_code code = TREE_CODE (arg);
2289 char class = TREE_CODE_CLASS (code);
2290
2291 /* We can handle some of the 'e' cases here. */
2292 if (class == 'e' && code == TRUTH_NOT_EXPR)
2293 class = '1';
2294 else if (class == 'e'
2295 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2296 || code == COMPOUND_EXPR))
2297 class = '2';
2298
2299 /* ??? Disable this since the SAVE_EXPR might already be in use outside
2300 the expression. There may be no way to make this work, but it needs
2301 to be looked at again for 2.6. */
2302#if 0
2303 else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0)
2304 {
2305 /* If we've already found a CVAL1 or CVAL2, this expression is
2306 two complex to handle. */
2307 if (*cval1 || *cval2)
2308 return 0;
2309
2310 class = '1';
2311 *save_p = 1;
2312 }
2313#endif
2314
2315 switch (class)
2316 {
2317 case '1':
2318 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2319
2320 case '2':
2321 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2322 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2323 cval1, cval2, save_p));
2324
2325 case 'c':
2326 return 1;
2327
2328 case 'e':
2329 if (code == COND_EXPR)
2330 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2331 cval1, cval2, save_p)
2332 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2333 cval1, cval2, save_p)
2334 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2335 cval1, cval2, save_p));
2336 return 0;
2337
2338 case '<':
2339 /* First see if we can handle the first operand, then the second. For
2340 the second operand, we know *CVAL1 can't be zero. It must be that
2341 one side of the comparison is each of the values; test for the
2342 case where this isn't true by failing if the two operands
2343 are the same. */
2344
2345 if (operand_equal_p (TREE_OPERAND (arg, 0),
2346 TREE_OPERAND (arg, 1), 0))
2347 return 0;
2348
2349 if (*cval1 == 0)
2350 *cval1 = TREE_OPERAND (arg, 0);
2351 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2352 ;
2353 else if (*cval2 == 0)
2354 *cval2 = TREE_OPERAND (arg, 0);
2355 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2356 ;
2357 else
2358 return 0;
2359
2360 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2361 ;
2362 else if (*cval2 == 0)
2363 *cval2 = TREE_OPERAND (arg, 1);
2364 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2365 ;
2366 else
2367 return 0;
2368
2369 return 1;
2370
2371 default:
2372 return 0;
2373 }
2374}
2375
2376/* ARG is a tree that is known to contain just arithmetic operations and
2377 comparisons. Evaluate the operations in the tree substituting NEW0 for
2378 any occurrence of OLD0 as an operand of a comparison and likewise for
2379 NEW1 and OLD1. */
2380
2381static tree
2382eval_subst (arg, old0, new0, old1, new1)
2383 tree arg;
2384 tree old0, new0, old1, new1;
2385{
2386 tree type = TREE_TYPE (arg);
2387 enum tree_code code = TREE_CODE (arg);
2388 char class = TREE_CODE_CLASS (code);
2389
2390 /* We can handle some of the 'e' cases here. */
2391 if (class == 'e' && code == TRUTH_NOT_EXPR)
2392 class = '1';
2393 else if (class == 'e'
2394 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2395 class = '2';
2396
2397 switch (class)
2398 {
2399 case '1':
2400 return fold (build1 (code, type,
2401 eval_subst (TREE_OPERAND (arg, 0),
2402 old0, new0, old1, new1)));
2403
2404 case '2':
2405 return fold (build (code, type,
2406 eval_subst (TREE_OPERAND (arg, 0),
2407 old0, new0, old1, new1),
2408 eval_subst (TREE_OPERAND (arg, 1),
2409 old0, new0, old1, new1)));
2410
2411 case 'e':
2412 switch (code)
2413 {
2414 case SAVE_EXPR:
2415 return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2416
2417 case COMPOUND_EXPR:
2418 return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2419
2420 case COND_EXPR:
2421 return fold (build (code, type,
2422 eval_subst (TREE_OPERAND (arg, 0),
2423 old0, new0, old1, new1),
2424 eval_subst (TREE_OPERAND (arg, 1),
2425 old0, new0, old1, new1),
2426 eval_subst (TREE_OPERAND (arg, 2),
2427 old0, new0, old1, new1)));
2428 default:
2429 break;
2430 }
|
2154 /* fall through (???) */
| 2431 /* fall through - ??? */
|
2155
2156 case '<':
2157 {
2158 tree arg0 = TREE_OPERAND (arg, 0);
2159 tree arg1 = TREE_OPERAND (arg, 1);
2160
2161 /* We need to check both for exact equality and tree equality. The
2162 former will be true if the operand has a side-effect. In that
2163 case, we know the operand occurred exactly once. */
2164
2165 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2166 arg0 = new0;
2167 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2168 arg0 = new1;
2169
2170 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2171 arg1 = new0;
2172 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2173 arg1 = new1;
2174
2175 return fold (build (code, type, arg0, arg1));
2176 }
2177
2178 default:
2179 return arg;
2180 }
2181}
2182
2183/* Return a tree for the case when the result of an expression is RESULT
2184 converted to TYPE and OMITTED was previously an operand of the expression
2185 but is now not needed (e.g., we folded OMITTED * 0).
2186
2187 If OMITTED has side effects, we must evaluate it. Otherwise, just do
2188 the conversion of RESULT to TYPE. */
2189
2190static tree
2191omit_one_operand (type, result, omitted)
2192 tree type, result, omitted;
2193{
2194 tree t = convert (type, result);
2195
2196 if (TREE_SIDE_EFFECTS (omitted))
2197 return build (COMPOUND_EXPR, type, omitted, t);
2198
2199 return non_lvalue (t);
2200}
2201
2202/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
2203
2204static tree
2205pedantic_omit_one_operand (type, result, omitted)
2206 tree type, result, omitted;
2207{
2208 tree t = convert (type, result);
2209
2210 if (TREE_SIDE_EFFECTS (omitted))
2211 return build (COMPOUND_EXPR, type, omitted, t);
2212
2213 return pedantic_non_lvalue (t);
2214}
2215
2216
2217
2218/* Return a simplified tree node for the truth-negation of ARG. This
2219 never alters ARG itself. We assume that ARG is an operation that
2220 returns a truth value (0 or 1). */
2221
2222tree
2223invert_truthvalue (arg)
2224 tree arg;
2225{
2226 tree type = TREE_TYPE (arg);
2227 enum tree_code code = TREE_CODE (arg);
2228
2229 if (code == ERROR_MARK)
2230 return arg;
2231
2232 /* If this is a comparison, we can simply invert it, except for
2233 floating-point non-equality comparisons, in which case we just
2234 enclose a TRUTH_NOT_EXPR around what we have. */
2235
2236 if (TREE_CODE_CLASS (code) == '<')
2237 {
2238 if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
| 2432
2433 case '<':
2434 {
2435 tree arg0 = TREE_OPERAND (arg, 0);
2436 tree arg1 = TREE_OPERAND (arg, 1);
2437
2438 /* We need to check both for exact equality and tree equality. The
2439 former will be true if the operand has a side-effect. In that
2440 case, we know the operand occurred exactly once. */
2441
2442 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2443 arg0 = new0;
2444 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2445 arg0 = new1;
2446
2447 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2448 arg1 = new0;
2449 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2450 arg1 = new1;
2451
2452 return fold (build (code, type, arg0, arg1));
2453 }
2454
2455 default:
2456 return arg;
2457 }
2458}
2459
2460/* Return a tree for the case when the result of an expression is RESULT
2461 converted to TYPE and OMITTED was previously an operand of the expression
2462 but is now not needed (e.g., we folded OMITTED * 0).
2463
2464 If OMITTED has side effects, we must evaluate it. Otherwise, just do
2465 the conversion of RESULT to TYPE. */
2466
2467static tree
2468omit_one_operand (type, result, omitted)
2469 tree type, result, omitted;
2470{
2471 tree t = convert (type, result);
2472
2473 if (TREE_SIDE_EFFECTS (omitted))
2474 return build (COMPOUND_EXPR, type, omitted, t);
2475
2476 return non_lvalue (t);
2477}
2478
2479/* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
2480
2481static tree
2482pedantic_omit_one_operand (type, result, omitted)
2483 tree type, result, omitted;
2484{
2485 tree t = convert (type, result);
2486
2487 if (TREE_SIDE_EFFECTS (omitted))
2488 return build (COMPOUND_EXPR, type, omitted, t);
2489
2490 return pedantic_non_lvalue (t);
2491}
2492
2493
2494
2495/* Return a simplified tree node for the truth-negation of ARG. This
2496 never alters ARG itself. We assume that ARG is an operation that
2497 returns a truth value (0 or 1). */
2498
2499tree
2500invert_truthvalue (arg)
2501 tree arg;
2502{
2503 tree type = TREE_TYPE (arg);
2504 enum tree_code code = TREE_CODE (arg);
2505
2506 if (code == ERROR_MARK)
2507 return arg;
2508
2509 /* If this is a comparison, we can simply invert it, except for
2510 floating-point non-equality comparisons, in which case we just
2511 enclose a TRUTH_NOT_EXPR around what we have. */
2512
2513 if (TREE_CODE_CLASS (code) == '<')
2514 {
2515 if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
|
2239 && code != NE_EXPR && code != EQ_EXPR)
| 2516 && !flag_fast_math && code != NE_EXPR && code != EQ_EXPR)
|
2240 return build1 (TRUTH_NOT_EXPR, type, arg);
2241 else
2242 return build (invert_tree_comparison (code), type,
2243 TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2244 }
2245
2246 switch (code)
2247 {
2248 case INTEGER_CST:
2249 return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
2250 && TREE_INT_CST_HIGH (arg) == 0, 0));
2251
2252 case TRUTH_AND_EXPR:
2253 return build (TRUTH_OR_EXPR, type,
2254 invert_truthvalue (TREE_OPERAND (arg, 0)),
2255 invert_truthvalue (TREE_OPERAND (arg, 1)));
2256
2257 case TRUTH_OR_EXPR:
2258 return build (TRUTH_AND_EXPR, type,
2259 invert_truthvalue (TREE_OPERAND (arg, 0)),
2260 invert_truthvalue (TREE_OPERAND (arg, 1)));
2261
2262 case TRUTH_XOR_EXPR:
2263 /* Here we can invert either operand. We invert the first operand
2264 unless the second operand is a TRUTH_NOT_EXPR in which case our
2265 result is the XOR of the first operand with the inside of the
2266 negation of the second operand. */
2267
2268 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2269 return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2270 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2271 else
2272 return build (TRUTH_XOR_EXPR, type,
2273 invert_truthvalue (TREE_OPERAND (arg, 0)),
2274 TREE_OPERAND (arg, 1));
2275
2276 case TRUTH_ANDIF_EXPR:
2277 return build (TRUTH_ORIF_EXPR, type,
2278 invert_truthvalue (TREE_OPERAND (arg, 0)),
2279 invert_truthvalue (TREE_OPERAND (arg, 1)));
2280
2281 case TRUTH_ORIF_EXPR:
2282 return build (TRUTH_ANDIF_EXPR, type,
2283 invert_truthvalue (TREE_OPERAND (arg, 0)),
2284 invert_truthvalue (TREE_OPERAND (arg, 1)));
2285
2286 case TRUTH_NOT_EXPR:
2287 return TREE_OPERAND (arg, 0);
2288
2289 case COND_EXPR:
2290 return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2291 invert_truthvalue (TREE_OPERAND (arg, 1)),
2292 invert_truthvalue (TREE_OPERAND (arg, 2)));
2293
2294 case COMPOUND_EXPR:
2295 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2296 invert_truthvalue (TREE_OPERAND (arg, 1)));
2297
2298 case NON_LVALUE_EXPR:
2299 return invert_truthvalue (TREE_OPERAND (arg, 0));
2300
2301 case NOP_EXPR:
2302 case CONVERT_EXPR:
2303 case FLOAT_EXPR:
2304 return build1 (TREE_CODE (arg), type,
2305 invert_truthvalue (TREE_OPERAND (arg, 0)));
2306
2307 case BIT_AND_EXPR:
2308 if (!integer_onep (TREE_OPERAND (arg, 1)))
2309 break;
2310 return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2311
2312 case SAVE_EXPR:
2313 return build1 (TRUTH_NOT_EXPR, type, arg);
2314
2315 case CLEANUP_POINT_EXPR:
2316 return build1 (CLEANUP_POINT_EXPR, type,
2317 invert_truthvalue (TREE_OPERAND (arg, 0)));
2318
2319 default:
2320 break;
2321 }
2322 if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2323 abort ();
2324 return build1 (TRUTH_NOT_EXPR, type, arg);
2325}
2326
2327/* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2328 operands are another bit-wise operation with a common input. If so,
2329 distribute the bit operations to save an operation and possibly two if
2330 constants are involved. For example, convert
2331 (A | B) & (A | C) into A | (B & C)
2332 Further simplification will occur if B and C are constants.
2333
2334 If this optimization cannot be done, 0 will be returned. */
2335
2336static tree
2337distribute_bit_expr (code, type, arg0, arg1)
2338 enum tree_code code;
2339 tree type;
2340 tree arg0, arg1;
2341{
2342 tree common;
2343 tree left, right;
2344
2345 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2346 || TREE_CODE (arg0) == code
2347 || (TREE_CODE (arg0) != BIT_AND_EXPR
2348 && TREE_CODE (arg0) != BIT_IOR_EXPR))
2349 return 0;
2350
2351 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2352 {
2353 common = TREE_OPERAND (arg0, 0);
2354 left = TREE_OPERAND (arg0, 1);
2355 right = TREE_OPERAND (arg1, 1);
2356 }
2357 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2358 {
2359 common = TREE_OPERAND (arg0, 0);
2360 left = TREE_OPERAND (arg0, 1);
2361 right = TREE_OPERAND (arg1, 0);
2362 }
2363 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2364 {
2365 common = TREE_OPERAND (arg0, 1);
2366 left = TREE_OPERAND (arg0, 0);
2367 right = TREE_OPERAND (arg1, 1);
2368 }
2369 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2370 {
2371 common = TREE_OPERAND (arg0, 1);
2372 left = TREE_OPERAND (arg0, 0);
2373 right = TREE_OPERAND (arg1, 0);
2374 }
2375 else
2376 return 0;
2377
2378 return fold (build (TREE_CODE (arg0), type, common,
2379 fold (build (code, type, left, right))));
2380}
2381
2382/* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2383 starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
2384
2385static tree
2386make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2387 tree inner;
2388 tree type;
2389 int bitsize, bitpos;
2390 int unsignedp;
2391{
2392 tree result = build (BIT_FIELD_REF, type, inner,
2393 size_int (bitsize), bitsize_int (bitpos, 0L));
2394
2395 TREE_UNSIGNED (result) = unsignedp;
2396
2397 return result;
2398}
2399
2400/* Optimize a bit-field compare.
2401
2402 There are two cases: First is a compare against a constant and the
2403 second is a comparison of two items where the fields are at the same
2404 bit position relative to the start of a chunk (byte, halfword, word)
2405 large enough to contain it. In these cases we can avoid the shift
2406 implicit in bitfield extractions.
2407
2408 For constants, we emit a compare of the shifted constant with the
2409 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2410 compared. For two fields at the same position, we do the ANDs with the
2411 similar mask and compare the result of the ANDs.
2412
2413 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2414 COMPARE_TYPE is the type of the comparison, and LHS and RHS
2415 are the left and right operands of the comparison, respectively.
2416
2417 If the optimization described above can be done, we return the resulting
2418 tree. Otherwise we return zero. */
2419
2420static tree
2421optimize_bit_field_compare (code, compare_type, lhs, rhs)
2422 enum tree_code code;
2423 tree compare_type;
2424 tree lhs, rhs;
2425{
2426 int lbitpos, lbitsize, rbitpos, rbitsize;
2427 int lnbitpos, lnbitsize, rnbitpos = 0, rnbitsize = 0;
2428 tree type = TREE_TYPE (lhs);
2429 tree signed_type, unsigned_type;
2430 int const_p = TREE_CODE (rhs) == INTEGER_CST;
2431 enum machine_mode lmode, rmode, lnmode, rnmode = VOIDmode;
2432 int lunsignedp, runsignedp;
2433 int lvolatilep = 0, rvolatilep = 0;
2434 int alignment;
2435 tree linner, rinner = NULL_TREE;
2436 tree mask;
2437 tree offset;
2438
2439 /* Get all the information about the extractions being done. If the bit size
2440 if the same as the size of the underlying object, we aren't doing an
2441 extraction at all and so can do nothing. */
2442 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2443 &lunsignedp, &lvolatilep, &alignment);
2444 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2445 || offset != 0)
2446 return 0;
2447
2448 if (!const_p)
2449 {
2450 /* If this is not a constant, we can only do something if bit positions,
2451 sizes, and signedness are the same. */
2452 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2453 &runsignedp, &rvolatilep, &alignment);
2454
2455 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2456 || lunsignedp != runsignedp || offset != 0)
2457 return 0;
2458 }
2459
2460 /* See if we can find a mode to refer to this field. We should be able to,
2461 but fail if we can't. */
2462 lnmode = get_best_mode (lbitsize, lbitpos,
2463 TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
2464 lvolatilep);
2465 if (lnmode == VOIDmode)
2466 return 0;
2467
2468 /* Set signed and unsigned types of the precision of this mode for the
2469 shifts below. */
2470 signed_type = type_for_mode (lnmode, 0);
2471 unsigned_type = type_for_mode (lnmode, 1);
2472
2473 if (! const_p)
2474 {
2475 rnmode = get_best_mode (rbitsize, rbitpos,
2476 TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
2477 rvolatilep);
2478 if (rnmode == VOIDmode)
2479 return 0;
2480 }
2481
2482 /* Compute the bit position and size for the new reference and our offset
2483 within it. If the new reference is the same size as the original, we
2484 won't optimize anything, so return zero. */
2485 lnbitsize = GET_MODE_BITSIZE (lnmode);
2486 lnbitpos = lbitpos & ~ (lnbitsize - 1);
2487 lbitpos -= lnbitpos;
2488 if (lnbitsize == lbitsize)
2489 return 0;
2490
2491 if (! const_p)
2492 {
2493 rnbitsize = GET_MODE_BITSIZE (rnmode);
2494 rnbitpos = rbitpos & ~ (rnbitsize - 1);
2495 rbitpos -= rnbitpos;
2496 if (rnbitsize == rbitsize)
2497 return 0;
2498 }
2499
2500 if (BYTES_BIG_ENDIAN)
2501 lbitpos = lnbitsize - lbitsize - lbitpos;
2502
2503 /* Make the mask to be used against the extracted field. */
2504 mask = build_int_2 (~0, ~0);
2505 TREE_TYPE (mask) = unsigned_type;
2506 force_fit_type (mask, 0);
2507 mask = convert (unsigned_type, mask);
2508 mask = const_binop (LSHIFT_EXPR, mask, size_int (lnbitsize - lbitsize), 0);
2509 mask = const_binop (RSHIFT_EXPR, mask,
2510 size_int (lnbitsize - lbitsize - lbitpos), 0);
2511
2512 if (! const_p)
2513 /* If not comparing with constant, just rework the comparison
2514 and return. */
2515 return build (code, compare_type,
2516 build (BIT_AND_EXPR, unsigned_type,
2517 make_bit_field_ref (linner, unsigned_type,
2518 lnbitsize, lnbitpos, 1),
2519 mask),
2520 build (BIT_AND_EXPR, unsigned_type,
2521 make_bit_field_ref (rinner, unsigned_type,
2522 rnbitsize, rnbitpos, 1),
2523 mask));
2524
2525 /* Otherwise, we are handling the constant case. See if the constant is too
2526 big for the field. Warn and return a tree of for 0 (false) if so. We do
2527 this not only for its own sake, but to avoid having to test for this
2528 error case below. If we didn't, we might generate wrong code.
2529
2530 For unsigned fields, the constant shifted right by the field length should
2531 be all zero. For signed fields, the high-order bits should agree with
2532 the sign bit. */
2533
2534 if (lunsignedp)
2535 {
2536 if (! integer_zerop (const_binop (RSHIFT_EXPR,
2537 convert (unsigned_type, rhs),
2538 size_int (lbitsize), 0)))
2539 {
| 2517 return build1 (TRUTH_NOT_EXPR, type, arg);
2518 else
2519 return build (invert_tree_comparison (code), type,
2520 TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2521 }
2522
2523 switch (code)
2524 {
2525 case INTEGER_CST:
2526 return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
2527 && TREE_INT_CST_HIGH (arg) == 0, 0));
2528
2529 case TRUTH_AND_EXPR:
2530 return build (TRUTH_OR_EXPR, type,
2531 invert_truthvalue (TREE_OPERAND (arg, 0)),
2532 invert_truthvalue (TREE_OPERAND (arg, 1)));
2533
2534 case TRUTH_OR_EXPR:
2535 return build (TRUTH_AND_EXPR, type,
2536 invert_truthvalue (TREE_OPERAND (arg, 0)),
2537 invert_truthvalue (TREE_OPERAND (arg, 1)));
2538
2539 case TRUTH_XOR_EXPR:
2540 /* Here we can invert either operand. We invert the first operand
2541 unless the second operand is a TRUTH_NOT_EXPR in which case our
2542 result is the XOR of the first operand with the inside of the
2543 negation of the second operand. */
2544
2545 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2546 return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2547 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2548 else
2549 return build (TRUTH_XOR_EXPR, type,
2550 invert_truthvalue (TREE_OPERAND (arg, 0)),
2551 TREE_OPERAND (arg, 1));
2552
2553 case TRUTH_ANDIF_EXPR:
2554 return build (TRUTH_ORIF_EXPR, type,
2555 invert_truthvalue (TREE_OPERAND (arg, 0)),
2556 invert_truthvalue (TREE_OPERAND (arg, 1)));
2557
2558 case TRUTH_ORIF_EXPR:
2559 return build (TRUTH_ANDIF_EXPR, type,
2560 invert_truthvalue (TREE_OPERAND (arg, 0)),
2561 invert_truthvalue (TREE_OPERAND (arg, 1)));
2562
2563 case TRUTH_NOT_EXPR:
2564 return TREE_OPERAND (arg, 0);
2565
2566 case COND_EXPR:
2567 return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2568 invert_truthvalue (TREE_OPERAND (arg, 1)),
2569 invert_truthvalue (TREE_OPERAND (arg, 2)));
2570
2571 case COMPOUND_EXPR:
2572 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2573 invert_truthvalue (TREE_OPERAND (arg, 1)));
2574
2575 case NON_LVALUE_EXPR:
2576 return invert_truthvalue (TREE_OPERAND (arg, 0));
2577
2578 case NOP_EXPR:
2579 case CONVERT_EXPR:
2580 case FLOAT_EXPR:
2581 return build1 (TREE_CODE (arg), type,
2582 invert_truthvalue (TREE_OPERAND (arg, 0)));
2583
2584 case BIT_AND_EXPR:
2585 if (!integer_onep (TREE_OPERAND (arg, 1)))
2586 break;
2587 return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2588
2589 case SAVE_EXPR:
2590 return build1 (TRUTH_NOT_EXPR, type, arg);
2591
2592 case CLEANUP_POINT_EXPR:
2593 return build1 (CLEANUP_POINT_EXPR, type,
2594 invert_truthvalue (TREE_OPERAND (arg, 0)));
2595
2596 default:
2597 break;
2598 }
2599 if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2600 abort ();
2601 return build1 (TRUTH_NOT_EXPR, type, arg);
2602}
2603
2604/* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2605 operands are another bit-wise operation with a common input. If so,
2606 distribute the bit operations to save an operation and possibly two if
2607 constants are involved. For example, convert
2608 (A | B) & (A | C) into A | (B & C)
2609 Further simplification will occur if B and C are constants.
2610
2611 If this optimization cannot be done, 0 will be returned. */
2612
2613static tree
2614distribute_bit_expr (code, type, arg0, arg1)
2615 enum tree_code code;
2616 tree type;
2617 tree arg0, arg1;
2618{
2619 tree common;
2620 tree left, right;
2621
2622 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2623 || TREE_CODE (arg0) == code
2624 || (TREE_CODE (arg0) != BIT_AND_EXPR
2625 && TREE_CODE (arg0) != BIT_IOR_EXPR))
2626 return 0;
2627
2628 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2629 {
2630 common = TREE_OPERAND (arg0, 0);
2631 left = TREE_OPERAND (arg0, 1);
2632 right = TREE_OPERAND (arg1, 1);
2633 }
2634 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2635 {
2636 common = TREE_OPERAND (arg0, 0);
2637 left = TREE_OPERAND (arg0, 1);
2638 right = TREE_OPERAND (arg1, 0);
2639 }
2640 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2641 {
2642 common = TREE_OPERAND (arg0, 1);
2643 left = TREE_OPERAND (arg0, 0);
2644 right = TREE_OPERAND (arg1, 1);
2645 }
2646 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2647 {
2648 common = TREE_OPERAND (arg0, 1);
2649 left = TREE_OPERAND (arg0, 0);
2650 right = TREE_OPERAND (arg1, 0);
2651 }
2652 else
2653 return 0;
2654
2655 return fold (build (TREE_CODE (arg0), type, common,
2656 fold (build (code, type, left, right))));
2657}
2658
2659/* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2660 starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
2661
2662static tree
2663make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2664 tree inner;
2665 tree type;
2666 int bitsize, bitpos;
2667 int unsignedp;
2668{
2669 tree result = build (BIT_FIELD_REF, type, inner,
2670 size_int (bitsize), bitsize_int (bitpos, 0L));
2671
2672 TREE_UNSIGNED (result) = unsignedp;
2673
2674 return result;
2675}
2676
2677/* Optimize a bit-field compare.
2678
2679 There are two cases: First is a compare against a constant and the
2680 second is a comparison of two items where the fields are at the same
2681 bit position relative to the start of a chunk (byte, halfword, word)
2682 large enough to contain it. In these cases we can avoid the shift
2683 implicit in bitfield extractions.
2684
2685 For constants, we emit a compare of the shifted constant with the
2686 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2687 compared. For two fields at the same position, we do the ANDs with the
2688 similar mask and compare the result of the ANDs.
2689
2690 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2691 COMPARE_TYPE is the type of the comparison, and LHS and RHS
2692 are the left and right operands of the comparison, respectively.
2693
2694 If the optimization described above can be done, we return the resulting
2695 tree. Otherwise we return zero. */
2696
2697static tree
2698optimize_bit_field_compare (code, compare_type, lhs, rhs)
2699 enum tree_code code;
2700 tree compare_type;
2701 tree lhs, rhs;
2702{
2703 int lbitpos, lbitsize, rbitpos, rbitsize;
2704 int lnbitpos, lnbitsize, rnbitpos = 0, rnbitsize = 0;
2705 tree type = TREE_TYPE (lhs);
2706 tree signed_type, unsigned_type;
2707 int const_p = TREE_CODE (rhs) == INTEGER_CST;
2708 enum machine_mode lmode, rmode, lnmode, rnmode = VOIDmode;
2709 int lunsignedp, runsignedp;
2710 int lvolatilep = 0, rvolatilep = 0;
2711 int alignment;
2712 tree linner, rinner = NULL_TREE;
2713 tree mask;
2714 tree offset;
2715
2716 /* Get all the information about the extractions being done. If the bit size
2717 if the same as the size of the underlying object, we aren't doing an
2718 extraction at all and so can do nothing. */
2719 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2720 &lunsignedp, &lvolatilep, &alignment);
2721 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2722 || offset != 0)
2723 return 0;
2724
2725 if (!const_p)
2726 {
2727 /* If this is not a constant, we can only do something if bit positions,
2728 sizes, and signedness are the same. */
2729 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
2730 &runsignedp, &rvolatilep, &alignment);
2731
2732 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2733 || lunsignedp != runsignedp || offset != 0)
2734 return 0;
2735 }
2736
2737 /* See if we can find a mode to refer to this field. We should be able to,
2738 but fail if we can't. */
2739 lnmode = get_best_mode (lbitsize, lbitpos,
2740 TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
2741 lvolatilep);
2742 if (lnmode == VOIDmode)
2743 return 0;
2744
2745 /* Set signed and unsigned types of the precision of this mode for the
2746 shifts below. */
2747 signed_type = type_for_mode (lnmode, 0);
2748 unsigned_type = type_for_mode (lnmode, 1);
2749
2750 if (! const_p)
2751 {
2752 rnmode = get_best_mode (rbitsize, rbitpos,
2753 TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
2754 rvolatilep);
2755 if (rnmode == VOIDmode)
2756 return 0;
2757 }
2758
2759 /* Compute the bit position and size for the new reference and our offset
2760 within it. If the new reference is the same size as the original, we
2761 won't optimize anything, so return zero. */
2762 lnbitsize = GET_MODE_BITSIZE (lnmode);
2763 lnbitpos = lbitpos & ~ (lnbitsize - 1);
2764 lbitpos -= lnbitpos;
2765 if (lnbitsize == lbitsize)
2766 return 0;
2767
2768 if (! const_p)
2769 {
2770 rnbitsize = GET_MODE_BITSIZE (rnmode);
2771 rnbitpos = rbitpos & ~ (rnbitsize - 1);
2772 rbitpos -= rnbitpos;
2773 if (rnbitsize == rbitsize)
2774 return 0;
2775 }
2776
2777 if (BYTES_BIG_ENDIAN)
2778 lbitpos = lnbitsize - lbitsize - lbitpos;
2779
2780 /* Make the mask to be used against the extracted field. */
2781 mask = build_int_2 (~0, ~0);
2782 TREE_TYPE (mask) = unsigned_type;
2783 force_fit_type (mask, 0);
2784 mask = convert (unsigned_type, mask);
2785 mask = const_binop (LSHIFT_EXPR, mask, size_int (lnbitsize - lbitsize), 0);
2786 mask = const_binop (RSHIFT_EXPR, mask,
2787 size_int (lnbitsize - lbitsize - lbitpos), 0);
2788
2789 if (! const_p)
2790 /* If not comparing with constant, just rework the comparison
2791 and return. */
2792 return build (code, compare_type,
2793 build (BIT_AND_EXPR, unsigned_type,
2794 make_bit_field_ref (linner, unsigned_type,
2795 lnbitsize, lnbitpos, 1),
2796 mask),
2797 build (BIT_AND_EXPR, unsigned_type,
2798 make_bit_field_ref (rinner, unsigned_type,
2799 rnbitsize, rnbitpos, 1),
2800 mask));
2801
2802 /* Otherwise, we are handling the constant case. See if the constant is too
2803 big for the field. Warn and return a tree of for 0 (false) if so. We do
2804 this not only for its own sake, but to avoid having to test for this
2805 error case below. If we didn't, we might generate wrong code.
2806
2807 For unsigned fields, the constant shifted right by the field length should
2808 be all zero. For signed fields, the high-order bits should agree with
2809 the sign bit. */
2810
2811 if (lunsignedp)
2812 {
2813 if (! integer_zerop (const_binop (RSHIFT_EXPR,
2814 convert (unsigned_type, rhs),
2815 size_int (lbitsize), 0)))
2816 {
|
2540 warning ("comparison is always %s due to width of bitfield",
2541 code == NE_EXPR ? "one" : "zero");
| 2817 warning ("comparison is always %d due to width of bitfield",
2818 code == NE_EXPR);
|
2542 return convert (compare_type,
2543 (code == NE_EXPR
2544 ? integer_one_node : integer_zero_node));
2545 }
2546 }
2547 else
2548 {
2549 tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
2550 size_int (lbitsize - 1), 0);
2551 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2552 {
| 2819 return convert (compare_type,
2820 (code == NE_EXPR
2821 ? integer_one_node : integer_zero_node));
2822 }
2823 }
2824 else
2825 {
2826 tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
2827 size_int (lbitsize - 1), 0);
2828 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2829 {
|
2553 warning ("comparison is always %s due to width of bitfield",
2554 code == NE_EXPR ? "one" : "zero");
| 2830 warning ("comparison is always %d due to width of bitfield",
2831 code == NE_EXPR);
|
2555 return convert (compare_type,
2556 (code == NE_EXPR
2557 ? integer_one_node : integer_zero_node));
2558 }
2559 }
2560
2561 /* Single-bit compares should always be against zero. */
2562 if (lbitsize == 1 && ! integer_zerop (rhs))
2563 {
2564 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2565 rhs = convert (type, integer_zero_node);
2566 }
2567
2568 /* Make a new bitfield reference, shift the constant over the
2569 appropriate number of bits and mask it with the computed mask
2570 (in case this was a signed field). If we changed it, make a new one. */
2571 lhs = make_bit_field_ref (linner, unsigned_type, lnbitsize, lnbitpos, 1);
2572 if (lvolatilep)
2573 {
2574 TREE_SIDE_EFFECTS (lhs) = 1;
2575 TREE_THIS_VOLATILE (lhs) = 1;
2576 }
2577
2578 rhs = fold (const_binop (BIT_AND_EXPR,
2579 const_binop (LSHIFT_EXPR,
2580 convert (unsigned_type, rhs),
2581 size_int (lbitpos), 0),
2582 mask, 0));
2583
2584 return build (code, compare_type,
2585 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
2586 rhs);
2587}
2588
2589/* Subroutine for fold_truthop: decode a field reference.
2590
2591 If EXP is a comparison reference, we return the innermost reference.
2592
2593 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2594 set to the starting bit number.
2595
2596 If the innermost field can be completely contained in a mode-sized
2597 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
2598
2599 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2600 otherwise it is not changed.
2601
2602 *PUNSIGNEDP is set to the signedness of the field.
2603
2604 *PMASK is set to the mask used. This is either contained in a
2605 BIT_AND_EXPR or derived from the width of the field.
2606
2607 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
2608
2609 Return 0 if this is not a component reference or is one that we can't
2610 do anything with. */
2611
2612static tree
2613decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
2614 pvolatilep, pmask, pand_mask)
2615 tree exp;
2616 int *pbitsize, *pbitpos;
2617 enum machine_mode *pmode;
2618 int *punsignedp, *pvolatilep;
2619 tree *pmask;
2620 tree *pand_mask;
2621{
2622 tree and_mask = 0;
2623 tree mask, inner, offset;
2624 tree unsigned_type;
2625 int precision;
2626 int alignment;
2627
2628 /* All the optimizations using this function assume integer fields.
2629 There are problems with FP fields since the type_for_size call
2630 below can fail for, e.g., XFmode. */
2631 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2632 return 0;
2633
2634 STRIP_NOPS (exp);
2635
2636 if (TREE_CODE (exp) == BIT_AND_EXPR)
2637 {
2638 and_mask = TREE_OPERAND (exp, 1);
2639 exp = TREE_OPERAND (exp, 0);
2640 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
2641 if (TREE_CODE (and_mask) != INTEGER_CST)
2642 return 0;
2643 }
2644
2645
2646 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
2647 punsignedp, pvolatilep, &alignment);
2648 if ((inner == exp && and_mask == 0)
2649 || *pbitsize < 0 || offset != 0)
2650 return 0;
2651
2652 /* Compute the mask to access the bitfield. */
2653 unsigned_type = type_for_size (*pbitsize, 1);
2654 precision = TYPE_PRECISION (unsigned_type);
2655
2656 mask = build_int_2 (~0, ~0);
2657 TREE_TYPE (mask) = unsigned_type;
2658 force_fit_type (mask, 0);
2659 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2660 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2661
2662 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
2663 if (and_mask != 0)
2664 mask = fold (build (BIT_AND_EXPR, unsigned_type,
2665 convert (unsigned_type, and_mask), mask));
2666
2667 *pmask = mask;
2668 *pand_mask = and_mask;
2669 return inner;
2670}
2671
2672/* Return non-zero if MASK represents a mask of SIZE ones in the low-order
2673 bit positions. */
2674
2675static int
2676all_ones_mask_p (mask, size)
2677 tree mask;
2678 int size;
2679{
2680 tree type = TREE_TYPE (mask);
2681 int precision = TYPE_PRECISION (type);
2682 tree tmask;
2683
2684 tmask = build_int_2 (~0, ~0);
2685 TREE_TYPE (tmask) = signed_type (type);
2686 force_fit_type (tmask, 0);
2687 return
2688 tree_int_cst_equal (mask,
2689 const_binop (RSHIFT_EXPR,
2690 const_binop (LSHIFT_EXPR, tmask,
2691 size_int (precision - size),
2692 0),
2693 size_int (precision - size), 0));
2694}
2695
2696/* Subroutine for fold_truthop: determine if an operand is simple enough
2697 to be evaluated unconditionally. */
2698
2699static int
2700simple_operand_p (exp)
2701 tree exp;
2702{
2703 /* Strip any conversions that don't change the machine mode. */
2704 while ((TREE_CODE (exp) == NOP_EXPR
2705 || TREE_CODE (exp) == CONVERT_EXPR)
2706 && (TYPE_MODE (TREE_TYPE (exp))
2707 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2708 exp = TREE_OPERAND (exp, 0);
2709
2710 return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2711 || (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
2712 && ! TREE_ADDRESSABLE (exp)
2713 && ! TREE_THIS_VOLATILE (exp)
2714 && ! DECL_NONLOCAL (exp)
2715 /* Don't regard global variables as simple. They may be
2716 allocated in ways unknown to the compiler (shared memory,
2717 #pragma weak, etc). */
2718 && ! TREE_PUBLIC (exp)
2719 && ! DECL_EXTERNAL (exp)
2720 /* Loading a static variable is unduly expensive, but global
2721 registers aren't expensive. */
2722 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
2723}
2724
2725/* The following functions are subroutines to fold_range_test and allow it to
2726 try to change a logical combination of comparisons into a range test.
2727
2728 For example, both
2729 X == 2 && X == 3 && X == 4 && X == 5
2730 and
2731 X >= 2 && X <= 5
2732 are converted to
2733 (unsigned) (X - 2) <= 3
2734
2735 We describe each set of comparisons as being either inside or outside
2736 a range, using a variable named like IN_P, and then describe the
2737 range with a lower and upper bound. If one of the bounds is omitted,
2738 it represents either the highest or lowest value of the type.
2739
2740 In the comments below, we represent a range by two numbers in brackets
2741 preceded by a "+" to designate being inside that range, or a "-" to
2742 designate being outside that range, so the condition can be inverted by
2743 flipping the prefix. An omitted bound is represented by a "-". For
2744 example, "- [-, 10]" means being outside the range starting at the lowest
2745 possible value and ending at 10, in other words, being greater than 10.
2746 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
2747 always false.
2748
2749 We set up things so that the missing bounds are handled in a consistent
2750 manner so neither a missing bound nor "true" and "false" need to be
2751 handled using a special case. */
2752
2753/* Return the result of applying CODE to ARG0 and ARG1, but handle the case
2754 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
2755 and UPPER1_P are nonzero if the respective argument is an upper bound
2756 and zero for a lower. TYPE, if nonzero, is the type of the result; it
2757 must be specified for a comparison. ARG1 will be converted to ARG0's
2758 type if both are specified. */
2759
2760static tree
2761range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
2762 enum tree_code code;
2763 tree type;
2764 tree arg0, arg1;
2765 int upper0_p, upper1_p;
2766{
2767 tree tem;
2768 int result;
2769 int sgn0, sgn1;
2770
2771 /* If neither arg represents infinity, do the normal operation.
2772 Else, if not a comparison, return infinity. Else handle the special
2773 comparison rules. Note that most of the cases below won't occur, but
2774 are handled for consistency. */
2775
2776 if (arg0 != 0 && arg1 != 0)
2777 {
2778 tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
2779 arg0, convert (TREE_TYPE (arg0), arg1)));
2780 STRIP_NOPS (tem);
2781 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
2782 }
2783
2784 if (TREE_CODE_CLASS (code) != '<')
2785 return 0;
2786
2787 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
2788 for neither. In real maths, we cannot assume open ended ranges are
2789 the same. But, this is computer arithmetic, where numbers are finite.
2790 We can therefore make the transformation of any unbounded range with
2791 the value Z, Z being greater than any representable number. This permits
2792 us to treat unbounded ranges as equal. */
2793 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
2794 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
2795 switch (code)
2796 {
2797 case EQ_EXPR:
2798 result = sgn0 == sgn1;
2799 break;
2800 case NE_EXPR:
2801 result = sgn0 != sgn1;
2802 break;
2803 case LT_EXPR:
2804 result = sgn0 < sgn1;
2805 break;
2806 case LE_EXPR:
2807 result = sgn0 <= sgn1;
2808 break;
2809 case GT_EXPR:
2810 result = sgn0 > sgn1;
2811 break;
2812 case GE_EXPR:
2813 result = sgn0 >= sgn1;
2814 break;
2815 default:
2816 abort ();
2817 }
2818
2819 return convert (type, result ? integer_one_node : integer_zero_node);
2820}
2821
2822/* Given EXP, a logical expression, set the range it is testing into
2823 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
2824 actually being tested. *PLOW and *PHIGH will have be made the same type
2825 as the returned expression. If EXP is not a comparison, we will most
2826 likely not be returning a useful value and range. */
2827
2828static tree
2829make_range (exp, pin_p, plow, phigh)
2830 tree exp;
2831 int *pin_p;
2832 tree *plow, *phigh;
2833{
2834 enum tree_code code;
| 2832 return convert (compare_type,
2833 (code == NE_EXPR
2834 ? integer_one_node : integer_zero_node));
2835 }
2836 }
2837
2838 /* Single-bit compares should always be against zero. */
2839 if (lbitsize == 1 && ! integer_zerop (rhs))
2840 {
2841 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2842 rhs = convert (type, integer_zero_node);
2843 }
2844
2845 /* Make a new bitfield reference, shift the constant over the
2846 appropriate number of bits and mask it with the computed mask
2847 (in case this was a signed field). If we changed it, make a new one. */
2848 lhs = make_bit_field_ref (linner, unsigned_type, lnbitsize, lnbitpos, 1);
2849 if (lvolatilep)
2850 {
2851 TREE_SIDE_EFFECTS (lhs) = 1;
2852 TREE_THIS_VOLATILE (lhs) = 1;
2853 }
2854
2855 rhs = fold (const_binop (BIT_AND_EXPR,
2856 const_binop (LSHIFT_EXPR,
2857 convert (unsigned_type, rhs),
2858 size_int (lbitpos), 0),
2859 mask, 0));
2860
2861 return build (code, compare_type,
2862 build (BIT_AND_EXPR, unsigned_type, lhs, mask),
2863 rhs);
2864}
2865
2866/* Subroutine for fold_truthop: decode a field reference.
2867
2868 If EXP is a comparison reference, we return the innermost reference.
2869
2870 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2871 set to the starting bit number.
2872
2873 If the innermost field can be completely contained in a mode-sized
2874 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
2875
2876 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2877 otherwise it is not changed.
2878
2879 *PUNSIGNEDP is set to the signedness of the field.
2880
2881 *PMASK is set to the mask used. This is either contained in a
2882 BIT_AND_EXPR or derived from the width of the field.
2883
2884 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
2885
2886 Return 0 if this is not a component reference or is one that we can't
2887 do anything with. */
2888
2889static tree
2890decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
2891 pvolatilep, pmask, pand_mask)
2892 tree exp;
2893 int *pbitsize, *pbitpos;
2894 enum machine_mode *pmode;
2895 int *punsignedp, *pvolatilep;
2896 tree *pmask;
2897 tree *pand_mask;
2898{
2899 tree and_mask = 0;
2900 tree mask, inner, offset;
2901 tree unsigned_type;
2902 int precision;
2903 int alignment;
2904
2905 /* All the optimizations using this function assume integer fields.
2906 There are problems with FP fields since the type_for_size call
2907 below can fail for, e.g., XFmode. */
2908 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2909 return 0;
2910
2911 STRIP_NOPS (exp);
2912
2913 if (TREE_CODE (exp) == BIT_AND_EXPR)
2914 {
2915 and_mask = TREE_OPERAND (exp, 1);
2916 exp = TREE_OPERAND (exp, 0);
2917 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
2918 if (TREE_CODE (and_mask) != INTEGER_CST)
2919 return 0;
2920 }
2921
2922
2923 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
2924 punsignedp, pvolatilep, &alignment);
2925 if ((inner == exp && and_mask == 0)
2926 || *pbitsize < 0 || offset != 0)
2927 return 0;
2928
2929 /* Compute the mask to access the bitfield. */
2930 unsigned_type = type_for_size (*pbitsize, 1);
2931 precision = TYPE_PRECISION (unsigned_type);
2932
2933 mask = build_int_2 (~0, ~0);
2934 TREE_TYPE (mask) = unsigned_type;
2935 force_fit_type (mask, 0);
2936 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2937 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2938
2939 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
2940 if (and_mask != 0)
2941 mask = fold (build (BIT_AND_EXPR, unsigned_type,
2942 convert (unsigned_type, and_mask), mask));
2943
2944 *pmask = mask;
2945 *pand_mask = and_mask;
2946 return inner;
2947}
2948
2949/* Return non-zero if MASK represents a mask of SIZE ones in the low-order
2950 bit positions. */
2951
2952static int
2953all_ones_mask_p (mask, size)
2954 tree mask;
2955 int size;
2956{
2957 tree type = TREE_TYPE (mask);
2958 int precision = TYPE_PRECISION (type);
2959 tree tmask;
2960
2961 tmask = build_int_2 (~0, ~0);
2962 TREE_TYPE (tmask) = signed_type (type);
2963 force_fit_type (tmask, 0);
2964 return
2965 tree_int_cst_equal (mask,
2966 const_binop (RSHIFT_EXPR,
2967 const_binop (LSHIFT_EXPR, tmask,
2968 size_int (precision - size),
2969 0),
2970 size_int (precision - size), 0));
2971}
2972
2973/* Subroutine for fold_truthop: determine if an operand is simple enough
2974 to be evaluated unconditionally. */
2975
2976static int
2977simple_operand_p (exp)
2978 tree exp;
2979{
2980 /* Strip any conversions that don't change the machine mode. */
2981 while ((TREE_CODE (exp) == NOP_EXPR
2982 || TREE_CODE (exp) == CONVERT_EXPR)
2983 && (TYPE_MODE (TREE_TYPE (exp))
2984 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2985 exp = TREE_OPERAND (exp, 0);
2986
2987 return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2988 || (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
2989 && ! TREE_ADDRESSABLE (exp)
2990 && ! TREE_THIS_VOLATILE (exp)
2991 && ! DECL_NONLOCAL (exp)
2992 /* Don't regard global variables as simple. They may be
2993 allocated in ways unknown to the compiler (shared memory,
2994 #pragma weak, etc). */
2995 && ! TREE_PUBLIC (exp)
2996 && ! DECL_EXTERNAL (exp)
2997 /* Loading a static variable is unduly expensive, but global
2998 registers aren't expensive. */
2999 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3000}
3001
3002/* The following functions are subroutines to fold_range_test and allow it to
3003 try to change a logical combination of comparisons into a range test.
3004
3005 For example, both
3006 X == 2 && X == 3 && X == 4 && X == 5
3007 and
3008 X >= 2 && X <= 5
3009 are converted to
3010 (unsigned) (X - 2) <= 3
3011
3012 We describe each set of comparisons as being either inside or outside
3013 a range, using a variable named like IN_P, and then describe the
3014 range with a lower and upper bound. If one of the bounds is omitted,
3015 it represents either the highest or lowest value of the type.
3016
3017 In the comments below, we represent a range by two numbers in brackets
3018 preceded by a "+" to designate being inside that range, or a "-" to
3019 designate being outside that range, so the condition can be inverted by
3020 flipping the prefix. An omitted bound is represented by a "-". For
3021 example, "- [-, 10]" means being outside the range starting at the lowest
3022 possible value and ending at 10, in other words, being greater than 10.
3023 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3024 always false.
3025
3026 We set up things so that the missing bounds are handled in a consistent
3027 manner so neither a missing bound nor "true" and "false" need to be
3028 handled using a special case. */
3029
3030/* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3031 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3032 and UPPER1_P are nonzero if the respective argument is an upper bound
3033 and zero for a lower. TYPE, if nonzero, is the type of the result; it
3034 must be specified for a comparison. ARG1 will be converted to ARG0's
3035 type if both are specified. */
3036
3037static tree
3038range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
3039 enum tree_code code;
3040 tree type;
3041 tree arg0, arg1;
3042 int upper0_p, upper1_p;
3043{
3044 tree tem;
3045 int result;
3046 int sgn0, sgn1;
3047
3048 /* If neither arg represents infinity, do the normal operation.
3049 Else, if not a comparison, return infinity. Else handle the special
3050 comparison rules. Note that most of the cases below won't occur, but
3051 are handled for consistency. */
3052
3053 if (arg0 != 0 && arg1 != 0)
3054 {
3055 tem = fold (build (code, type != 0 ? type : TREE_TYPE (arg0),
3056 arg0, convert (TREE_TYPE (arg0), arg1)));
3057 STRIP_NOPS (tem);
3058 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3059 }
3060
3061 if (TREE_CODE_CLASS (code) != '<')
3062 return 0;
3063
3064 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3065 for neither. In real maths, we cannot assume open ended ranges are
3066 the same. But, this is computer arithmetic, where numbers are finite.
3067 We can therefore make the transformation of any unbounded range with
3068 the value Z, Z being greater than any representable number. This permits
3069 us to treat unbounded ranges as equal. */
3070 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3071 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3072 switch (code)
3073 {
3074 case EQ_EXPR:
3075 result = sgn0 == sgn1;
3076 break;
3077 case NE_EXPR:
3078 result = sgn0 != sgn1;
3079 break;
3080 case LT_EXPR:
3081 result = sgn0 < sgn1;
3082 break;
3083 case LE_EXPR:
3084 result = sgn0 <= sgn1;
3085 break;
3086 case GT_EXPR:
3087 result = sgn0 > sgn1;
3088 break;
3089 case GE_EXPR:
3090 result = sgn0 >= sgn1;
3091 break;
3092 default:
3093 abort ();
3094 }
3095
3096 return convert (type, result ? integer_one_node : integer_zero_node);
3097}
3098
3099/* Given EXP, a logical expression, set the range it is testing into
3100 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
3101 actually being tested. *PLOW and *PHIGH will have be made the same type
3102 as the returned expression. If EXP is not a comparison, we will most
3103 likely not be returning a useful value and range. */
3104
3105static tree
3106make_range (exp, pin_p, plow, phigh)
3107 tree exp;
3108 int *pin_p;
3109 tree *plow, *phigh;
3110{
3111 enum tree_code code;
|
2835 tree arg0, arg1, type = NULL_TREE;
| 3112 tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
|
2836 tree orig_type = NULL_TREE;
2837 int in_p, n_in_p;
2838 tree low, high, n_low, n_high;
2839
2840 /* Start with simply saying "EXP != 0" and then look at the code of EXP
2841 and see if we can refine the range. Some of the cases below may not
2842 happen, but it doesn't seem worth worrying about this. We "continue"
2843 the outer loop when we've changed something; otherwise we "break"
2844 the switch, which will "break" the while. */
2845
2846 in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
2847
2848 while (1)
2849 {
2850 code = TREE_CODE (exp);
2851
2852 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
2853 {
2854 arg0 = TREE_OPERAND (exp, 0);
2855 if (TREE_CODE_CLASS (code) == '<'
2856 || TREE_CODE_CLASS (code) == '1'
2857 || TREE_CODE_CLASS (code) == '2')
2858 type = TREE_TYPE (arg0);
2859 if (TREE_CODE_CLASS (code) == '2'
2860 || TREE_CODE_CLASS (code) == '<'
2861 || (TREE_CODE_CLASS (code) == 'e'
2862 && tree_code_length[(int) code] > 1))
2863 arg1 = TREE_OPERAND (exp, 1);
2864 }
2865
| 3113 tree orig_type = NULL_TREE;
3114 int in_p, n_in_p;
3115 tree low, high, n_low, n_high;
3116
3117 /* Start with simply saying "EXP != 0" and then look at the code of EXP
3118 and see if we can refine the range. Some of the cases below may not
3119 happen, but it doesn't seem worth worrying about this. We "continue"
3120 the outer loop when we've changed something; otherwise we "break"
3121 the switch, which will "break" the while. */
3122
3123 in_p = 0, low = high = convert (TREE_TYPE (exp), integer_zero_node);
3124
3125 while (1)
3126 {
3127 code = TREE_CODE (exp);
3128
3129 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3130 {
3131 arg0 = TREE_OPERAND (exp, 0);
3132 if (TREE_CODE_CLASS (code) == '<'
3133 || TREE_CODE_CLASS (code) == '1'
3134 || TREE_CODE_CLASS (code) == '2')
3135 type = TREE_TYPE (arg0);
3136 if (TREE_CODE_CLASS (code) == '2'
3137 || TREE_CODE_CLASS (code) == '<'
3138 || (TREE_CODE_CLASS (code) == 'e'
3139 && tree_code_length[(int) code] > 1))
3140 arg1 = TREE_OPERAND (exp, 1);
3141 }
3142
|
| 3143 /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
3144 lose a cast by accident. */
3145 if (type != NULL_TREE && orig_type == NULL_TREE)
3146 orig_type = type;
3147
|
2866 switch (code)
2867 {
2868 case TRUTH_NOT_EXPR:
2869 in_p = ! in_p, exp = arg0;
2870 continue;
2871
2872 case EQ_EXPR: case NE_EXPR:
2873 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
2874 /* We can only do something if the range is testing for zero
2875 and if the second operand is an integer constant. Note that
2876 saying something is "in" the range we make is done by
2877 complementing IN_P since it will set in the initial case of
2878 being not equal to zero; "out" is leaving it alone. */
2879 if (low == 0 || high == 0
2880 || ! integer_zerop (low) || ! integer_zerop (high)
2881 || TREE_CODE (arg1) != INTEGER_CST)
2882 break;
2883
2884 switch (code)
2885 {
2886 case NE_EXPR: /* - [c, c] */
2887 low = high = arg1;
2888 break;
2889 case EQ_EXPR: /* + [c, c] */
2890 in_p = ! in_p, low = high = arg1;
2891 break;
2892 case GT_EXPR: /* - [-, c] */
2893 low = 0, high = arg1;
2894 break;
2895 case GE_EXPR: /* + [c, -] */
2896 in_p = ! in_p, low = arg1, high = 0;
2897 break;
2898 case LT_EXPR: /* - [c, -] */
2899 low = arg1, high = 0;
2900 break;
2901 case LE_EXPR: /* + [-, c] */
2902 in_p = ! in_p, low = 0, high = arg1;
2903 break;
2904 default:
2905 abort ();
2906 }
2907
2908 exp = arg0;
2909
2910 /* If this is an unsigned comparison, we also know that EXP is
2911 greater than or equal to zero. We base the range tests we make
2912 on that fact, so we record it here so we can parse existing
2913 range tests. */
2914 if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
2915 {
2916 if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
2917 1, convert (type, integer_zero_node),
2918 NULL_TREE))
2919 break;
2920
2921 in_p = n_in_p, low = n_low, high = n_high;
2922
2923 /* If the high bound is missing, reverse the range so it
2924 goes from zero to the low bound minus 1. */
2925 if (high == 0)
2926 {
2927 in_p = ! in_p;
2928 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
2929 integer_one_node, 0);
2930 low = convert (type, integer_zero_node);
2931 }
2932 }
2933 continue;
2934
2935 case NEGATE_EXPR:
2936 /* (-x) IN [a,b] -> x in [-b, -a] */
2937 n_low = range_binop (MINUS_EXPR, type,
2938 convert (type, integer_zero_node), 0, high, 1);
2939 n_high = range_binop (MINUS_EXPR, type,
2940 convert (type, integer_zero_node), 0, low, 0);
2941 low = n_low, high = n_high;
2942 exp = arg0;
2943 continue;
2944
2945 case BIT_NOT_EXPR:
2946 /* ~ X -> -X - 1 */
2947 exp = build (MINUS_EXPR, type, build1 (NEGATE_EXPR, type, arg0),
2948 convert (type, integer_one_node));
2949 continue;
2950
2951 case PLUS_EXPR: case MINUS_EXPR:
2952 if (TREE_CODE (arg1) != INTEGER_CST)
2953 break;
2954
2955 /* If EXP is signed, any overflow in the computation is undefined,
2956 so we don't worry about it so long as our computations on
2957 the bounds don't overflow. For unsigned, overflow is defined
2958 and this is exactly the right thing. */
2959 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
2960 type, low, 0, arg1, 0);
2961 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
2962 type, high, 1, arg1, 0);
2963 if ((n_low != 0 && TREE_OVERFLOW (n_low))
2964 || (n_high != 0 && TREE_OVERFLOW (n_high)))
2965 break;
2966
2967 /* Check for an unsigned range which has wrapped around the maximum
2968 value thus making n_high < n_low, and normalize it. */
2969 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
2970 {
2971 low = range_binop (PLUS_EXPR, type, n_high, 0,
2972 integer_one_node, 0);
2973 high = range_binop (MINUS_EXPR, type, n_low, 0,
2974 integer_one_node, 0);
2975 in_p = ! in_p;
2976 }
2977 else
2978 low = n_low, high = n_high;
2979
2980 exp = arg0;
2981 continue;
2982
2983 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
| 3148 switch (code)
3149 {
3150 case TRUTH_NOT_EXPR:
3151 in_p = ! in_p, exp = arg0;
3152 continue;
3153
3154 case EQ_EXPR: case NE_EXPR:
3155 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3156 /* We can only do something if the range is testing for zero
3157 and if the second operand is an integer constant. Note that
3158 saying something is "in" the range we make is done by
3159 complementing IN_P since it will set in the initial case of
3160 being not equal to zero; "out" is leaving it alone. */
3161 if (low == 0 || high == 0
3162 || ! integer_zerop (low) || ! integer_zerop (high)
3163 || TREE_CODE (arg1) != INTEGER_CST)
3164 break;
3165
3166 switch (code)
3167 {
3168 case NE_EXPR: /* - [c, c] */
3169 low = high = arg1;
3170 break;
3171 case EQ_EXPR: /* + [c, c] */
3172 in_p = ! in_p, low = high = arg1;
3173 break;
3174 case GT_EXPR: /* - [-, c] */
3175 low = 0, high = arg1;
3176 break;
3177 case GE_EXPR: /* + [c, -] */
3178 in_p = ! in_p, low = arg1, high = 0;
3179 break;
3180 case LT_EXPR: /* - [c, -] */
3181 low = arg1, high = 0;
3182 break;
3183 case LE_EXPR: /* + [-, c] */
3184 in_p = ! in_p, low = 0, high = arg1;
3185 break;
3186 default:
3187 abort ();
3188 }
3189
3190 exp = arg0;
3191
3192 /* If this is an unsigned comparison, we also know that EXP is
3193 greater than or equal to zero. We base the range tests we make
3194 on that fact, so we record it here so we can parse existing
3195 range tests. */
3196 if (TREE_UNSIGNED (type) && (low == 0 || high == 0))
3197 {
3198 if (! merge_ranges (&n_in_p, &n_low, &n_high, in_p, low, high,
3199 1, convert (type, integer_zero_node),
3200 NULL_TREE))
3201 break;
3202
3203 in_p = n_in_p, low = n_low, high = n_high;
3204
3205 /* If the high bound is missing, reverse the range so it
3206 goes from zero to the low bound minus 1. */
3207 if (high == 0)
3208 {
3209 in_p = ! in_p;
3210 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3211 integer_one_node, 0);
3212 low = convert (type, integer_zero_node);
3213 }
3214 }
3215 continue;
3216
3217 case NEGATE_EXPR:
3218 /* (-x) IN [a,b] -> x in [-b, -a] */
3219 n_low = range_binop (MINUS_EXPR, type,
3220 convert (type, integer_zero_node), 0, high, 1);
3221 n_high = range_binop (MINUS_EXPR, type,
3222 convert (type, integer_zero_node), 0, low, 0);
3223 low = n_low, high = n_high;
3224 exp = arg0;
3225 continue;
3226
3227 case BIT_NOT_EXPR:
3228 /* ~ X -> -X - 1 */
3229 exp = build (MINUS_EXPR, type, build1 (NEGATE_EXPR, type, arg0),
3230 convert (type, integer_one_node));
3231 continue;
3232
3233 case PLUS_EXPR: case MINUS_EXPR:
3234 if (TREE_CODE (arg1) != INTEGER_CST)
3235 break;
3236
3237 /* If EXP is signed, any overflow in the computation is undefined,
3238 so we don't worry about it so long as our computations on
3239 the bounds don't overflow. For unsigned, overflow is defined
3240 and this is exactly the right thing. */
3241 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3242 type, low, 0, arg1, 0);
3243 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3244 type, high, 1, arg1, 0);
3245 if ((n_low != 0 && TREE_OVERFLOW (n_low))
3246 || (n_high != 0 && TREE_OVERFLOW (n_high)))
3247 break;
3248
3249 /* Check for an unsigned range which has wrapped around the maximum
3250 value thus making n_high < n_low, and normalize it. */
3251 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3252 {
3253 low = range_binop (PLUS_EXPR, type, n_high, 0,
3254 integer_one_node, 0);
3255 high = range_binop (MINUS_EXPR, type, n_low, 0,
3256 integer_one_node, 0);
3257 in_p = ! in_p;
3258 }
3259 else
3260 low = n_low, high = n_high;
3261
3262 exp = arg0;
3263 continue;
3264
3265 case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR:
|
2984 if (orig_type == NULL_TREE)
2985 orig_type = type;
| |
2986 if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
2987 break;
2988
2989 if (! INTEGRAL_TYPE_P (type)
2990 || (low != 0 && ! int_fits_type_p (low, type))
2991 || (high != 0 && ! int_fits_type_p (high, type)))
2992 break;
2993
2994 n_low = low, n_high = high;
2995
2996 if (n_low != 0)
2997 n_low = convert (type, n_low);
2998
2999 if (n_high != 0)
3000 n_high = convert (type, n_high);
3001
3002 /* If we're converting from an unsigned to a signed type,
3003 we will be doing the comparison as unsigned. The tests above
3004 have already verified that LOW and HIGH are both positive.
3005
3006 So we have to make sure that the original unsigned value will
3007 be interpreted as positive. */
3008 if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3009 {
3010 tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
3011 tree high_positive;
3012
3013 /* A range without an upper bound is, naturally, unbounded.
3014 Since convert would have cropped a very large value, use
3015 the max value for the destination type. */
3016
3017 high_positive = TYPE_MAX_VALUE (equiv_type);
3018 if (!high_positive)
3019 {
3020 high_positive = TYPE_MAX_VALUE (type);
3021 if (!high_positive)
3022 abort();
3023 }
3024 high_positive = fold (build (RSHIFT_EXPR, type,
3025 convert (type, high_positive),
3026 convert (type, integer_one_node)));
3027
3028 /* If the low bound is specified, "and" the range with the
3029 range for which the original unsigned value will be
3030 positive. */
3031 if (low != 0)
3032 {
3033 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3034 1, n_low, n_high,
3035 1, convert (type, integer_zero_node),
3036 high_positive))
3037 break;
3038
3039 in_p = (n_in_p == in_p);
3040 }
3041 else
3042 {
3043 /* Otherwise, "or" the range with the range of the input
3044 that will be interpreted as negative. */
3045 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3046 0, n_low, n_high,
3047 1, convert (type, integer_zero_node),
3048 high_positive))
3049 break;
3050
3051 in_p = (in_p != n_in_p);
3052 }
3053 }
3054
3055 exp = arg0;
3056 low = n_low, high = n_high;
3057 continue;
3058
3059 default:
3060 break;
3061 }
3062
3063 break;
3064 }
3065
3066 /* If EXP is a constant, we can evaluate whether this is true or false. */
3067 if (TREE_CODE (exp) == INTEGER_CST)
3068 {
3069 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3070 exp, 0, low, 0))
3071 && integer_onep (range_binop (LE_EXPR, integer_type_node,
3072 exp, 1, high, 1)));
3073 low = high = 0;
3074 exp = 0;
3075 }
3076
3077 *pin_p = in_p, *plow = low, *phigh = high;
3078 return exp;
3079}
3080
3081/* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3082 type, TYPE, return an expression to test if EXP is in (or out of, depending
3083 on IN_P) the range. */
3084
3085static tree
3086build_range_check (type, exp, in_p, low, high)
3087 tree type;
3088 tree exp;
3089 int in_p;
3090 tree low, high;
3091{
3092 tree etype = TREE_TYPE (exp);
3093 tree utype, value;
3094
3095 if (! in_p
3096 && (0 != (value = build_range_check (type, exp, 1, low, high))))
3097 return invert_truthvalue (value);
3098
3099 else if (low == 0 && high == 0)
3100 return convert (type, integer_one_node);
3101
3102 else if (low == 0)
3103 return fold (build (LE_EXPR, type, exp, high));
3104
3105 else if (high == 0)
3106 return fold (build (GE_EXPR, type, exp, low));
3107
3108 else if (operand_equal_p (low, high, 0))
3109 return fold (build (EQ_EXPR, type, exp, low));
3110
3111 else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3112 return build_range_check (type, exp, 1, 0, high);
3113
3114 else if (integer_zerop (low))
3115 {
3116 utype = unsigned_type (etype);
3117 return build_range_check (type, convert (utype, exp), 1, 0,
3118 convert (utype, high));
3119 }
3120
3121 else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3122 && ! TREE_OVERFLOW (value))
3123 return build_range_check (type,
3124 fold (build (MINUS_EXPR, etype, exp, low)),
3125 1, convert (etype, integer_zero_node), value);
3126 else
3127 return 0;
3128}
3129
3130/* Given two ranges, see if we can merge them into one. Return 1 if we
3131 can, 0 if we can't. Set the output range into the specified parameters. */
3132
3133static int
3134merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3135 int *pin_p;
3136 tree *plow, *phigh;
3137 int in0_p, in1_p;
3138 tree low0, high0, low1, high1;
3139{
3140 int no_overlap;
3141 int subset;
3142 int temp;
3143 tree tem;
3144 int in_p;
3145 tree low, high;
3146 int lowequal = ((low0 == 0 && low1 == 0)
3147 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3148 low0, 0, low1, 0)));
3149 int highequal = ((high0 == 0 && high1 == 0)
3150 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3151 high0, 1, high1, 1)));
3152
3153 /* Make range 0 be the range that starts first, or ends last if they
3154 start at the same value. Swap them if it isn't. */
3155 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3156 low0, 0, low1, 0))
3157 || (lowequal
3158 && integer_onep (range_binop (GT_EXPR, integer_type_node,
3159 high1, 1, high0, 1))))
3160 {
3161 temp = in0_p, in0_p = in1_p, in1_p = temp;
3162 tem = low0, low0 = low1, low1 = tem;
3163 tem = high0, high0 = high1, high1 = tem;
3164 }
3165
3166 /* Now flag two cases, whether the ranges are disjoint or whether the
3167 second range is totally subsumed in the first. Note that the tests
3168 below are simplified by the ones above. */
3169 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3170 high0, 1, low1, 0));
3171 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3172 high1, 1, high0, 1));
3173
3174 /* We now have four cases, depending on whether we are including or
3175 excluding the two ranges. */
3176 if (in0_p && in1_p)
3177 {
3178 /* If they don't overlap, the result is false. If the second range
3179 is a subset it is the result. Otherwise, the range is from the start
3180 of the second to the end of the first. */
3181 if (no_overlap)
3182 in_p = 0, low = high = 0;
3183 else if (subset)
3184 in_p = 1, low = low1, high = high1;
3185 else
3186 in_p = 1, low = low1, high = high0;
3187 }
3188
3189 else if (in0_p && ! in1_p)
3190 {
3191 /* If they don't overlap, the result is the first range. If they are
3192 equal, the result is false. If the second range is a subset of the
3193 first, and the ranges begin at the same place, we go from just after
3194 the end of the first range to the end of the second. If the second
3195 range is not a subset of the first, or if it is a subset and both
3196 ranges end at the same place, the range starts at the start of the
3197 first range and ends just before the second range.
3198 Otherwise, we can't describe this as a single range. */
3199 if (no_overlap)
3200 in_p = 1, low = low0, high = high0;
3201 else if (lowequal && highequal)
3202 in_p = 0, low = high = 0;
3203 else if (subset && lowequal)
3204 {
3205 in_p = 1, high = high0;
3206 low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3207 integer_one_node, 0);
3208 }
3209 else if (! subset || highequal)
3210 {
3211 in_p = 1, low = low0;
3212 high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3213 integer_one_node, 0);
3214 }
3215 else
3216 return 0;
3217 }
3218
3219 else if (! in0_p && in1_p)
3220 {
3221 /* If they don't overlap, the result is the second range. If the second
3222 is a subset of the first, the result is false. Otherwise,
3223 the range starts just after the first range and ends at the
3224 end of the second. */
3225 if (no_overlap)
3226 in_p = 1, low = low1, high = high1;
3227 else if (subset)
3228 in_p = 0, low = high = 0;
3229 else
3230 {
3231 in_p = 1, high = high1;
3232 low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3233 integer_one_node, 0);
3234 }
3235 }
3236
3237 else
3238 {
3239 /* The case where we are excluding both ranges. Here the complex case
3240 is if they don't overlap. In that case, the only time we have a
3241 range is if they are adjacent. If the second is a subset of the
3242 first, the result is the first. Otherwise, the range to exclude
3243 starts at the beginning of the first range and ends at the end of the
3244 second. */
3245 if (no_overlap)
3246 {
3247 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3248 range_binop (PLUS_EXPR, NULL_TREE,
3249 high0, 1,
3250 integer_one_node, 1),
3251 1, low1, 0)))
3252 in_p = 0, low = low0, high = high1;
3253 else
3254 return 0;
3255 }
3256 else if (subset)
3257 in_p = 0, low = low0, high = high0;
3258 else
3259 in_p = 0, low = low0, high = high1;
3260 }
3261
3262 *pin_p = in_p, *plow = low, *phigh = high;
3263 return 1;
3264}
3265
3266/* EXP is some logical combination of boolean tests. See if we can
3267 merge it into some range test. Return the new tree if so. */
3268
3269static tree
3270fold_range_test (exp)
3271 tree exp;
3272{
3273 int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3274 || TREE_CODE (exp) == TRUTH_OR_EXPR);
3275 int in0_p, in1_p, in_p;
3276 tree low0, low1, low, high0, high1, high;
3277 tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3278 tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3279 tree tem;
3280
3281 /* If this is an OR operation, invert both sides; we will invert
3282 again at the end. */
3283 if (or_op)
3284 in0_p = ! in0_p, in1_p = ! in1_p;
3285
3286 /* If both expressions are the same, if we can merge the ranges, and we
3287 can build the range test, return it or it inverted. If one of the
3288 ranges is always true or always false, consider it to be the same
3289 expression as the other. */
3290 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3291 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3292 in1_p, low1, high1)
3293 && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3294 lhs != 0 ? lhs
3295 : rhs != 0 ? rhs : integer_zero_node,
3296 in_p, low, high))))
3297 return or_op ? invert_truthvalue (tem) : tem;
3298
3299 /* On machines where the branch cost is expensive, if this is a
3300 short-circuited branch and the underlying object on both sides
3301 is the same, make a non-short-circuit operation. */
3302 else if (BRANCH_COST >= 2
3303 && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3304 || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3305 && operand_equal_p (lhs, rhs, 0))
3306 {
3307 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
3308 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3309 which cases we can't do this. */
3310 if (simple_operand_p (lhs))
3311 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3312 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3313 TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3314 TREE_OPERAND (exp, 1));
3315
3316 else if (current_function_decl != 0
3317 && ! contains_placeholder_p (lhs))
3318 {
3319 tree common = save_expr (lhs);
3320
3321 if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3322 or_op ? ! in0_p : in0_p,
3323 low0, high0))
3324 && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3325 or_op ? ! in1_p : in1_p,
3326 low1, high1))))
3327 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3328 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3329 TREE_TYPE (exp), lhs, rhs);
3330 }
3331 }
3332
| 3266 if (TYPE_PRECISION (type) > TYPE_PRECISION (orig_type))
3267 break;
3268
3269 if (! INTEGRAL_TYPE_P (type)
3270 || (low != 0 && ! int_fits_type_p (low, type))
3271 || (high != 0 && ! int_fits_type_p (high, type)))
3272 break;
3273
3274 n_low = low, n_high = high;
3275
3276 if (n_low != 0)
3277 n_low = convert (type, n_low);
3278
3279 if (n_high != 0)
3280 n_high = convert (type, n_high);
3281
3282 /* If we're converting from an unsigned to a signed type,
3283 we will be doing the comparison as unsigned. The tests above
3284 have already verified that LOW and HIGH are both positive.
3285
3286 So we have to make sure that the original unsigned value will
3287 be interpreted as positive. */
3288 if (TREE_UNSIGNED (type) && ! TREE_UNSIGNED (TREE_TYPE (exp)))
3289 {
3290 tree equiv_type = type_for_mode (TYPE_MODE (type), 1);
3291 tree high_positive;
3292
3293 /* A range without an upper bound is, naturally, unbounded.
3294 Since convert would have cropped a very large value, use
3295 the max value for the destination type. */
3296
3297 high_positive = TYPE_MAX_VALUE (equiv_type);
3298 if (!high_positive)
3299 {
3300 high_positive = TYPE_MAX_VALUE (type);
3301 if (!high_positive)
3302 abort();
3303 }
3304 high_positive = fold (build (RSHIFT_EXPR, type,
3305 convert (type, high_positive),
3306 convert (type, integer_one_node)));
3307
3308 /* If the low bound is specified, "and" the range with the
3309 range for which the original unsigned value will be
3310 positive. */
3311 if (low != 0)
3312 {
3313 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3314 1, n_low, n_high,
3315 1, convert (type, integer_zero_node),
3316 high_positive))
3317 break;
3318
3319 in_p = (n_in_p == in_p);
3320 }
3321 else
3322 {
3323 /* Otherwise, "or" the range with the range of the input
3324 that will be interpreted as negative. */
3325 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3326 0, n_low, n_high,
3327 1, convert (type, integer_zero_node),
3328 high_positive))
3329 break;
3330
3331 in_p = (in_p != n_in_p);
3332 }
3333 }
3334
3335 exp = arg0;
3336 low = n_low, high = n_high;
3337 continue;
3338
3339 default:
3340 break;
3341 }
3342
3343 break;
3344 }
3345
3346 /* If EXP is a constant, we can evaluate whether this is true or false. */
3347 if (TREE_CODE (exp) == INTEGER_CST)
3348 {
3349 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
3350 exp, 0, low, 0))
3351 && integer_onep (range_binop (LE_EXPR, integer_type_node,
3352 exp, 1, high, 1)));
3353 low = high = 0;
3354 exp = 0;
3355 }
3356
3357 *pin_p = in_p, *plow = low, *phigh = high;
3358 return exp;
3359}
3360
3361/* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
3362 type, TYPE, return an expression to test if EXP is in (or out of, depending
3363 on IN_P) the range. */
3364
3365static tree
3366build_range_check (type, exp, in_p, low, high)
3367 tree type;
3368 tree exp;
3369 int in_p;
3370 tree low, high;
3371{
3372 tree etype = TREE_TYPE (exp);
3373 tree utype, value;
3374
3375 if (! in_p
3376 && (0 != (value = build_range_check (type, exp, 1, low, high))))
3377 return invert_truthvalue (value);
3378
3379 else if (low == 0 && high == 0)
3380 return convert (type, integer_one_node);
3381
3382 else if (low == 0)
3383 return fold (build (LE_EXPR, type, exp, high));
3384
3385 else if (high == 0)
3386 return fold (build (GE_EXPR, type, exp, low));
3387
3388 else if (operand_equal_p (low, high, 0))
3389 return fold (build (EQ_EXPR, type, exp, low));
3390
3391 else if (TREE_UNSIGNED (etype) && integer_zerop (low))
3392 return build_range_check (type, exp, 1, 0, high);
3393
3394 else if (integer_zerop (low))
3395 {
3396 utype = unsigned_type (etype);
3397 return build_range_check (type, convert (utype, exp), 1, 0,
3398 convert (utype, high));
3399 }
3400
3401 else if (0 != (value = const_binop (MINUS_EXPR, high, low, 0))
3402 && ! TREE_OVERFLOW (value))
3403 return build_range_check (type,
3404 fold (build (MINUS_EXPR, etype, exp, low)),
3405 1, convert (etype, integer_zero_node), value);
3406 else
3407 return 0;
3408}
3409
3410/* Given two ranges, see if we can merge them into one. Return 1 if we
3411 can, 0 if we can't. Set the output range into the specified parameters. */
3412
3413static int
3414merge_ranges (pin_p, plow, phigh, in0_p, low0, high0, in1_p, low1, high1)
3415 int *pin_p;
3416 tree *plow, *phigh;
3417 int in0_p, in1_p;
3418 tree low0, high0, low1, high1;
3419{
3420 int no_overlap;
3421 int subset;
3422 int temp;
3423 tree tem;
3424 int in_p;
3425 tree low, high;
3426 int lowequal = ((low0 == 0 && low1 == 0)
3427 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3428 low0, 0, low1, 0)));
3429 int highequal = ((high0 == 0 && high1 == 0)
3430 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
3431 high0, 1, high1, 1)));
3432
3433 /* Make range 0 be the range that starts first, or ends last if they
3434 start at the same value. Swap them if it isn't. */
3435 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
3436 low0, 0, low1, 0))
3437 || (lowequal
3438 && integer_onep (range_binop (GT_EXPR, integer_type_node,
3439 high1, 1, high0, 1))))
3440 {
3441 temp = in0_p, in0_p = in1_p, in1_p = temp;
3442 tem = low0, low0 = low1, low1 = tem;
3443 tem = high0, high0 = high1, high1 = tem;
3444 }
3445
3446 /* Now flag two cases, whether the ranges are disjoint or whether the
3447 second range is totally subsumed in the first. Note that the tests
3448 below are simplified by the ones above. */
3449 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
3450 high0, 1, low1, 0));
3451 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
3452 high1, 1, high0, 1));
3453
3454 /* We now have four cases, depending on whether we are including or
3455 excluding the two ranges. */
3456 if (in0_p && in1_p)
3457 {
3458 /* If they don't overlap, the result is false. If the second range
3459 is a subset it is the result. Otherwise, the range is from the start
3460 of the second to the end of the first. */
3461 if (no_overlap)
3462 in_p = 0, low = high = 0;
3463 else if (subset)
3464 in_p = 1, low = low1, high = high1;
3465 else
3466 in_p = 1, low = low1, high = high0;
3467 }
3468
3469 else if (in0_p && ! in1_p)
3470 {
3471 /* If they don't overlap, the result is the first range. If they are
3472 equal, the result is false. If the second range is a subset of the
3473 first, and the ranges begin at the same place, we go from just after
3474 the end of the first range to the end of the second. If the second
3475 range is not a subset of the first, or if it is a subset and both
3476 ranges end at the same place, the range starts at the start of the
3477 first range and ends just before the second range.
3478 Otherwise, we can't describe this as a single range. */
3479 if (no_overlap)
3480 in_p = 1, low = low0, high = high0;
3481 else if (lowequal && highequal)
3482 in_p = 0, low = high = 0;
3483 else if (subset && lowequal)
3484 {
3485 in_p = 1, high = high0;
3486 low = range_binop (PLUS_EXPR, NULL_TREE, high1, 0,
3487 integer_one_node, 0);
3488 }
3489 else if (! subset || highequal)
3490 {
3491 in_p = 1, low = low0;
3492 high = range_binop (MINUS_EXPR, NULL_TREE, low1, 0,
3493 integer_one_node, 0);
3494 }
3495 else
3496 return 0;
3497 }
3498
3499 else if (! in0_p && in1_p)
3500 {
3501 /* If they don't overlap, the result is the second range. If the second
3502 is a subset of the first, the result is false. Otherwise,
3503 the range starts just after the first range and ends at the
3504 end of the second. */
3505 if (no_overlap)
3506 in_p = 1, low = low1, high = high1;
3507 else if (subset)
3508 in_p = 0, low = high = 0;
3509 else
3510 {
3511 in_p = 1, high = high1;
3512 low = range_binop (PLUS_EXPR, NULL_TREE, high0, 1,
3513 integer_one_node, 0);
3514 }
3515 }
3516
3517 else
3518 {
3519 /* The case where we are excluding both ranges. Here the complex case
3520 is if they don't overlap. In that case, the only time we have a
3521 range is if they are adjacent. If the second is a subset of the
3522 first, the result is the first. Otherwise, the range to exclude
3523 starts at the beginning of the first range and ends at the end of the
3524 second. */
3525 if (no_overlap)
3526 {
3527 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
3528 range_binop (PLUS_EXPR, NULL_TREE,
3529 high0, 1,
3530 integer_one_node, 1),
3531 1, low1, 0)))
3532 in_p = 0, low = low0, high = high1;
3533 else
3534 return 0;
3535 }
3536 else if (subset)
3537 in_p = 0, low = low0, high = high0;
3538 else
3539 in_p = 0, low = low0, high = high1;
3540 }
3541
3542 *pin_p = in_p, *plow = low, *phigh = high;
3543 return 1;
3544}
3545
3546/* EXP is some logical combination of boolean tests. See if we can
3547 merge it into some range test. Return the new tree if so. */
3548
3549static tree
3550fold_range_test (exp)
3551 tree exp;
3552{
3553 int or_op = (TREE_CODE (exp) == TRUTH_ORIF_EXPR
3554 || TREE_CODE (exp) == TRUTH_OR_EXPR);
3555 int in0_p, in1_p, in_p;
3556 tree low0, low1, low, high0, high1, high;
3557 tree lhs = make_range (TREE_OPERAND (exp, 0), &in0_p, &low0, &high0);
3558 tree rhs = make_range (TREE_OPERAND (exp, 1), &in1_p, &low1, &high1);
3559 tree tem;
3560
3561 /* If this is an OR operation, invert both sides; we will invert
3562 again at the end. */
3563 if (or_op)
3564 in0_p = ! in0_p, in1_p = ! in1_p;
3565
3566 /* If both expressions are the same, if we can merge the ranges, and we
3567 can build the range test, return it or it inverted. If one of the
3568 ranges is always true or always false, consider it to be the same
3569 expression as the other. */
3570 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
3571 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
3572 in1_p, low1, high1)
3573 && 0 != (tem = (build_range_check (TREE_TYPE (exp),
3574 lhs != 0 ? lhs
3575 : rhs != 0 ? rhs : integer_zero_node,
3576 in_p, low, high))))
3577 return or_op ? invert_truthvalue (tem) : tem;
3578
3579 /* On machines where the branch cost is expensive, if this is a
3580 short-circuited branch and the underlying object on both sides
3581 is the same, make a non-short-circuit operation. */
3582 else if (BRANCH_COST >= 2
3583 && (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3584 || TREE_CODE (exp) == TRUTH_ORIF_EXPR)
3585 && operand_equal_p (lhs, rhs, 0))
3586 {
3587 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
3588 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
3589 which cases we can't do this. */
3590 if (simple_operand_p (lhs))
3591 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3592 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3593 TREE_TYPE (exp), TREE_OPERAND (exp, 0),
3594 TREE_OPERAND (exp, 1));
3595
3596 else if (current_function_decl != 0
3597 && ! contains_placeholder_p (lhs))
3598 {
3599 tree common = save_expr (lhs);
3600
3601 if (0 != (lhs = build_range_check (TREE_TYPE (exp), common,
3602 or_op ? ! in0_p : in0_p,
3603 low0, high0))
3604 && (0 != (rhs = build_range_check (TREE_TYPE (exp), common,
3605 or_op ? ! in1_p : in1_p,
3606 low1, high1))))
3607 return build (TREE_CODE (exp) == TRUTH_ANDIF_EXPR
3608 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
3609 TREE_TYPE (exp), lhs, rhs);
3610 }
3611 }
3612
|
3333
| |
3334 return 0;
3335}
3336
3337/* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3338 bit value. Arrange things so the extra bits will be set to zero if and
3339 only if C is signed-extended to its full width. If MASK is nonzero,
3340 it is an INTEGER_CST that should be AND'ed with the extra bits. */
3341
3342static tree
3343unextend (c, p, unsignedp, mask)
3344 tree c;
3345 int p;
3346 int unsignedp;
3347 tree mask;
3348{
3349 tree type = TREE_TYPE (c);
3350 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3351 tree temp;
3352
3353 if (p == modesize || unsignedp)
3354 return c;
3355
3356 /* We work by getting just the sign bit into the low-order bit, then
3357 into the high-order bit, then sign-extend. We then XOR that value
3358 with C. */
3359 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3360 temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3361
3362 /* We must use a signed type in order to get an arithmetic right shift.
3363 However, we must also avoid introducing accidental overflows, so that
3364 a subsequent call to integer_zerop will work. Hence we must
3365 do the type conversion here. At this point, the constant is either
3366 zero or one, and the conversion to a signed type can never overflow.
3367 We could get an overflow if this conversion is done anywhere else. */
3368 if (TREE_UNSIGNED (type))
3369 temp = convert (signed_type (type), temp);
3370
3371 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3372 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3373 if (mask != 0)
3374 temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3375 /* If necessary, convert the type back to match the type of C. */
3376 if (TREE_UNSIGNED (type))
3377 temp = convert (type, temp);
3378
3379 return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3380}
3381
3382/* Find ways of folding logical expressions of LHS and RHS:
3383 Try to merge two comparisons to the same innermost item.
3384 Look for range tests like "ch >= '0' && ch <= '9'".
3385 Look for combinations of simple terms on machines with expensive branches
3386 and evaluate the RHS unconditionally.
3387
3388 For example, if we have p->a == 2 && p->b == 4 and we can make an
3389 object large enough to span both A and B, we can do this with a comparison
3390 against the object ANDed with the a mask.
3391
3392 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3393 operations to do this with one comparison.
3394
3395 We check for both normal comparisons and the BIT_AND_EXPRs made this by
3396 function and the one above.
3397
3398 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
3399 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3400
3401 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3402 two operands.
3403
3404 We return the simplified tree or 0 if no optimization is possible. */
3405
3406static tree
3407fold_truthop (code, truth_type, lhs, rhs)
3408 enum tree_code code;
3409 tree truth_type, lhs, rhs;
3410{
3411 /* If this is the "or" of two comparisons, we can do something if we
3412 the comparisons are NE_EXPR. If this is the "and", we can do something
3413 if the comparisons are EQ_EXPR. I.e.,
3414 (a->b == 2 && a->c == 4) can become (a->new == NEW).
3415
3416 WANTED_CODE is this operation code. For single bit fields, we can
3417 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3418 comparison for one-bit fields. */
3419
3420 enum tree_code wanted_code;
3421 enum tree_code lcode, rcode;
3422 tree ll_arg, lr_arg, rl_arg, rr_arg;
3423 tree ll_inner, lr_inner, rl_inner, rr_inner;
3424 int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3425 int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3426 int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3427 int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3428 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3429 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3430 enum machine_mode lnmode, rnmode;
3431 tree ll_mask, lr_mask, rl_mask, rr_mask;
3432 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3433 tree l_const, r_const;
| 3613 return 0;
3614}
3615
3616/* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
3617 bit value. Arrange things so the extra bits will be set to zero if and
3618 only if C is signed-extended to its full width. If MASK is nonzero,
3619 it is an INTEGER_CST that should be AND'ed with the extra bits. */
3620
3621static tree
3622unextend (c, p, unsignedp, mask)
3623 tree c;
3624 int p;
3625 int unsignedp;
3626 tree mask;
3627{
3628 tree type = TREE_TYPE (c);
3629 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
3630 tree temp;
3631
3632 if (p == modesize || unsignedp)
3633 return c;
3634
3635 /* We work by getting just the sign bit into the low-order bit, then
3636 into the high-order bit, then sign-extend. We then XOR that value
3637 with C. */
3638 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
3639 temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
3640
3641 /* We must use a signed type in order to get an arithmetic right shift.
3642 However, we must also avoid introducing accidental overflows, so that
3643 a subsequent call to integer_zerop will work. Hence we must
3644 do the type conversion here. At this point, the constant is either
3645 zero or one, and the conversion to a signed type can never overflow.
3646 We could get an overflow if this conversion is done anywhere else. */
3647 if (TREE_UNSIGNED (type))
3648 temp = convert (signed_type (type), temp);
3649
3650 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
3651 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
3652 if (mask != 0)
3653 temp = const_binop (BIT_AND_EXPR, temp, convert (TREE_TYPE (c), mask), 0);
3654 /* If necessary, convert the type back to match the type of C. */
3655 if (TREE_UNSIGNED (type))
3656 temp = convert (type, temp);
3657
3658 return convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
3659}
3660
3661/* Find ways of folding logical expressions of LHS and RHS:
3662 Try to merge two comparisons to the same innermost item.
3663 Look for range tests like "ch >= '0' && ch <= '9'".
3664 Look for combinations of simple terms on machines with expensive branches
3665 and evaluate the RHS unconditionally.
3666
3667 For example, if we have p->a == 2 && p->b == 4 and we can make an
3668 object large enough to span both A and B, we can do this with a comparison
3669 against the object ANDed with the a mask.
3670
3671 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
3672 operations to do this with one comparison.
3673
3674 We check for both normal comparisons and the BIT_AND_EXPRs made this by
3675 function and the one above.
3676
3677 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
3678 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
3679
3680 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
3681 two operands.
3682
3683 We return the simplified tree or 0 if no optimization is possible. */
3684
3685static tree
3686fold_truthop (code, truth_type, lhs, rhs)
3687 enum tree_code code;
3688 tree truth_type, lhs, rhs;
3689{
3690 /* If this is the "or" of two comparisons, we can do something if we
3691 the comparisons are NE_EXPR. If this is the "and", we can do something
3692 if the comparisons are EQ_EXPR. I.e.,
3693 (a->b == 2 && a->c == 4) can become (a->new == NEW).
3694
3695 WANTED_CODE is this operation code. For single bit fields, we can
3696 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
3697 comparison for one-bit fields. */
3698
3699 enum tree_code wanted_code;
3700 enum tree_code lcode, rcode;
3701 tree ll_arg, lr_arg, rl_arg, rr_arg;
3702 tree ll_inner, lr_inner, rl_inner, rr_inner;
3703 int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
3704 int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
3705 int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
3706 int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
3707 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
3708 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
3709 enum machine_mode lnmode, rnmode;
3710 tree ll_mask, lr_mask, rl_mask, rr_mask;
3711 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
3712 tree l_const, r_const;
|
3434 tree type, result;
| 3713 tree lntype, rntype, result;
|
3435 int first_bit, end_bit;
3436 int volatilep;
3437
3438 /* Start by getting the comparison codes. Fail if anything is volatile.
3439 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3440 it were surrounded with a NE_EXPR. */
3441
3442 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3443 return 0;
3444
3445 lcode = TREE_CODE (lhs);
3446 rcode = TREE_CODE (rhs);
3447
3448 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3449 lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3450
3451 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3452 rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3453
3454 if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3455 return 0;
3456
3457 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3458 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3459
3460 ll_arg = TREE_OPERAND (lhs, 0);
3461 lr_arg = TREE_OPERAND (lhs, 1);
3462 rl_arg = TREE_OPERAND (rhs, 0);
3463 rr_arg = TREE_OPERAND (rhs, 1);
3464
3465 /* If the RHS can be evaluated unconditionally and its operands are
3466 simple, it wins to evaluate the RHS unconditionally on machines
3467 with expensive branches. In this case, this isn't a comparison
3468 that can be merged. */
3469
3470 /* @@ I'm not sure it wins on the m88110 to do this if the comparisons
3471 are with zero (tmw). */
3472
3473 if (BRANCH_COST >= 2
3474 && INTEGRAL_TYPE_P (TREE_TYPE (rhs))
3475 && simple_operand_p (rl_arg)
3476 && simple_operand_p (rr_arg))
3477 return build (code, truth_type, lhs, rhs);
3478
3479 /* See if the comparisons can be merged. Then get all the parameters for
3480 each side. */
3481
3482 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3483 || (rcode != EQ_EXPR && rcode != NE_EXPR))
3484 return 0;
3485
3486 volatilep = 0;
3487 ll_inner = decode_field_reference (ll_arg,
3488 &ll_bitsize, &ll_bitpos, &ll_mode,
3489 &ll_unsignedp, &volatilep, &ll_mask,
3490 &ll_and_mask);
3491 lr_inner = decode_field_reference (lr_arg,
3492 &lr_bitsize, &lr_bitpos, &lr_mode,
3493 &lr_unsignedp, &volatilep, &lr_mask,
3494 &lr_and_mask);
3495 rl_inner = decode_field_reference (rl_arg,
3496 &rl_bitsize, &rl_bitpos, &rl_mode,
3497 &rl_unsignedp, &volatilep, &rl_mask,
3498 &rl_and_mask);
3499 rr_inner = decode_field_reference (rr_arg,
3500 &rr_bitsize, &rr_bitpos, &rr_mode,
3501 &rr_unsignedp, &volatilep, &rr_mask,
3502 &rr_and_mask);
3503
3504 /* It must be true that the inner operation on the lhs of each
3505 comparison must be the same if we are to be able to do anything.
3506 Then see if we have constants. If not, the same must be true for
3507 the rhs's. */
3508 if (volatilep || ll_inner == 0 || rl_inner == 0
3509 || ! operand_equal_p (ll_inner, rl_inner, 0))
3510 return 0;
3511
3512 if (TREE_CODE (lr_arg) == INTEGER_CST
3513 && TREE_CODE (rr_arg) == INTEGER_CST)
3514 l_const = lr_arg, r_const = rr_arg;
3515 else if (lr_inner == 0 || rr_inner == 0
3516 || ! operand_equal_p (lr_inner, rr_inner, 0))
3517 return 0;
3518 else
3519 l_const = r_const = 0;
3520
3521 /* If either comparison code is not correct for our logical operation,
3522 fail. However, we can convert a one-bit comparison against zero into
3523 the opposite comparison against that bit being set in the field. */
3524
3525 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3526 if (lcode != wanted_code)
3527 {
3528 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3529 {
| 3714 int first_bit, end_bit;
3715 int volatilep;
3716
3717 /* Start by getting the comparison codes. Fail if anything is volatile.
3718 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
3719 it were surrounded with a NE_EXPR. */
3720
3721 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
3722 return 0;
3723
3724 lcode = TREE_CODE (lhs);
3725 rcode = TREE_CODE (rhs);
3726
3727 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
3728 lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
3729
3730 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
3731 rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
3732
3733 if (TREE_CODE_CLASS (lcode) != '<' || TREE_CODE_CLASS (rcode) != '<')
3734 return 0;
3735
3736 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
3737 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
3738
3739 ll_arg = TREE_OPERAND (lhs, 0);
3740 lr_arg = TREE_OPERAND (lhs, 1);
3741 rl_arg = TREE_OPERAND (rhs, 0);
3742 rr_arg = TREE_OPERAND (rhs, 1);
3743
3744 /* If the RHS can be evaluated unconditionally and its operands are
3745 simple, it wins to evaluate the RHS unconditionally on machines
3746 with expensive branches. In this case, this isn't a comparison
3747 that can be merged. */
3748
3749 /* @@ I'm not sure it wins on the m88110 to do this if the comparisons
3750 are with zero (tmw). */
3751
3752 if (BRANCH_COST >= 2
3753 && INTEGRAL_TYPE_P (TREE_TYPE (rhs))
3754 && simple_operand_p (rl_arg)
3755 && simple_operand_p (rr_arg))
3756 return build (code, truth_type, lhs, rhs);
3757
3758 /* See if the comparisons can be merged. Then get all the parameters for
3759 each side. */
3760
3761 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
3762 || (rcode != EQ_EXPR && rcode != NE_EXPR))
3763 return 0;
3764
3765 volatilep = 0;
3766 ll_inner = decode_field_reference (ll_arg,
3767 &ll_bitsize, &ll_bitpos, &ll_mode,
3768 &ll_unsignedp, &volatilep, &ll_mask,
3769 &ll_and_mask);
3770 lr_inner = decode_field_reference (lr_arg,
3771 &lr_bitsize, &lr_bitpos, &lr_mode,
3772 &lr_unsignedp, &volatilep, &lr_mask,
3773 &lr_and_mask);
3774 rl_inner = decode_field_reference (rl_arg,
3775 &rl_bitsize, &rl_bitpos, &rl_mode,
3776 &rl_unsignedp, &volatilep, &rl_mask,
3777 &rl_and_mask);
3778 rr_inner = decode_field_reference (rr_arg,
3779 &rr_bitsize, &rr_bitpos, &rr_mode,
3780 &rr_unsignedp, &volatilep, &rr_mask,
3781 &rr_and_mask);
3782
3783 /* It must be true that the inner operation on the lhs of each
3784 comparison must be the same if we are to be able to do anything.
3785 Then see if we have constants. If not, the same must be true for
3786 the rhs's. */
3787 if (volatilep || ll_inner == 0 || rl_inner == 0
3788 || ! operand_equal_p (ll_inner, rl_inner, 0))
3789 return 0;
3790
3791 if (TREE_CODE (lr_arg) == INTEGER_CST
3792 && TREE_CODE (rr_arg) == INTEGER_CST)
3793 l_const = lr_arg, r_const = rr_arg;
3794 else if (lr_inner == 0 || rr_inner == 0
3795 || ! operand_equal_p (lr_inner, rr_inner, 0))
3796 return 0;
3797 else
3798 l_const = r_const = 0;
3799
3800 /* If either comparison code is not correct for our logical operation,
3801 fail. However, we can convert a one-bit comparison against zero into
3802 the opposite comparison against that bit being set in the field. */
3803
3804 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
3805 if (lcode != wanted_code)
3806 {
3807 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
3808 {
|
3530 if (ll_unsignedp || tree_log2 (ll_mask) + 1 < ll_bitsize)
3531 l_const = ll_mask;
3532 else
3533 /* Since ll_arg is a single bit bit mask, we can sign extend
3534 it appropriately with a NEGATE_EXPR.
3535 l_const is made a signed value here, but since for l_const != NULL
3536 lr_unsignedp is not used, we don't need to clear the latter. */
3537 l_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (ll_arg),
3538 convert (TREE_TYPE (ll_arg), ll_mask)));
| 3809 /* Make the left operand unsigned, since we are only interested
3810 in the value of one bit. Otherwise we are doing the wrong
3811 thing below. */
3812 ll_unsignedp = 1;
3813 l_const = ll_mask;
|
3539 }
3540 else
3541 return 0;
3542 }
3543
| 3814 }
3815 else
3816 return 0;
3817 }
3818
|
| 3819 /* This is analogous to the code for l_const above. */
|
3544 if (rcode != wanted_code)
3545 {
3546 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3547 {
| 3820 if (rcode != wanted_code)
3821 {
3822 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3823 {
|
3548 if (rl_unsignedp || tree_log2 (rl_mask) + 1 < rl_bitsize)
3549 r_const = rl_mask;
3550 else
3551 /* This is analogous to the code for l_const above. */
3552 r_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (rl_arg),
3553 convert (TREE_TYPE (rl_arg), rl_mask)));
| 3824 rl_unsignedp = 1;
3825 r_const = rl_mask;
|
3554 }
3555 else
3556 return 0;
3557 }
3558
3559 /* See if we can find a mode that contains both fields being compared on
3560 the left. If we can't, fail. Otherwise, update all constants and masks
3561 to be relative to a field of that size. */
3562 first_bit = MIN (ll_bitpos, rl_bitpos);
3563 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3564 lnmode = get_best_mode (end_bit - first_bit, first_bit,
3565 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3566 volatilep);
3567 if (lnmode == VOIDmode)
3568 return 0;
3569
3570 lnbitsize = GET_MODE_BITSIZE (lnmode);
3571 lnbitpos = first_bit & ~ (lnbitsize - 1);
| 3826 }
3827 else
3828 return 0;
3829 }
3830
3831 /* See if we can find a mode that contains both fields being compared on
3832 the left. If we can't, fail. Otherwise, update all constants and masks
3833 to be relative to a field of that size. */
3834 first_bit = MIN (ll_bitpos, rl_bitpos);
3835 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
3836 lnmode = get_best_mode (end_bit - first_bit, first_bit,
3837 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
3838 volatilep);
3839 if (lnmode == VOIDmode)
3840 return 0;
3841
3842 lnbitsize = GET_MODE_BITSIZE (lnmode);
3843 lnbitpos = first_bit & ~ (lnbitsize - 1);
|
3572 type = type_for_size (lnbitsize, 1);
| 3844 lntype = type_for_size (lnbitsize, 1);
|
3573 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3574
3575 if (BYTES_BIG_ENDIAN)
3576 {
3577 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3578 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3579 }
3580
| 3845 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
3846
3847 if (BYTES_BIG_ENDIAN)
3848 {
3849 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
3850 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
3851 }
3852
|
3581 ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
| 3853 ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
|
3582 size_int (xll_bitpos), 0);
| 3854 size_int (xll_bitpos), 0);
|
3583 rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
| 3855 rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
|
3584 size_int (xrl_bitpos), 0);
3585
3586 if (l_const)
3587 {
| 3856 size_int (xrl_bitpos), 0);
3857
3858 if (l_const)
3859 {
|
3588 l_const = convert (type, l_const);
| 3860 l_const = convert (lntype, l_const);
|
3589 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
3590 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3591 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3592 fold (build1 (BIT_NOT_EXPR,
| 3861 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
3862 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
3863 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
3864 fold (build1 (BIT_NOT_EXPR,
|
3593 type, ll_mask)),
| 3865 lntype, ll_mask)),
|
3594 0)))
3595 {
| 3866 0)))
3867 {
|
3596 warning ("comparison is always %s",
3597 wanted_code == NE_EXPR ? "one" : "zero");
| 3868 warning ("comparison is always %d", wanted_code == NE_EXPR);
|
3598
3599 return convert (truth_type,
3600 wanted_code == NE_EXPR
3601 ? integer_one_node : integer_zero_node);
3602 }
3603 }
3604 if (r_const)
3605 {
| 3869
3870 return convert (truth_type,
3871 wanted_code == NE_EXPR
3872 ? integer_one_node : integer_zero_node);
3873 }
3874 }
3875 if (r_const)
3876 {
|
3606 r_const = convert (type, r_const);
| 3877 r_const = convert (lntype, r_const);
|
3607 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3608 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3609 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3610 fold (build1 (BIT_NOT_EXPR,
| 3878 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
3879 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
3880 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
3881 fold (build1 (BIT_NOT_EXPR,
|
3611 type, rl_mask)),
| 3882 lntype, rl_mask)),
|
3612 0)))
3613 {
| 3883 0)))
3884 {
|
3614 warning ("comparison is always %s",
3615 wanted_code == NE_EXPR ? "one" : "zero");
3616
| 3885 warning ("comparison is always %d", wanted_code == NE_EXPR);
3886
|
3617 return convert (truth_type,
3618 wanted_code == NE_EXPR
3619 ? integer_one_node : integer_zero_node);
3620 }
3621 }
3622
3623 /* If the right sides are not constant, do the same for it. Also,
3624 disallow this optimization if a size or signedness mismatch occurs
3625 between the left and right sides. */
3626 if (l_const == 0)
3627 {
3628 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
3629 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
3630 /* Make sure the two fields on the right
3631 correspond to the left without being swapped. */
3632 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
3633 return 0;
3634
3635 first_bit = MIN (lr_bitpos, rr_bitpos);
3636 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
3637 rnmode = get_best_mode (end_bit - first_bit, first_bit,
3638 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
3639 volatilep);
3640 if (rnmode == VOIDmode)
3641 return 0;
3642
3643 rnbitsize = GET_MODE_BITSIZE (rnmode);
3644 rnbitpos = first_bit & ~ (rnbitsize - 1);
| 3887 return convert (truth_type,
3888 wanted_code == NE_EXPR
3889 ? integer_one_node : integer_zero_node);
3890 }
3891 }
3892
3893 /* If the right sides are not constant, do the same for it. Also,
3894 disallow this optimization if a size or signedness mismatch occurs
3895 between the left and right sides. */
3896 if (l_const == 0)
3897 {
3898 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
3899 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
3900 /* Make sure the two fields on the right
3901 correspond to the left without being swapped. */
3902 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
3903 return 0;
3904
3905 first_bit = MIN (lr_bitpos, rr_bitpos);
3906 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
3907 rnmode = get_best_mode (end_bit - first_bit, first_bit,
3908 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
3909 volatilep);
3910 if (rnmode == VOIDmode)
3911 return 0;
3912
3913 rnbitsize = GET_MODE_BITSIZE (rnmode);
3914 rnbitpos = first_bit & ~ (rnbitsize - 1);
|
| 3915 rntype = type_for_size (rnbitsize, 1);
|
3645 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
3646
3647 if (BYTES_BIG_ENDIAN)
3648 {
3649 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
3650 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
3651 }
3652
| 3916 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
3917
3918 if (BYTES_BIG_ENDIAN)
3919 {
3920 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
3921 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
3922 }
3923
|
3653 lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
| 3924 lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
|
3654 size_int (xlr_bitpos), 0);
| 3925 size_int (xlr_bitpos), 0);
|
3655 rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
| 3926 rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
|
3656 size_int (xrr_bitpos), 0);
3657
3658 /* Make a mask that corresponds to both fields being compared.
| 3927 size_int (xrr_bitpos), 0);
3928
3929 /* Make a mask that corresponds to both fields being compared.
|
3659 Do this for both items being compared. If the masks agree,
3660 we can do this by masking both and comparing the masked
| 3930 Do this for both items being compared. If the operands are the
3931 same size and the bits being compared are in the same position
3932 then we can do this by masking both and comparing the masked
|
3661 results. */
3662 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3663 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
| 3933 results. */
3934 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3935 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
|
3664 if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
| 3936 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
|
3665 {
| 3937 {
|
3666 lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
| 3938 lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
|
3667 ll_unsignedp || rl_unsignedp);
| 3939 ll_unsignedp || rl_unsignedp);
|
3668 rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
3669 lr_unsignedp || rr_unsignedp);
| |
3670 if (! all_ones_mask_p (ll_mask, lnbitsize))
| 3940 if (! all_ones_mask_p (ll_mask, lnbitsize))
|
3671 {
3672 lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3673 rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
3674 }
| 3941 lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
3942
3943 rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
3944 lr_unsignedp || rr_unsignedp);
3945 if (! all_ones_mask_p (lr_mask, rnbitsize))
3946 rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
3947
|
3675 return build (wanted_code, truth_type, lhs, rhs);
3676 }
3677
3678 /* There is still another way we can do something: If both pairs of
3679 fields being compared are adjacent, we may be able to make a wider
| 3948 return build (wanted_code, truth_type, lhs, rhs);
3949 }
3950
3951 /* There is still another way we can do something: If both pairs of
3952 fields being compared are adjacent, we may be able to make a wider
|
3680 field containing them both. */
| 3953 field containing them both.
3954
3955 Note that we still must mask the lhs/rhs expressions. Furthermore,
3956 the mask must be shifted to account for the shift done by
3957 make_bit_field_ref. */
|
3681 if ((ll_bitsize + ll_bitpos == rl_bitpos
3682 && lr_bitsize + lr_bitpos == rr_bitpos)
3683 || (ll_bitpos == rl_bitpos + rl_bitsize
3684 && lr_bitpos == rr_bitpos + rr_bitsize))
| 3958 if ((ll_bitsize + ll_bitpos == rl_bitpos
3959 && lr_bitsize + lr_bitpos == rr_bitpos)
3960 || (ll_bitpos == rl_bitpos + rl_bitsize
3961 && lr_bitpos == rr_bitpos + rr_bitsize))
|
3685 return build (wanted_code, truth_type,
3686 make_bit_field_ref (ll_inner, type,
3687 ll_bitsize + rl_bitsize,
3688 MIN (ll_bitpos, rl_bitpos),
3689 ll_unsignedp),
3690 make_bit_field_ref (lr_inner, type,
3691 lr_bitsize + rr_bitsize,
3692 MIN (lr_bitpos, rr_bitpos),
3693 lr_unsignedp));
| 3962 {
3963 tree type;
|
3694
| 3964
|
| 3965 lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
3966 MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
3967 rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
3968 MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
3969
3970 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
3971 size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
3972 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
3973 size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
3974
3975 /* Convert to the smaller type before masking out unwanted bits. */
3976 type = lntype;
3977 if (lntype != rntype)
3978 {
3979 if (lnbitsize > rnbitsize)
3980 {
3981 lhs = convert (rntype, lhs);
3982 ll_mask = convert (rntype, ll_mask);
3983 type = rntype;
3984 }
3985 else if (lnbitsize < rnbitsize)
3986 {
3987 rhs = convert (lntype, rhs);
3988 lr_mask = convert (lntype, lr_mask);
3989 type = lntype;
3990 }
3991 }
3992
3993 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
3994 lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3995
3996 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
3997 rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
3998
3999 return build (wanted_code, truth_type, lhs, rhs);
4000 }
4001
|
3695 return 0;
3696 }
3697
3698 /* Handle the case of comparisons with constants. If there is something in
3699 common between the masks, those bits of the constants must be the same.
3700 If not, the condition is always false. Test for this to avoid generating
3701 incorrect code below. */
3702 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
3703 if (! integer_zerop (result)
3704 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
3705 const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
3706 {
3707 if (wanted_code == NE_EXPR)
3708 {
3709 warning ("`or' of unmatched not-equal tests is always 1");
3710 return convert (truth_type, integer_one_node);
3711 }
3712 else
3713 {
| 4002 return 0;
4003 }
4004
4005 /* Handle the case of comparisons with constants. If there is something in
4006 common between the masks, those bits of the constants must be the same.
4007 If not, the condition is always false. Test for this to avoid generating
4008 incorrect code below. */
4009 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
4010 if (! integer_zerop (result)
4011 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
4012 const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
4013 {
4014 if (wanted_code == NE_EXPR)
4015 {
4016 warning ("`or' of unmatched not-equal tests is always 1");
4017 return convert (truth_type, integer_one_node);
4018 }
4019 else
4020 {
|
3714 warning ("`and' of mutually exclusive equal-tests is always zero");
| 4021 warning ("`and' of mutually exclusive equal-tests is always 0");
|
3715 return convert (truth_type, integer_zero_node);
3716 }
3717 }
3718
3719 /* Construct the expression we will return. First get the component
3720 reference we will make. Unless the mask is all ones the width of
3721 that field, perform the mask operation. Then compare with the
3722 merged constant. */
| 4022 return convert (truth_type, integer_zero_node);
4023 }
4024 }
4025
4026 /* Construct the expression we will return. First get the component
4027 reference we will make. Unless the mask is all ones the width of
4028 that field, perform the mask operation. Then compare with the
4029 merged constant. */
|
3723 result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
| 4030 result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
|
3724 ll_unsignedp || rl_unsignedp);
3725
3726 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3727 if (! all_ones_mask_p (ll_mask, lnbitsize))
| 4031 ll_unsignedp || rl_unsignedp);
4032
4033 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
4034 if (! all_ones_mask_p (ll_mask, lnbitsize))
|
3728 result = build (BIT_AND_EXPR, type, result, ll_mask);
| 4035 result = build (BIT_AND_EXPR, lntype, result, ll_mask);
|
3729
3730 return build (wanted_code, truth_type, result,
3731 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
3732}
3733
3734/* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
3735 S, a SAVE_EXPR, return the expression actually being evaluated. Note
3736 that we may sometimes modify the tree. */
3737
3738static tree
3739strip_compound_expr (t, s)
3740 tree t;
3741 tree s;
3742{
3743 enum tree_code code = TREE_CODE (t);
3744
3745 /* See if this is the COMPOUND_EXPR we want to eliminate. */
3746 if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
3747 && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
3748 return TREE_OPERAND (t, 1);
3749
3750 /* See if this is a COND_EXPR or a simple arithmetic operator. We
3751 don't bother handling any other types. */
3752 else if (code == COND_EXPR)
3753 {
3754 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3755 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
3756 TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
3757 }
3758 else if (TREE_CODE_CLASS (code) == '1')
3759 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3760 else if (TREE_CODE_CLASS (code) == '<'
3761 || TREE_CODE_CLASS (code) == '2')
3762 {
3763 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
3764 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
3765 }
3766
3767 return t;
3768}
3769
3770/* Return a node which has the indicated constant VALUE (either 0 or
3771 1), and is of the indicated TYPE. */
3772
3773static tree
3774constant_boolean_node (value, type)
3775 int value;
3776 tree type;
3777{
3778 if (type == integer_type_node)
3779 return value ? integer_one_node : integer_zero_node;
3780 else if (TREE_CODE (type) == BOOLEAN_TYPE)
3781 return truthvalue_conversion (value ? integer_one_node :
3782 integer_zero_node);
3783 else
3784 {
3785 tree t = build_int_2 (value, 0);
3786 TREE_TYPE (t) = type;
3787 return t;
3788 }
3789}
3790
| 4036
4037 return build (wanted_code, truth_type, result,
4038 const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
4039}
4040
4041/* If T contains a COMPOUND_EXPR which was inserted merely to evaluate
4042 S, a SAVE_EXPR, return the expression actually being evaluated. Note
4043 that we may sometimes modify the tree. */
4044
4045static tree
4046strip_compound_expr (t, s)
4047 tree t;
4048 tree s;
4049{
4050 enum tree_code code = TREE_CODE (t);
4051
4052 /* See if this is the COMPOUND_EXPR we want to eliminate. */
4053 if (code == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR
4054 && TREE_OPERAND (TREE_OPERAND (t, 0), 0) == s)
4055 return TREE_OPERAND (t, 1);
4056
4057 /* See if this is a COND_EXPR or a simple arithmetic operator. We
4058 don't bother handling any other types. */
4059 else if (code == COND_EXPR)
4060 {
4061 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4062 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4063 TREE_OPERAND (t, 2) = strip_compound_expr (TREE_OPERAND (t, 2), s);
4064 }
4065 else if (TREE_CODE_CLASS (code) == '1')
4066 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4067 else if (TREE_CODE_CLASS (code) == '<'
4068 || TREE_CODE_CLASS (code) == '2')
4069 {
4070 TREE_OPERAND (t, 0) = strip_compound_expr (TREE_OPERAND (t, 0), s);
4071 TREE_OPERAND (t, 1) = strip_compound_expr (TREE_OPERAND (t, 1), s);
4072 }
4073
4074 return t;
4075}
4076
4077/* Return a node which has the indicated constant VALUE (either 0 or
4078 1), and is of the indicated TYPE. */
4079
4080static tree
4081constant_boolean_node (value, type)
4082 int value;
4083 tree type;
4084{
4085 if (type == integer_type_node)
4086 return value ? integer_one_node : integer_zero_node;
4087 else if (TREE_CODE (type) == BOOLEAN_TYPE)
4088 return truthvalue_conversion (value ? integer_one_node :
4089 integer_zero_node);
4090 else
4091 {
4092 tree t = build_int_2 (value, 0);
4093 TREE_TYPE (t) = type;
4094 return t;
4095 }
4096}
4097
|
| 4098/* Utility function for the following routine, to see how complex a nesting of
4099 COND_EXPRs can be. EXPR is the expression and LIMIT is a count beyond which
4100 we don't care (to avoid spending too much time on complex expressions.). */
4101
4102static int
4103count_cond (expr, lim)
4104 tree expr;
4105 int lim;
4106{
4107 int true, false;
4108
4109 if (TREE_CODE (expr) != COND_EXPR)
4110 return 0;
4111 else if (lim <= 0)
4112 return 0;
4113
4114 true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
4115 false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
4116 return MIN (lim, 1 + true + false);
4117}
4118
|
3791/* Perform constant folding and related simplification of EXPR.
3792 The related simplifications include x*1 => x, x*0 => 0, etc.,
3793 and application of the associative law.
3794 NOP_EXPR conversions may be removed freely (as long as we
3795 are careful not to change the C type of the overall expression)
3796 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
3797 but we can constant-fold them if they have constant operands. */
3798
3799tree
3800fold (expr)
3801 tree expr;
3802{
3803 register tree t = expr;
3804 tree t1 = NULL_TREE;
3805 tree tem;
3806 tree type = TREE_TYPE (expr);
3807 register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
3808 register enum tree_code code = TREE_CODE (t);
3809 register int kind;
3810 int invert;
3811
3812 /* WINS will be nonzero when the switch is done
3813 if all operands are constant. */
3814
3815 int wins = 1;
3816
3817 /* Don't try to process an RTL_EXPR since its operands aren't trees.
3818 Likewise for a SAVE_EXPR that's already been evaluated. */
3819 if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
3820 return t;
3821
3822 /* Return right away if already constant. */
3823 if (TREE_CONSTANT (t))
3824 {
3825 if (code == CONST_DECL)
3826 return DECL_INITIAL (t);
3827 return t;
3828 }
3829
3830#ifdef MAX_INTEGER_COMPUTATION_MODE
3831 check_max_integer_computation_mode (expr);
3832#endif
3833
3834 kind = TREE_CODE_CLASS (code);
3835 if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
3836 {
3837 tree subop;
3838
3839 /* Special case for conversion ops that can have fixed point args. */
3840 arg0 = TREE_OPERAND (t, 0);
3841
3842 /* Don't use STRIP_NOPS, because signedness of argument type matters. */
3843 if (arg0 != 0)
3844 STRIP_TYPE_NOPS (arg0);
3845
3846 if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
3847 subop = TREE_REALPART (arg0);
3848 else
3849 subop = arg0;
3850
3851 if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
3852#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3853 && TREE_CODE (subop) != REAL_CST
3854#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3855 )
3856 /* Note that TREE_CONSTANT isn't enough:
3857 static var addresses are constant but we can't
3858 do arithmetic on them. */
3859 wins = 0;
3860 }
3861 else if (kind == 'e' || kind == '<'
3862 || kind == '1' || kind == '2' || kind == 'r')
3863 {
3864 register int len = tree_code_length[(int) code];
3865 register int i;
3866 for (i = 0; i < len; i++)
3867 {
3868 tree op = TREE_OPERAND (t, i);
3869 tree subop;
3870
3871 if (op == 0)
3872 continue; /* Valid for CALL_EXPR, at least. */
3873
3874 if (kind == '<' || code == RSHIFT_EXPR)
3875 {
3876 /* Signedness matters here. Perhaps we can refine this
3877 later. */
3878 STRIP_TYPE_NOPS (op);
3879 }
3880 else
3881 {
3882 /* Strip any conversions that don't change the mode. */
3883 STRIP_NOPS (op);
3884 }
3885
3886 if (TREE_CODE (op) == COMPLEX_CST)
3887 subop = TREE_REALPART (op);
3888 else
3889 subop = op;
3890
3891 if (TREE_CODE (subop) != INTEGER_CST
3892#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3893 && TREE_CODE (subop) != REAL_CST
3894#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3895 )
3896 /* Note that TREE_CONSTANT isn't enough:
3897 static var addresses are constant but we can't
3898 do arithmetic on them. */
3899 wins = 0;
3900
3901 if (i == 0)
3902 arg0 = op;
3903 else if (i == 1)
3904 arg1 = op;
3905 }
3906 }
3907
3908 /* If this is a commutative operation, and ARG0 is a constant, move it
3909 to ARG1 to reduce the number of tests below. */
3910 if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
3911 || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
3912 || code == BIT_AND_EXPR)
3913 && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
3914 {
3915 tem = arg0; arg0 = arg1; arg1 = tem;
3916
3917 tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
3918 TREE_OPERAND (t, 1) = tem;
3919 }
3920
3921 /* Now WINS is set as described above,
3922 ARG0 is the first operand of EXPR,
3923 and ARG1 is the second operand (if it has more than one operand).
3924
3925 First check for cases where an arithmetic operation is applied to a
3926 compound, conditional, or comparison operation. Push the arithmetic
3927 operation inside the compound or conditional to see if any folding
3928 can then be done. Convert comparison to conditional for this purpose.
3929 The also optimizes non-constant cases that used to be done in
3930 expand_expr.
3931
3932 Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
3933 one of the operands is a comparison and the other is a comparison, a
3934 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
3935 code below would make the expression more complex. Change it to a
3936 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
3937 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
3938
3939 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
3940 || code == EQ_EXPR || code == NE_EXPR)
3941 && ((truth_value_p (TREE_CODE (arg0))
3942 && (truth_value_p (TREE_CODE (arg1))
3943 || (TREE_CODE (arg1) == BIT_AND_EXPR
3944 && integer_onep (TREE_OPERAND (arg1, 1)))))
3945 || (truth_value_p (TREE_CODE (arg1))
3946 && (truth_value_p (TREE_CODE (arg0))
3947 || (TREE_CODE (arg0) == BIT_AND_EXPR
3948 && integer_onep (TREE_OPERAND (arg0, 1)))))))
3949 {
3950 t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
3951 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
3952 : TRUTH_XOR_EXPR,
3953 type, arg0, arg1));
3954
3955 if (code == EQ_EXPR)
3956 t = invert_truthvalue (t);
3957
3958 return t;
3959 }
3960
3961 if (TREE_CODE_CLASS (code) == '1')
3962 {
3963 if (TREE_CODE (arg0) == COMPOUND_EXPR)
3964 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
3965 fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
3966 else if (TREE_CODE (arg0) == COND_EXPR)
3967 {
3968 t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
3969 fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
3970 fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
3971
3972 /* If this was a conversion, and all we did was to move into
3973 inside the COND_EXPR, bring it back out. But leave it if
3974 it is a conversion from integer to integer and the
3975 result precision is no wider than a word since such a
3976 conversion is cheap and may be optimized away by combine,
3977 while it couldn't if it were outside the COND_EXPR. Then return
3978 so we don't get into an infinite recursion loop taking the
3979 conversion out and then back in. */
3980
3981 if ((code == NOP_EXPR || code == CONVERT_EXPR
3982 || code == NON_LVALUE_EXPR)
3983 && TREE_CODE (t) == COND_EXPR
3984 && TREE_CODE (TREE_OPERAND (t, 1)) == code
3985 && TREE_CODE (TREE_OPERAND (t, 2)) == code
3986 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
3987 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
3988 && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
3989 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)))
3990 && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
3991 t = build1 (code, type,
3992 build (COND_EXPR,
3993 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)),
3994 TREE_OPERAND (t, 0),
3995 TREE_OPERAND (TREE_OPERAND (t, 1), 0),
3996 TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
3997 return t;
3998 }
3999 else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4000 return fold (build (COND_EXPR, type, arg0,
4001 fold (build1 (code, type, integer_one_node)),
4002 fold (build1 (code, type, integer_zero_node))));
4003 }
4004 else if (TREE_CODE_CLASS (code) == '2'
4005 || TREE_CODE_CLASS (code) == '<')
4006 {
4007 if (TREE_CODE (arg1) == COMPOUND_EXPR)
4008 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4009 fold (build (code, type,
4010 arg0, TREE_OPERAND (arg1, 1))));
4011 else if ((TREE_CODE (arg1) == COND_EXPR
4012 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4013 && TREE_CODE_CLASS (code) != '<'))
| 4119/* Perform constant folding and related simplification of EXPR.
4120 The related simplifications include x*1 => x, x*0 => 0, etc.,
4121 and application of the associative law.
4122 NOP_EXPR conversions may be removed freely (as long as we
4123 are careful not to change the C type of the overall expression)
4124 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
4125 but we can constant-fold them if they have constant operands. */
4126
4127tree
4128fold (expr)
4129 tree expr;
4130{
4131 register tree t = expr;
4132 tree t1 = NULL_TREE;
4133 tree tem;
4134 tree type = TREE_TYPE (expr);
4135 register tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4136 register enum tree_code code = TREE_CODE (t);
4137 register int kind;
4138 int invert;
4139
4140 /* WINS will be nonzero when the switch is done
4141 if all operands are constant. */
4142
4143 int wins = 1;
4144
4145 /* Don't try to process an RTL_EXPR since its operands aren't trees.
4146 Likewise for a SAVE_EXPR that's already been evaluated. */
4147 if (code == RTL_EXPR || (code == SAVE_EXPR && SAVE_EXPR_RTL (t)) != 0)
4148 return t;
4149
4150 /* Return right away if already constant. */
4151 if (TREE_CONSTANT (t))
4152 {
4153 if (code == CONST_DECL)
4154 return DECL_INITIAL (t);
4155 return t;
4156 }
4157
4158#ifdef MAX_INTEGER_COMPUTATION_MODE
4159 check_max_integer_computation_mode (expr);
4160#endif
4161
4162 kind = TREE_CODE_CLASS (code);
4163 if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
4164 {
4165 tree subop;
4166
4167 /* Special case for conversion ops that can have fixed point args. */
4168 arg0 = TREE_OPERAND (t, 0);
4169
4170 /* Don't use STRIP_NOPS, because signedness of argument type matters. */
4171 if (arg0 != 0)
4172 STRIP_TYPE_NOPS (arg0);
4173
4174 if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
4175 subop = TREE_REALPART (arg0);
4176 else
4177 subop = arg0;
4178
4179 if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
4180#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4181 && TREE_CODE (subop) != REAL_CST
4182#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4183 )
4184 /* Note that TREE_CONSTANT isn't enough:
4185 static var addresses are constant but we can't
4186 do arithmetic on them. */
4187 wins = 0;
4188 }
4189 else if (kind == 'e' || kind == '<'
4190 || kind == '1' || kind == '2' || kind == 'r')
4191 {
4192 register int len = tree_code_length[(int) code];
4193 register int i;
4194 for (i = 0; i < len; i++)
4195 {
4196 tree op = TREE_OPERAND (t, i);
4197 tree subop;
4198
4199 if (op == 0)
4200 continue; /* Valid for CALL_EXPR, at least. */
4201
4202 if (kind == '<' || code == RSHIFT_EXPR)
4203 {
4204 /* Signedness matters here. Perhaps we can refine this
4205 later. */
4206 STRIP_TYPE_NOPS (op);
4207 }
4208 else
4209 {
4210 /* Strip any conversions that don't change the mode. */
4211 STRIP_NOPS (op);
4212 }
4213
4214 if (TREE_CODE (op) == COMPLEX_CST)
4215 subop = TREE_REALPART (op);
4216 else
4217 subop = op;
4218
4219 if (TREE_CODE (subop) != INTEGER_CST
4220#if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4221 && TREE_CODE (subop) != REAL_CST
4222#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4223 )
4224 /* Note that TREE_CONSTANT isn't enough:
4225 static var addresses are constant but we can't
4226 do arithmetic on them. */
4227 wins = 0;
4228
4229 if (i == 0)
4230 arg0 = op;
4231 else if (i == 1)
4232 arg1 = op;
4233 }
4234 }
4235
4236 /* If this is a commutative operation, and ARG0 is a constant, move it
4237 to ARG1 to reduce the number of tests below. */
4238 if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
4239 || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
4240 || code == BIT_AND_EXPR)
4241 && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
4242 {
4243 tem = arg0; arg0 = arg1; arg1 = tem;
4244
4245 tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
4246 TREE_OPERAND (t, 1) = tem;
4247 }
4248
4249 /* Now WINS is set as described above,
4250 ARG0 is the first operand of EXPR,
4251 and ARG1 is the second operand (if it has more than one operand).
4252
4253 First check for cases where an arithmetic operation is applied to a
4254 compound, conditional, or comparison operation. Push the arithmetic
4255 operation inside the compound or conditional to see if any folding
4256 can then be done. Convert comparison to conditional for this purpose.
4257 The also optimizes non-constant cases that used to be done in
4258 expand_expr.
4259
4260 Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
4261 one of the operands is a comparison and the other is a comparison, a
4262 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
4263 code below would make the expression more complex. Change it to a
4264 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
4265 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
4266
4267 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
4268 || code == EQ_EXPR || code == NE_EXPR)
4269 && ((truth_value_p (TREE_CODE (arg0))
4270 && (truth_value_p (TREE_CODE (arg1))
4271 || (TREE_CODE (arg1) == BIT_AND_EXPR
4272 && integer_onep (TREE_OPERAND (arg1, 1)))))
4273 || (truth_value_p (TREE_CODE (arg1))
4274 && (truth_value_p (TREE_CODE (arg0))
4275 || (TREE_CODE (arg0) == BIT_AND_EXPR
4276 && integer_onep (TREE_OPERAND (arg0, 1)))))))
4277 {
4278 t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
4279 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
4280 : TRUTH_XOR_EXPR,
4281 type, arg0, arg1));
4282
4283 if (code == EQ_EXPR)
4284 t = invert_truthvalue (t);
4285
4286 return t;
4287 }
4288
4289 if (TREE_CODE_CLASS (code) == '1')
4290 {
4291 if (TREE_CODE (arg0) == COMPOUND_EXPR)
4292 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4293 fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
4294 else if (TREE_CODE (arg0) == COND_EXPR)
4295 {
4296 t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
4297 fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
4298 fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
4299
4300 /* If this was a conversion, and all we did was to move into
4301 inside the COND_EXPR, bring it back out. But leave it if
4302 it is a conversion from integer to integer and the
4303 result precision is no wider than a word since such a
4304 conversion is cheap and may be optimized away by combine,
4305 while it couldn't if it were outside the COND_EXPR. Then return
4306 so we don't get into an infinite recursion loop taking the
4307 conversion out and then back in. */
4308
4309 if ((code == NOP_EXPR || code == CONVERT_EXPR
4310 || code == NON_LVALUE_EXPR)
4311 && TREE_CODE (t) == COND_EXPR
4312 && TREE_CODE (TREE_OPERAND (t, 1)) == code
4313 && TREE_CODE (TREE_OPERAND (t, 2)) == code
4314 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
4315 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0)))
4316 && ! (INTEGRAL_TYPE_P (TREE_TYPE (t))
4317 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)))
4318 && TYPE_PRECISION (TREE_TYPE (t)) <= BITS_PER_WORD))
4319 t = build1 (code, type,
4320 build (COND_EXPR,
4321 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)),
4322 TREE_OPERAND (t, 0),
4323 TREE_OPERAND (TREE_OPERAND (t, 1), 0),
4324 TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
4325 return t;
4326 }
4327 else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
4328 return fold (build (COND_EXPR, type, arg0,
4329 fold (build1 (code, type, integer_one_node)),
4330 fold (build1 (code, type, integer_zero_node))));
4331 }
4332 else if (TREE_CODE_CLASS (code) == '2'
4333 || TREE_CODE_CLASS (code) == '<')
4334 {
4335 if (TREE_CODE (arg1) == COMPOUND_EXPR)
4336 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4337 fold (build (code, type,
4338 arg0, TREE_OPERAND (arg1, 1))));
4339 else if ((TREE_CODE (arg1) == COND_EXPR
4340 || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
4341 && TREE_CODE_CLASS (code) != '<'))
|
| 4342 && (TREE_CODE (arg0) != COND_EXPR
4343 || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
|
4014 && (! TREE_SIDE_EFFECTS (arg0)
4015 || (current_function_decl != 0
4016 && ! contains_placeholder_p (arg0))))
4017 {
4018 tree test, true_value, false_value;
4019 tree lhs = 0, rhs = 0;
4020
4021 if (TREE_CODE (arg1) == COND_EXPR)
4022 {
4023 test = TREE_OPERAND (arg1, 0);
4024 true_value = TREE_OPERAND (arg1, 1);
4025 false_value = TREE_OPERAND (arg1, 2);
4026 }
4027 else
4028 {
4029 tree testtype = TREE_TYPE (arg1);
4030 test = arg1;
4031 true_value = convert (testtype, integer_one_node);
4032 false_value = convert (testtype, integer_zero_node);
4033 }
4034
4035 /* If ARG0 is complex we want to make sure we only evaluate
4036 it once. Though this is only required if it is volatile, it
4037 might be more efficient even if it is not. However, if we
4038 succeed in folding one part to a constant, we do not need
4039 to make this SAVE_EXPR. Since we do this optimization
4040 primarily to see if we do end up with constant and this
4041 SAVE_EXPR interferes with later optimizations, suppressing
4042 it when we can is important.
4043
4044 If we are not in a function, we can't make a SAVE_EXPR, so don't
4045 try to do so. Don't try to see if the result is a constant
4046 if an arm is a COND_EXPR since we get exponential behavior
4047 in that case. */
4048
4049 if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4050 && current_function_decl != 0
4051 && ((TREE_CODE (arg0) != VAR_DECL
4052 && TREE_CODE (arg0) != PARM_DECL)
4053 || TREE_SIDE_EFFECTS (arg0)))
4054 {
4055 if (TREE_CODE (true_value) != COND_EXPR)
4056 lhs = fold (build (code, type, arg0, true_value));
4057
4058 if (TREE_CODE (false_value) != COND_EXPR)
4059 rhs = fold (build (code, type, arg0, false_value));
4060
4061 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4062 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4063 arg0 = save_expr (arg0), lhs = rhs = 0;
4064 }
4065
4066 if (lhs == 0)
4067 lhs = fold (build (code, type, arg0, true_value));
4068 if (rhs == 0)
4069 rhs = fold (build (code, type, arg0, false_value));
4070
4071 test = fold (build (COND_EXPR, type, test, lhs, rhs));
4072
4073 if (TREE_CODE (arg0) == SAVE_EXPR)
4074 return build (COMPOUND_EXPR, type,
4075 convert (void_type_node, arg0),
4076 strip_compound_expr (test, arg0));
4077 else
4078 return convert (type, test);
4079 }
4080
4081 else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4082 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4083 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4084 else if ((TREE_CODE (arg0) == COND_EXPR
4085 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4086 && TREE_CODE_CLASS (code) != '<'))
| 4344 && (! TREE_SIDE_EFFECTS (arg0)
4345 || (current_function_decl != 0
4346 && ! contains_placeholder_p (arg0))))
4347 {
4348 tree test, true_value, false_value;
4349 tree lhs = 0, rhs = 0;
4350
4351 if (TREE_CODE (arg1) == COND_EXPR)
4352 {
4353 test = TREE_OPERAND (arg1, 0);
4354 true_value = TREE_OPERAND (arg1, 1);
4355 false_value = TREE_OPERAND (arg1, 2);
4356 }
4357 else
4358 {
4359 tree testtype = TREE_TYPE (arg1);
4360 test = arg1;
4361 true_value = convert (testtype, integer_one_node);
4362 false_value = convert (testtype, integer_zero_node);
4363 }
4364
4365 /* If ARG0 is complex we want to make sure we only evaluate
4366 it once. Though this is only required if it is volatile, it
4367 might be more efficient even if it is not. However, if we
4368 succeed in folding one part to a constant, we do not need
4369 to make this SAVE_EXPR. Since we do this optimization
4370 primarily to see if we do end up with constant and this
4371 SAVE_EXPR interferes with later optimizations, suppressing
4372 it when we can is important.
4373
4374 If we are not in a function, we can't make a SAVE_EXPR, so don't
4375 try to do so. Don't try to see if the result is a constant
4376 if an arm is a COND_EXPR since we get exponential behavior
4377 in that case. */
4378
4379 if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4380 && current_function_decl != 0
4381 && ((TREE_CODE (arg0) != VAR_DECL
4382 && TREE_CODE (arg0) != PARM_DECL)
4383 || TREE_SIDE_EFFECTS (arg0)))
4384 {
4385 if (TREE_CODE (true_value) != COND_EXPR)
4386 lhs = fold (build (code, type, arg0, true_value));
4387
4388 if (TREE_CODE (false_value) != COND_EXPR)
4389 rhs = fold (build (code, type, arg0, false_value));
4390
4391 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4392 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4393 arg0 = save_expr (arg0), lhs = rhs = 0;
4394 }
4395
4396 if (lhs == 0)
4397 lhs = fold (build (code, type, arg0, true_value));
4398 if (rhs == 0)
4399 rhs = fold (build (code, type, arg0, false_value));
4400
4401 test = fold (build (COND_EXPR, type, test, lhs, rhs));
4402
4403 if (TREE_CODE (arg0) == SAVE_EXPR)
4404 return build (COMPOUND_EXPR, type,
4405 convert (void_type_node, arg0),
4406 strip_compound_expr (test, arg0));
4407 else
4408 return convert (type, test);
4409 }
4410
4411 else if (TREE_CODE (arg0) == COMPOUND_EXPR)
4412 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4413 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4414 else if ((TREE_CODE (arg0) == COND_EXPR
4415 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4416 && TREE_CODE_CLASS (code) != '<'))
|
| 4417 && (TREE_CODE (arg1) != COND_EXPR
4418 || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
|
4087 && (! TREE_SIDE_EFFECTS (arg1)
4088 || (current_function_decl != 0
4089 && ! contains_placeholder_p (arg1))))
4090 {
4091 tree test, true_value, false_value;
4092 tree lhs = 0, rhs = 0;
4093
4094 if (TREE_CODE (arg0) == COND_EXPR)
4095 {
4096 test = TREE_OPERAND (arg0, 0);
4097 true_value = TREE_OPERAND (arg0, 1);
4098 false_value = TREE_OPERAND (arg0, 2);
4099 }
4100 else
4101 {
4102 tree testtype = TREE_TYPE (arg0);
4103 test = arg0;
4104 true_value = convert (testtype, integer_one_node);
4105 false_value = convert (testtype, integer_zero_node);
4106 }
4107
4108 if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4109 && current_function_decl != 0
4110 && ((TREE_CODE (arg1) != VAR_DECL
4111 && TREE_CODE (arg1) != PARM_DECL)
4112 || TREE_SIDE_EFFECTS (arg1)))
4113 {
4114 if (TREE_CODE (true_value) != COND_EXPR)
4115 lhs = fold (build (code, type, true_value, arg1));
4116
4117 if (TREE_CODE (false_value) != COND_EXPR)
4118 rhs = fold (build (code, type, false_value, arg1));
4119
4120 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4121 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4122 arg1 = save_expr (arg1), lhs = rhs = 0;
4123 }
4124
4125 if (lhs == 0)
4126 lhs = fold (build (code, type, true_value, arg1));
4127
4128 if (rhs == 0)
4129 rhs = fold (build (code, type, false_value, arg1));
4130
4131 test = fold (build (COND_EXPR, type, test, lhs, rhs));
4132 if (TREE_CODE (arg1) == SAVE_EXPR)
4133 return build (COMPOUND_EXPR, type,
4134 convert (void_type_node, arg1),
4135 strip_compound_expr (test, arg1));
4136 else
4137 return convert (type, test);
4138 }
4139 }
4140 else if (TREE_CODE_CLASS (code) == '<'
4141 && TREE_CODE (arg0) == COMPOUND_EXPR)
4142 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4143 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4144 else if (TREE_CODE_CLASS (code) == '<'
4145 && TREE_CODE (arg1) == COMPOUND_EXPR)
4146 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4147 fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4148
4149 switch (code)
4150 {
4151 case INTEGER_CST:
4152 case REAL_CST:
4153 case STRING_CST:
4154 case COMPLEX_CST:
4155 case CONSTRUCTOR:
4156 return t;
4157
4158 case CONST_DECL:
4159 return fold (DECL_INITIAL (t));
4160
4161 case NOP_EXPR:
4162 case FLOAT_EXPR:
4163 case CONVERT_EXPR:
4164 case FIX_TRUNC_EXPR:
4165 /* Other kinds of FIX are not handled properly by fold_convert. */
4166
4167 if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4168 return TREE_OPERAND (t, 0);
4169
4170 /* Handle cases of two conversions in a row. */
4171 if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4172 || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4173 {
4174 tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4175 tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4176 tree final_type = TREE_TYPE (t);
4177 int inside_int = INTEGRAL_TYPE_P (inside_type);
4178 int inside_ptr = POINTER_TYPE_P (inside_type);
4179 int inside_float = FLOAT_TYPE_P (inside_type);
4180 int inside_prec = TYPE_PRECISION (inside_type);
4181 int inside_unsignedp = TREE_UNSIGNED (inside_type);
4182 int inter_int = INTEGRAL_TYPE_P (inter_type);
4183 int inter_ptr = POINTER_TYPE_P (inter_type);
4184 int inter_float = FLOAT_TYPE_P (inter_type);
4185 int inter_prec = TYPE_PRECISION (inter_type);
4186 int inter_unsignedp = TREE_UNSIGNED (inter_type);
4187 int final_int = INTEGRAL_TYPE_P (final_type);
4188 int final_ptr = POINTER_TYPE_P (final_type);
4189 int final_float = FLOAT_TYPE_P (final_type);
4190 int final_prec = TYPE_PRECISION (final_type);
4191 int final_unsignedp = TREE_UNSIGNED (final_type);
4192
4193 /* In addition to the cases of two conversions in a row
4194 handled below, if we are converting something to its own
4195 type via an object of identical or wider precision, neither
4196 conversion is needed. */
4197 if (inside_type == final_type
4198 && ((inter_int && final_int) || (inter_float && final_float))
4199 && inter_prec >= final_prec)
4200 return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
4201
4202 /* Likewise, if the intermediate and final types are either both
4203 float or both integer, we don't need the middle conversion if
4204 it is wider than the final type and doesn't change the signedness
4205 (for integers). Avoid this if the final type is a pointer
4206 since then we sometimes need the inner conversion. Likewise if
4207 the outer has a precision not equal to the size of its mode. */
4208 if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4209 || (inter_float && inside_float))
4210 && inter_prec >= inside_prec
4211 && (inter_float || inter_unsignedp == inside_unsignedp)
4212 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4213 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4214 && ! final_ptr)
4215 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4216
4217 /* If we have a sign-extension of a zero-extended value, we can
4218 replace that by a single zero-extension. */
4219 if (inside_int && inter_int && final_int
4220 && inside_prec < inter_prec && inter_prec < final_prec
4221 && inside_unsignedp && !inter_unsignedp)
4222 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4223
4224 /* Two conversions in a row are not needed unless:
4225 - some conversion is floating-point (overstrict for now), or
4226 - the intermediate type is narrower than both initial and
4227 final, or
4228 - the intermediate type and innermost type differ in signedness,
4229 and the outermost type is wider than the intermediate, or
4230 - the initial type is a pointer type and the precisions of the
4231 intermediate and final types differ, or
4232 - the final type is a pointer type and the precisions of the
4233 initial and intermediate types differ. */
4234 if (! inside_float && ! inter_float && ! final_float
4235 && (inter_prec > inside_prec || inter_prec > final_prec)
4236 && ! (inside_int && inter_int
4237 && inter_unsignedp != inside_unsignedp
4238 && inter_prec < final_prec)
4239 && ((inter_unsignedp && inter_prec > inside_prec)
4240 == (final_unsignedp && final_prec > inter_prec))
4241 && ! (inside_ptr && inter_prec != final_prec)
4242 && ! (final_ptr && inside_prec != inter_prec)
4243 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4244 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4245 && ! final_ptr)
4246 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4247 }
4248
4249 if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
4250 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
4251 /* Detect assigning a bitfield. */
4252 && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
4253 && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
4254 {
4255 /* Don't leave an assignment inside a conversion
4256 unless assigning a bitfield. */
4257 tree prev = TREE_OPERAND (t, 0);
4258 TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
4259 /* First do the assignment, then return converted constant. */
4260 t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
4261 TREE_USED (t) = 1;
4262 return t;
4263 }
4264 if (!wins)
4265 {
4266 TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
4267 return t;
4268 }
4269 return fold_convert (t, arg0);
4270
4271#if 0 /* This loses on &"foo"[0]. */
4272 case ARRAY_REF:
4273 {
4274 int i;
4275
4276 /* Fold an expression like: "foo"[2] */
4277 if (TREE_CODE (arg0) == STRING_CST
4278 && TREE_CODE (arg1) == INTEGER_CST
4279 && !TREE_INT_CST_HIGH (arg1)
4280 && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
4281 {
4282 t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
4283 TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
4284 force_fit_type (t, 0);
4285 }
4286 }
4287 return t;
4288#endif /* 0 */
4289
4290 case COMPONENT_REF:
4291 if (TREE_CODE (arg0) == CONSTRUCTOR)
4292 {
4293 tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
4294 if (m)
4295 t = TREE_VALUE (m);
4296 }
4297 return t;
4298
4299 case RANGE_EXPR:
4300 TREE_CONSTANT (t) = wins;
4301 return t;
4302
4303 case NEGATE_EXPR:
4304 if (wins)
4305 {
4306 if (TREE_CODE (arg0) == INTEGER_CST)
4307 {
4308 HOST_WIDE_INT low, high;
4309 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4310 TREE_INT_CST_HIGH (arg0),
4311 &low, &high);
4312 t = build_int_2 (low, high);
4313 TREE_TYPE (t) = type;
4314 TREE_OVERFLOW (t)
4315 = (TREE_OVERFLOW (arg0)
4316 | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
4317 TREE_CONSTANT_OVERFLOW (t)
4318 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
4319 }
4320 else if (TREE_CODE (arg0) == REAL_CST)
4321 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
4322 }
4323 else if (TREE_CODE (arg0) == NEGATE_EXPR)
4324 return TREE_OPERAND (arg0, 0);
4325
4326 /* Convert - (a - b) to (b - a) for non-floating-point. */
4327 else if (TREE_CODE (arg0) == MINUS_EXPR && ! FLOAT_TYPE_P (type))
4328 return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
4329 TREE_OPERAND (arg0, 0));
4330
4331 return t;
4332
4333 case ABS_EXPR:
4334 if (wins)
4335 {
4336 if (TREE_CODE (arg0) == INTEGER_CST)
4337 {
4338 if (! TREE_UNSIGNED (type)
4339 && TREE_INT_CST_HIGH (arg0) < 0)
4340 {
4341 HOST_WIDE_INT low, high;
4342 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4343 TREE_INT_CST_HIGH (arg0),
4344 &low, &high);
4345 t = build_int_2 (low, high);
4346 TREE_TYPE (t) = type;
4347 TREE_OVERFLOW (t)
4348 = (TREE_OVERFLOW (arg0)
4349 | force_fit_type (t, overflow));
4350 TREE_CONSTANT_OVERFLOW (t)
4351 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
4352 }
4353 }
4354 else if (TREE_CODE (arg0) == REAL_CST)
4355 {
4356 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
4357 t = build_real (type,
4358 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
4359 }
4360 }
4361 else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
4362 return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
4363 return t;
4364
4365 case CONJ_EXPR:
4366 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
4367 return arg0;
4368 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
4369 return build (COMPLEX_EXPR, TREE_TYPE (arg0),
4370 TREE_OPERAND (arg0, 0),
4371 fold (build1 (NEGATE_EXPR,
4372 TREE_TYPE (TREE_TYPE (arg0)),
4373 TREE_OPERAND (arg0, 1))));
4374 else if (TREE_CODE (arg0) == COMPLEX_CST)
4375 return build_complex (type, TREE_OPERAND (arg0, 0),
4376 fold (build1 (NEGATE_EXPR,
4377 TREE_TYPE (TREE_TYPE (arg0)),
4378 TREE_OPERAND (arg0, 1))));
4379 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
4380 return fold (build (TREE_CODE (arg0), type,
4381 fold (build1 (CONJ_EXPR, type,
4382 TREE_OPERAND (arg0, 0))),
4383 fold (build1 (CONJ_EXPR,
4384 type, TREE_OPERAND (arg0, 1)))));
4385 else if (TREE_CODE (arg0) == CONJ_EXPR)
4386 return TREE_OPERAND (arg0, 0);
4387 return t;
4388
4389 case BIT_NOT_EXPR:
4390 if (wins)
4391 {
4392 t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
4393 ~ TREE_INT_CST_HIGH (arg0));
4394 TREE_TYPE (t) = type;
4395 force_fit_type (t, 0);
4396 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
4397 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
4398 }
4399 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
4400 return TREE_OPERAND (arg0, 0);
4401 return t;
4402
4403 case PLUS_EXPR:
4404 /* A + (-B) -> A - B */
4405 if (TREE_CODE (arg1) == NEGATE_EXPR)
4406 return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
4407 else if (! FLOAT_TYPE_P (type))
4408 {
4409 if (integer_zerop (arg1))
4410 return non_lvalue (convert (type, arg0));
4411
4412 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
4413 with a constant, and the two constants have no bits in common,
4414 we should treat this as a BIT_IOR_EXPR since this may produce more
4415 simplifications. */
4416 if (TREE_CODE (arg0) == BIT_AND_EXPR
4417 && TREE_CODE (arg1) == BIT_AND_EXPR
4418 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
4419 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
4420 && integer_zerop (const_binop (BIT_AND_EXPR,
4421 TREE_OPERAND (arg0, 1),
4422 TREE_OPERAND (arg1, 1), 0)))
4423 {
4424 code = BIT_IOR_EXPR;
4425 goto bit_ior;
4426 }
4427
| 4419 && (! TREE_SIDE_EFFECTS (arg1)
4420 || (current_function_decl != 0
4421 && ! contains_placeholder_p (arg1))))
4422 {
4423 tree test, true_value, false_value;
4424 tree lhs = 0, rhs = 0;
4425
4426 if (TREE_CODE (arg0) == COND_EXPR)
4427 {
4428 test = TREE_OPERAND (arg0, 0);
4429 true_value = TREE_OPERAND (arg0, 1);
4430 false_value = TREE_OPERAND (arg0, 2);
4431 }
4432 else
4433 {
4434 tree testtype = TREE_TYPE (arg0);
4435 test = arg0;
4436 true_value = convert (testtype, integer_one_node);
4437 false_value = convert (testtype, integer_zero_node);
4438 }
4439
4440 if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
4441 && current_function_decl != 0
4442 && ((TREE_CODE (arg1) != VAR_DECL
4443 && TREE_CODE (arg1) != PARM_DECL)
4444 || TREE_SIDE_EFFECTS (arg1)))
4445 {
4446 if (TREE_CODE (true_value) != COND_EXPR)
4447 lhs = fold (build (code, type, true_value, arg1));
4448
4449 if (TREE_CODE (false_value) != COND_EXPR)
4450 rhs = fold (build (code, type, false_value, arg1));
4451
4452 if ((lhs == 0 || ! TREE_CONSTANT (lhs))
4453 && (rhs == 0 || !TREE_CONSTANT (rhs)))
4454 arg1 = save_expr (arg1), lhs = rhs = 0;
4455 }
4456
4457 if (lhs == 0)
4458 lhs = fold (build (code, type, true_value, arg1));
4459
4460 if (rhs == 0)
4461 rhs = fold (build (code, type, false_value, arg1));
4462
4463 test = fold (build (COND_EXPR, type, test, lhs, rhs));
4464 if (TREE_CODE (arg1) == SAVE_EXPR)
4465 return build (COMPOUND_EXPR, type,
4466 convert (void_type_node, arg1),
4467 strip_compound_expr (test, arg1));
4468 else
4469 return convert (type, test);
4470 }
4471 }
4472 else if (TREE_CODE_CLASS (code) == '<'
4473 && TREE_CODE (arg0) == COMPOUND_EXPR)
4474 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
4475 fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
4476 else if (TREE_CODE_CLASS (code) == '<'
4477 && TREE_CODE (arg1) == COMPOUND_EXPR)
4478 return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
4479 fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
4480
4481 switch (code)
4482 {
4483 case INTEGER_CST:
4484 case REAL_CST:
4485 case STRING_CST:
4486 case COMPLEX_CST:
4487 case CONSTRUCTOR:
4488 return t;
4489
4490 case CONST_DECL:
4491 return fold (DECL_INITIAL (t));
4492
4493 case NOP_EXPR:
4494 case FLOAT_EXPR:
4495 case CONVERT_EXPR:
4496 case FIX_TRUNC_EXPR:
4497 /* Other kinds of FIX are not handled properly by fold_convert. */
4498
4499 if (TREE_TYPE (TREE_OPERAND (t, 0)) == TREE_TYPE (t))
4500 return TREE_OPERAND (t, 0);
4501
4502 /* Handle cases of two conversions in a row. */
4503 if (TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
4504 || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
4505 {
4506 tree inside_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4507 tree inter_type = TREE_TYPE (TREE_OPERAND (t, 0));
4508 tree final_type = TREE_TYPE (t);
4509 int inside_int = INTEGRAL_TYPE_P (inside_type);
4510 int inside_ptr = POINTER_TYPE_P (inside_type);
4511 int inside_float = FLOAT_TYPE_P (inside_type);
4512 int inside_prec = TYPE_PRECISION (inside_type);
4513 int inside_unsignedp = TREE_UNSIGNED (inside_type);
4514 int inter_int = INTEGRAL_TYPE_P (inter_type);
4515 int inter_ptr = POINTER_TYPE_P (inter_type);
4516 int inter_float = FLOAT_TYPE_P (inter_type);
4517 int inter_prec = TYPE_PRECISION (inter_type);
4518 int inter_unsignedp = TREE_UNSIGNED (inter_type);
4519 int final_int = INTEGRAL_TYPE_P (final_type);
4520 int final_ptr = POINTER_TYPE_P (final_type);
4521 int final_float = FLOAT_TYPE_P (final_type);
4522 int final_prec = TYPE_PRECISION (final_type);
4523 int final_unsignedp = TREE_UNSIGNED (final_type);
4524
4525 /* In addition to the cases of two conversions in a row
4526 handled below, if we are converting something to its own
4527 type via an object of identical or wider precision, neither
4528 conversion is needed. */
4529 if (inside_type == final_type
4530 && ((inter_int && final_int) || (inter_float && final_float))
4531 && inter_prec >= final_prec)
4532 return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
4533
4534 /* Likewise, if the intermediate and final types are either both
4535 float or both integer, we don't need the middle conversion if
4536 it is wider than the final type and doesn't change the signedness
4537 (for integers). Avoid this if the final type is a pointer
4538 since then we sometimes need the inner conversion. Likewise if
4539 the outer has a precision not equal to the size of its mode. */
4540 if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
4541 || (inter_float && inside_float))
4542 && inter_prec >= inside_prec
4543 && (inter_float || inter_unsignedp == inside_unsignedp)
4544 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4545 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4546 && ! final_ptr)
4547 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4548
4549 /* If we have a sign-extension of a zero-extended value, we can
4550 replace that by a single zero-extension. */
4551 if (inside_int && inter_int && final_int
4552 && inside_prec < inter_prec && inter_prec < final_prec
4553 && inside_unsignedp && !inter_unsignedp)
4554 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4555
4556 /* Two conversions in a row are not needed unless:
4557 - some conversion is floating-point (overstrict for now), or
4558 - the intermediate type is narrower than both initial and
4559 final, or
4560 - the intermediate type and innermost type differ in signedness,
4561 and the outermost type is wider than the intermediate, or
4562 - the initial type is a pointer type and the precisions of the
4563 intermediate and final types differ, or
4564 - the final type is a pointer type and the precisions of the
4565 initial and intermediate types differ. */
4566 if (! inside_float && ! inter_float && ! final_float
4567 && (inter_prec > inside_prec || inter_prec > final_prec)
4568 && ! (inside_int && inter_int
4569 && inter_unsignedp != inside_unsignedp
4570 && inter_prec < final_prec)
4571 && ((inter_unsignedp && inter_prec > inside_prec)
4572 == (final_unsignedp && final_prec > inter_prec))
4573 && ! (inside_ptr && inter_prec != final_prec)
4574 && ! (final_ptr && inside_prec != inter_prec)
4575 && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (final_type))
4576 && TYPE_MODE (final_type) == TYPE_MODE (inter_type))
4577 && ! final_ptr)
4578 return convert (final_type, TREE_OPERAND (TREE_OPERAND (t, 0), 0));
4579 }
4580
4581 if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
4582 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
4583 /* Detect assigning a bitfield. */
4584 && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
4585 && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
4586 {
4587 /* Don't leave an assignment inside a conversion
4588 unless assigning a bitfield. */
4589 tree prev = TREE_OPERAND (t, 0);
4590 TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
4591 /* First do the assignment, then return converted constant. */
4592 t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
4593 TREE_USED (t) = 1;
4594 return t;
4595 }
4596 if (!wins)
4597 {
4598 TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
4599 return t;
4600 }
4601 return fold_convert (t, arg0);
4602
4603#if 0 /* This loses on &"foo"[0]. */
4604 case ARRAY_REF:
4605 {
4606 int i;
4607
4608 /* Fold an expression like: "foo"[2] */
4609 if (TREE_CODE (arg0) == STRING_CST
4610 && TREE_CODE (arg1) == INTEGER_CST
4611 && !TREE_INT_CST_HIGH (arg1)
4612 && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
4613 {
4614 t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
4615 TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
4616 force_fit_type (t, 0);
4617 }
4618 }
4619 return t;
4620#endif /* 0 */
4621
4622 case COMPONENT_REF:
4623 if (TREE_CODE (arg0) == CONSTRUCTOR)
4624 {
4625 tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0));
4626 if (m)
4627 t = TREE_VALUE (m);
4628 }
4629 return t;
4630
4631 case RANGE_EXPR:
4632 TREE_CONSTANT (t) = wins;
4633 return t;
4634
4635 case NEGATE_EXPR:
4636 if (wins)
4637 {
4638 if (TREE_CODE (arg0) == INTEGER_CST)
4639 {
4640 HOST_WIDE_INT low, high;
4641 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4642 TREE_INT_CST_HIGH (arg0),
4643 &low, &high);
4644 t = build_int_2 (low, high);
4645 TREE_TYPE (t) = type;
4646 TREE_OVERFLOW (t)
4647 = (TREE_OVERFLOW (arg0)
4648 | force_fit_type (t, overflow && !TREE_UNSIGNED (type)));
4649 TREE_CONSTANT_OVERFLOW (t)
4650 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
4651 }
4652 else if (TREE_CODE (arg0) == REAL_CST)
4653 t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
4654 }
4655 else if (TREE_CODE (arg0) == NEGATE_EXPR)
4656 return TREE_OPERAND (arg0, 0);
4657
4658 /* Convert - (a - b) to (b - a) for non-floating-point. */
4659 else if (TREE_CODE (arg0) == MINUS_EXPR && ! FLOAT_TYPE_P (type))
4660 return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
4661 TREE_OPERAND (arg0, 0));
4662
4663 return t;
4664
4665 case ABS_EXPR:
4666 if (wins)
4667 {
4668 if (TREE_CODE (arg0) == INTEGER_CST)
4669 {
4670 if (! TREE_UNSIGNED (type)
4671 && TREE_INT_CST_HIGH (arg0) < 0)
4672 {
4673 HOST_WIDE_INT low, high;
4674 int overflow = neg_double (TREE_INT_CST_LOW (arg0),
4675 TREE_INT_CST_HIGH (arg0),
4676 &low, &high);
4677 t = build_int_2 (low, high);
4678 TREE_TYPE (t) = type;
4679 TREE_OVERFLOW (t)
4680 = (TREE_OVERFLOW (arg0)
4681 | force_fit_type (t, overflow));
4682 TREE_CONSTANT_OVERFLOW (t)
4683 = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
4684 }
4685 }
4686 else if (TREE_CODE (arg0) == REAL_CST)
4687 {
4688 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
4689 t = build_real (type,
4690 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
4691 }
4692 }
4693 else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
4694 return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
4695 return t;
4696
4697 case CONJ_EXPR:
4698 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
4699 return arg0;
4700 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
4701 return build (COMPLEX_EXPR, TREE_TYPE (arg0),
4702 TREE_OPERAND (arg0, 0),
4703 fold (build1 (NEGATE_EXPR,
4704 TREE_TYPE (TREE_TYPE (arg0)),
4705 TREE_OPERAND (arg0, 1))));
4706 else if (TREE_CODE (arg0) == COMPLEX_CST)
4707 return build_complex (type, TREE_OPERAND (arg0, 0),
4708 fold (build1 (NEGATE_EXPR,
4709 TREE_TYPE (TREE_TYPE (arg0)),
4710 TREE_OPERAND (arg0, 1))));
4711 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
4712 return fold (build (TREE_CODE (arg0), type,
4713 fold (build1 (CONJ_EXPR, type,
4714 TREE_OPERAND (arg0, 0))),
4715 fold (build1 (CONJ_EXPR,
4716 type, TREE_OPERAND (arg0, 1)))));
4717 else if (TREE_CODE (arg0) == CONJ_EXPR)
4718 return TREE_OPERAND (arg0, 0);
4719 return t;
4720
4721 case BIT_NOT_EXPR:
4722 if (wins)
4723 {
4724 t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
4725 ~ TREE_INT_CST_HIGH (arg0));
4726 TREE_TYPE (t) = type;
4727 force_fit_type (t, 0);
4728 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
4729 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
4730 }
4731 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
4732 return TREE_OPERAND (arg0, 0);
4733 return t;
4734
4735 case PLUS_EXPR:
4736 /* A + (-B) -> A - B */
4737 if (TREE_CODE (arg1) == NEGATE_EXPR)
4738 return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
4739 else if (! FLOAT_TYPE_P (type))
4740 {
4741 if (integer_zerop (arg1))
4742 return non_lvalue (convert (type, arg0));
4743
4744 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
4745 with a constant, and the two constants have no bits in common,
4746 we should treat this as a BIT_IOR_EXPR since this may produce more
4747 simplifications. */
4748 if (TREE_CODE (arg0) == BIT_AND_EXPR
4749 && TREE_CODE (arg1) == BIT_AND_EXPR
4750 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
4751 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
4752 && integer_zerop (const_binop (BIT_AND_EXPR,
4753 TREE_OPERAND (arg0, 1),
4754 TREE_OPERAND (arg1, 1), 0)))
4755 {
4756 code = BIT_IOR_EXPR;
4757 goto bit_ior;
4758 }
4759
|
4428 /* (A * C) + (B * C) -> (A+B) * C. Since we are most concerned
4429 about the case where C is a constant, just try one of the
4430 four possibilities. */
| 4760 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
4761 {
4762 tree arg00, arg01, arg10, arg11;
4763 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
|
4431
| 4764
|
4432 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
4433 && operand_equal_p (TREE_OPERAND (arg0, 1),
4434 TREE_OPERAND (arg1, 1), 0))
4435 return fold (build (MULT_EXPR, type,
4436 fold (build (PLUS_EXPR, type,
4437 TREE_OPERAND (arg0, 0),
4438 TREE_OPERAND (arg1, 0))),
4439 TREE_OPERAND (arg0, 1)));
| 4765 /* (A * C) + (B * C) -> (A+B) * C.
4766 We are most concerned about the case where C is a constant,
4767 but other combinations show up during loop reduction. Since
4768 it is not difficult, try all four possibilities. */
4769
4770 arg00 = TREE_OPERAND (arg0, 0);
4771 arg01 = TREE_OPERAND (arg0, 1);
4772 arg10 = TREE_OPERAND (arg1, 0);
4773 arg11 = TREE_OPERAND (arg1, 1);
4774 same = NULL_TREE;
4775
4776 if (operand_equal_p (arg01, arg11, 0))
4777 same = arg01, alt0 = arg00, alt1 = arg10;
4778 else if (operand_equal_p (arg00, arg10, 0))
4779 same = arg00, alt0 = arg01, alt1 = arg11;
4780 else if (operand_equal_p (arg00, arg11, 0))
4781 same = arg00, alt0 = arg01, alt1 = arg10;
4782 else if (operand_equal_p (arg01, arg10, 0))
4783 same = arg01, alt0 = arg00, alt1 = arg11;
4784
4785 if (same)
4786 return fold (build (MULT_EXPR, type,
4787 fold (build (PLUS_EXPR, type, alt0, alt1)),
4788 same));
4789 }
|
4440 }
4441 /* In IEEE floating point, x+0 may not equal x. */
4442 else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4443 || flag_fast_math)
4444 && real_zerop (arg1))
4445 return non_lvalue (convert (type, arg0));
4446 associate:
4447 /* In most languages, can't associate operations on floats
4448 through parentheses. Rather than remember where the parentheses
4449 were, we don't associate floats at all. It shouldn't matter much.
4450 However, associating multiplications is only very slightly
4451 inaccurate, so do that if -ffast-math is specified. */
4452 if (FLOAT_TYPE_P (type)
4453 && ! (flag_fast_math && code == MULT_EXPR))
4454 goto binary;
4455
4456 /* The varsign == -1 cases happen only for addition and subtraction.
4457 It says that the arg that was split was really CON minus VAR.
4458 The rest of the code applies to all associative operations. */
4459 if (!wins)
4460 {
4461 tree var, con;
4462 int varsign;
4463
4464 if (split_tree (arg0, code, &var, &con, &varsign))
4465 {
4466 if (varsign == -1)
4467 {
4468 /* EXPR is (CON-VAR) +- ARG1. */
4469 /* If it is + and VAR==ARG1, return just CONST. */
4470 if (code == PLUS_EXPR && operand_equal_p (var, arg1, 0))
4471 return convert (TREE_TYPE (t), con);
4472
4473 /* If ARG0 is a constant, don't change things around;
4474 instead keep all the constant computations together. */
4475
4476 if (TREE_CONSTANT (arg0))
4477 return t;
4478
4479 /* Otherwise return (CON +- ARG1) - VAR. */
4480 t = build (MINUS_EXPR, type,
4481 fold (build (code, type, con, arg1)), var);
4482 }
4483 else
4484 {
4485 /* EXPR is (VAR+CON) +- ARG1. */
4486 /* If it is - and VAR==ARG1, return just CONST. */
4487 if (code == MINUS_EXPR && operand_equal_p (var, arg1, 0))
4488 return convert (TREE_TYPE (t), con);
4489
4490 /* If ARG0 is a constant, don't change things around;
4491 instead keep all the constant computations together. */
4492
4493 if (TREE_CONSTANT (arg0))
4494 return t;
4495
4496 /* Otherwise return VAR +- (ARG1 +- CON). */
4497 tem = fold (build (code, type, arg1, con));
4498 t = build (code, type, var, tem);
4499
4500 if (integer_zerop (tem)
4501 && (code == PLUS_EXPR || code == MINUS_EXPR))
4502 return convert (type, var);
4503 /* If we have x +/- (c - d) [c an explicit integer]
4504 change it to x -/+ (d - c) since if d is relocatable
4505 then the latter can be a single immediate insn
4506 and the former cannot. */
4507 if (TREE_CODE (tem) == MINUS_EXPR
4508 && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
4509 {
4510 tree tem1 = TREE_OPERAND (tem, 1);
4511 TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
4512 TREE_OPERAND (tem, 0) = tem1;
4513 TREE_SET_CODE (t,
4514 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4515 }
4516 }
4517 return t;
4518 }
4519
4520 if (split_tree (arg1, code, &var, &con, &varsign))
4521 {
4522 if (TREE_CONSTANT (arg1))
4523 return t;
4524
4525 if (varsign == -1)
4526 TREE_SET_CODE (t,
4527 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4528
4529 /* EXPR is ARG0 +- (CON +- VAR). */
4530 if (TREE_CODE (t) == MINUS_EXPR
4531 && operand_equal_p (var, arg0, 0))
4532 {
4533 /* If VAR and ARG0 cancel, return just CON or -CON. */
4534 if (code == PLUS_EXPR)
4535 return convert (TREE_TYPE (t), con);
4536 return fold (build1 (NEGATE_EXPR, TREE_TYPE (t),
4537 convert (TREE_TYPE (t), con)));
4538 }
4539
4540 t = build (TREE_CODE (t), type,
4541 fold (build (code, TREE_TYPE (t), arg0, con)), var);
4542
4543 if (integer_zerop (TREE_OPERAND (t, 0))
4544 && TREE_CODE (t) == PLUS_EXPR)
4545 return convert (TREE_TYPE (t), var);
4546 return t;
4547 }
4548 }
4549 binary:
4550#if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
4551 if (TREE_CODE (arg1) == REAL_CST)
4552 return t;
4553#endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
4554 if (wins)
4555 t1 = const_binop (code, arg0, arg1, 0);
4556 if (t1 != NULL_TREE)
4557 {
4558 /* The return value should always have
4559 the same type as the original expression. */
4560 if (TREE_TYPE (t1) != TREE_TYPE (t))
4561 t1 = convert (TREE_TYPE (t), t1);
4562
4563 return t1;
4564 }
4565 return t;
4566
4567 case MINUS_EXPR:
4568 if (! FLOAT_TYPE_P (type))
4569 {
4570 if (! wins && integer_zerop (arg0))
4571 return build1 (NEGATE_EXPR, type, arg1);
4572 if (integer_zerop (arg1))
4573 return non_lvalue (convert (type, arg0));
4574
4575 /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
4576 about the case where C is a constant, just try one of the
4577 four possibilities. */
4578
4579 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
4580 && operand_equal_p (TREE_OPERAND (arg0, 1),
4581 TREE_OPERAND (arg1, 1), 0))
4582 return fold (build (MULT_EXPR, type,
4583 fold (build (MINUS_EXPR, type,
4584 TREE_OPERAND (arg0, 0),
4585 TREE_OPERAND (arg1, 0))),
4586 TREE_OPERAND (arg0, 1)));
4587 }
4588 /* Convert A - (-B) to A + B. */
4589 else if (TREE_CODE (arg1) == NEGATE_EXPR)
4590 return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
4591
4592 else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4593 || flag_fast_math)
4594 {
4595 /* Except with IEEE floating point, 0-x equals -x. */
4596 if (! wins && real_zerop (arg0))
4597 return build1 (NEGATE_EXPR, type, arg1);
4598 /* Except with IEEE floating point, x-0 equals x. */
4599 if (real_zerop (arg1))
4600 return non_lvalue (convert (type, arg0));
4601 }
4602
4603 /* Fold &x - &x. This can happen from &x.foo - &x.
4604 This is unsafe for certain floats even in non-IEEE formats.
4605 In IEEE, it is unsafe because it does wrong for NaNs.
4606 Also note that operand_equal_p is always false if an operand
4607 is volatile. */
4608
4609 if ((! FLOAT_TYPE_P (type) || flag_fast_math)
4610 && operand_equal_p (arg0, arg1, 0))
4611 return convert (type, integer_zero_node);
4612
4613 goto associate;
4614
4615 case MULT_EXPR:
4616 if (! FLOAT_TYPE_P (type))
4617 {
4618 if (integer_zerop (arg1))
4619 return omit_one_operand (type, arg1, arg0);
4620 if (integer_onep (arg1))
4621 return non_lvalue (convert (type, arg0));
4622
4623 /* ((A / C) * C) is A if the division is an
4624 EXACT_DIV_EXPR. Since C is normally a constant,
4625 just check for one of the four possibilities. */
4626
4627 if (TREE_CODE (arg0) == EXACT_DIV_EXPR
4628 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
4629 return TREE_OPERAND (arg0, 0);
4630
4631 /* (a * (1 << b)) is (a << b) */
4632 if (TREE_CODE (arg1) == LSHIFT_EXPR
4633 && integer_onep (TREE_OPERAND (arg1, 0)))
4634 return fold (build (LSHIFT_EXPR, type, arg0,
4635 TREE_OPERAND (arg1, 1)));
4636 if (TREE_CODE (arg0) == LSHIFT_EXPR
4637 && integer_onep (TREE_OPERAND (arg0, 0)))
4638 return fold (build (LSHIFT_EXPR, type, arg1,
4639 TREE_OPERAND (arg0, 1)));
4640 }
4641 else
4642 {
4643 /* x*0 is 0, except for IEEE floating point. */
4644 if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4645 || flag_fast_math)
4646 && real_zerop (arg1))
4647 return omit_one_operand (type, arg1, arg0);
4648 /* In IEEE floating point, x*1 is not equivalent to x for snans.
4649 However, ANSI says we can drop signals,
4650 so we can do this anyway. */
4651 if (real_onep (arg1))
4652 return non_lvalue (convert (type, arg0));
4653 /* x*2 is x+x */
4654 if (! wins && real_twop (arg1) && current_function_decl != 0
4655 && ! contains_placeholder_p (arg0))
4656 {
4657 tree arg = save_expr (arg0);
4658 return build (PLUS_EXPR, type, arg, arg);
4659 }
4660 }
4661 goto associate;
4662
4663 case BIT_IOR_EXPR:
4664 bit_ior:
4665 {
4666 register enum tree_code code0, code1;
4667
4668 if (integer_all_onesp (arg1))
4669 return omit_one_operand (type, arg1, arg0);
4670 if (integer_zerop (arg1))
4671 return non_lvalue (convert (type, arg0));
4672 t1 = distribute_bit_expr (code, type, arg0, arg1);
4673 if (t1 != NULL_TREE)
4674 return t1;
4675
4676 /* (A << C1) | (A >> C2) if A is unsigned and C1+C2 is the size of A
4677 is a rotate of A by C1 bits. */
4678 /* (A << B) | (A >> (Z - B)) if A is unsigned and Z is the size of A
4679 is a rotate of A by B bits. */
4680
4681 code0 = TREE_CODE (arg0);
4682 code1 = TREE_CODE (arg1);
4683 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
4684 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
4685 && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1,0), 0)
4686 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
4687 {
4688 register tree tree01, tree11;
4689 register enum tree_code code01, code11;
4690
4691 tree01 = TREE_OPERAND (arg0, 1);
4692 tree11 = TREE_OPERAND (arg1, 1);
| 4790 }
4791 /* In IEEE floating point, x+0 may not equal x. */
4792 else if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4793 || flag_fast_math)
4794 && real_zerop (arg1))
4795 return non_lvalue (convert (type, arg0));
4796 associate:
4797 /* In most languages, can't associate operations on floats
4798 through parentheses. Rather than remember where the parentheses
4799 were, we don't associate floats at all. It shouldn't matter much.
4800 However, associating multiplications is only very slightly
4801 inaccurate, so do that if -ffast-math is specified. */
4802 if (FLOAT_TYPE_P (type)
4803 && ! (flag_fast_math && code == MULT_EXPR))
4804 goto binary;
4805
4806 /* The varsign == -1 cases happen only for addition and subtraction.
4807 It says that the arg that was split was really CON minus VAR.
4808 The rest of the code applies to all associative operations. */
4809 if (!wins)
4810 {
4811 tree var, con;
4812 int varsign;
4813
4814 if (split_tree (arg0, code, &var, &con, &varsign))
4815 {
4816 if (varsign == -1)
4817 {
4818 /* EXPR is (CON-VAR) +- ARG1. */
4819 /* If it is + and VAR==ARG1, return just CONST. */
4820 if (code == PLUS_EXPR && operand_equal_p (var, arg1, 0))
4821 return convert (TREE_TYPE (t), con);
4822
4823 /* If ARG0 is a constant, don't change things around;
4824 instead keep all the constant computations together. */
4825
4826 if (TREE_CONSTANT (arg0))
4827 return t;
4828
4829 /* Otherwise return (CON +- ARG1) - VAR. */
4830 t = build (MINUS_EXPR, type,
4831 fold (build (code, type, con, arg1)), var);
4832 }
4833 else
4834 {
4835 /* EXPR is (VAR+CON) +- ARG1. */
4836 /* If it is - and VAR==ARG1, return just CONST. */
4837 if (code == MINUS_EXPR && operand_equal_p (var, arg1, 0))
4838 return convert (TREE_TYPE (t), con);
4839
4840 /* If ARG0 is a constant, don't change things around;
4841 instead keep all the constant computations together. */
4842
4843 if (TREE_CONSTANT (arg0))
4844 return t;
4845
4846 /* Otherwise return VAR +- (ARG1 +- CON). */
4847 tem = fold (build (code, type, arg1, con));
4848 t = build (code, type, var, tem);
4849
4850 if (integer_zerop (tem)
4851 && (code == PLUS_EXPR || code == MINUS_EXPR))
4852 return convert (type, var);
4853 /* If we have x +/- (c - d) [c an explicit integer]
4854 change it to x -/+ (d - c) since if d is relocatable
4855 then the latter can be a single immediate insn
4856 and the former cannot. */
4857 if (TREE_CODE (tem) == MINUS_EXPR
4858 && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
4859 {
4860 tree tem1 = TREE_OPERAND (tem, 1);
4861 TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
4862 TREE_OPERAND (tem, 0) = tem1;
4863 TREE_SET_CODE (t,
4864 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4865 }
4866 }
4867 return t;
4868 }
4869
4870 if (split_tree (arg1, code, &var, &con, &varsign))
4871 {
4872 if (TREE_CONSTANT (arg1))
4873 return t;
4874
4875 if (varsign == -1)
4876 TREE_SET_CODE (t,
4877 (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
4878
4879 /* EXPR is ARG0 +- (CON +- VAR). */
4880 if (TREE_CODE (t) == MINUS_EXPR
4881 && operand_equal_p (var, arg0, 0))
4882 {
4883 /* If VAR and ARG0 cancel, return just CON or -CON. */
4884 if (code == PLUS_EXPR)
4885 return convert (TREE_TYPE (t), con);
4886 return fold (build1 (NEGATE_EXPR, TREE_TYPE (t),
4887 convert (TREE_TYPE (t), con)));
4888 }
4889
4890 t = build (TREE_CODE (t), type,
4891 fold (build (code, TREE_TYPE (t), arg0, con)), var);
4892
4893 if (integer_zerop (TREE_OPERAND (t, 0))
4894 && TREE_CODE (t) == PLUS_EXPR)
4895 return convert (TREE_TYPE (t), var);
4896 return t;
4897 }
4898 }
4899 binary:
4900#if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
4901 if (TREE_CODE (arg1) == REAL_CST)
4902 return t;
4903#endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
4904 if (wins)
4905 t1 = const_binop (code, arg0, arg1, 0);
4906 if (t1 != NULL_TREE)
4907 {
4908 /* The return value should always have
4909 the same type as the original expression. */
4910 if (TREE_TYPE (t1) != TREE_TYPE (t))
4911 t1 = convert (TREE_TYPE (t), t1);
4912
4913 return t1;
4914 }
4915 return t;
4916
4917 case MINUS_EXPR:
4918 if (! FLOAT_TYPE_P (type))
4919 {
4920 if (! wins && integer_zerop (arg0))
4921 return build1 (NEGATE_EXPR, type, arg1);
4922 if (integer_zerop (arg1))
4923 return non_lvalue (convert (type, arg0));
4924
4925 /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
4926 about the case where C is a constant, just try one of the
4927 four possibilities. */
4928
4929 if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
4930 && operand_equal_p (TREE_OPERAND (arg0, 1),
4931 TREE_OPERAND (arg1, 1), 0))
4932 return fold (build (MULT_EXPR, type,
4933 fold (build (MINUS_EXPR, type,
4934 TREE_OPERAND (arg0, 0),
4935 TREE_OPERAND (arg1, 0))),
4936 TREE_OPERAND (arg0, 1)));
4937 }
4938 /* Convert A - (-B) to A + B. */
4939 else if (TREE_CODE (arg1) == NEGATE_EXPR)
4940 return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
4941
4942 else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4943 || flag_fast_math)
4944 {
4945 /* Except with IEEE floating point, 0-x equals -x. */
4946 if (! wins && real_zerop (arg0))
4947 return build1 (NEGATE_EXPR, type, arg1);
4948 /* Except with IEEE floating point, x-0 equals x. */
4949 if (real_zerop (arg1))
4950 return non_lvalue (convert (type, arg0));
4951 }
4952
4953 /* Fold &x - &x. This can happen from &x.foo - &x.
4954 This is unsafe for certain floats even in non-IEEE formats.
4955 In IEEE, it is unsafe because it does wrong for NaNs.
4956 Also note that operand_equal_p is always false if an operand
4957 is volatile. */
4958
4959 if ((! FLOAT_TYPE_P (type) || flag_fast_math)
4960 && operand_equal_p (arg0, arg1, 0))
4961 return convert (type, integer_zero_node);
4962
4963 goto associate;
4964
4965 case MULT_EXPR:
4966 if (! FLOAT_TYPE_P (type))
4967 {
4968 if (integer_zerop (arg1))
4969 return omit_one_operand (type, arg1, arg0);
4970 if (integer_onep (arg1))
4971 return non_lvalue (convert (type, arg0));
4972
4973 /* ((A / C) * C) is A if the division is an
4974 EXACT_DIV_EXPR. Since C is normally a constant,
4975 just check for one of the four possibilities. */
4976
4977 if (TREE_CODE (arg0) == EXACT_DIV_EXPR
4978 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
4979 return TREE_OPERAND (arg0, 0);
4980
4981 /* (a * (1 << b)) is (a << b) */
4982 if (TREE_CODE (arg1) == LSHIFT_EXPR
4983 && integer_onep (TREE_OPERAND (arg1, 0)))
4984 return fold (build (LSHIFT_EXPR, type, arg0,
4985 TREE_OPERAND (arg1, 1)));
4986 if (TREE_CODE (arg0) == LSHIFT_EXPR
4987 && integer_onep (TREE_OPERAND (arg0, 0)))
4988 return fold (build (LSHIFT_EXPR, type, arg1,
4989 TREE_OPERAND (arg0, 1)));
4990 }
4991 else
4992 {
4993 /* x*0 is 0, except for IEEE floating point. */
4994 if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4995 || flag_fast_math)
4996 && real_zerop (arg1))
4997 return omit_one_operand (type, arg1, arg0);
4998 /* In IEEE floating point, x*1 is not equivalent to x for snans.
4999 However, ANSI says we can drop signals,
5000 so we can do this anyway. */
5001 if (real_onep (arg1))
5002 return non_lvalue (convert (type, arg0));
5003 /* x*2 is x+x */
5004 if (! wins && real_twop (arg1) && current_function_decl != 0
5005 && ! contains_placeholder_p (arg0))
5006 {
5007 tree arg = save_expr (arg0);
5008 return build (PLUS_EXPR, type, arg, arg);
5009 }
5010 }
5011 goto associate;
5012
5013 case BIT_IOR_EXPR:
5014 bit_ior:
5015 {
5016 register enum tree_code code0, code1;
5017
5018 if (integer_all_onesp (arg1))
5019 return omit_one_operand (type, arg1, arg0);
5020 if (integer_zerop (arg1))
5021 return non_lvalue (convert (type, arg0));
5022 t1 = distribute_bit_expr (code, type, arg0, arg1);
5023 if (t1 != NULL_TREE)
5024 return t1;
5025
5026 /* (A << C1) | (A >> C2) if A is unsigned and C1+C2 is the size of A
5027 is a rotate of A by C1 bits. */
5028 /* (A << B) | (A >> (Z - B)) if A is unsigned and Z is the size of A
5029 is a rotate of A by B bits. */
5030
5031 code0 = TREE_CODE (arg0);
5032 code1 = TREE_CODE (arg1);
5033 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
5034 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
5035 && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1,0), 0)
5036 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5037 {
5038 register tree tree01, tree11;
5039 register enum tree_code code01, code11;
5040
5041 tree01 = TREE_OPERAND (arg0, 1);
5042 tree11 = TREE_OPERAND (arg1, 1);
|
| 5043 STRIP_NOPS (tree01);
5044 STRIP_NOPS (tree11);
|
4693 code01 = TREE_CODE (tree01);
4694 code11 = TREE_CODE (tree11);
4695 if (code01 == INTEGER_CST
4696 && code11 == INTEGER_CST
4697 && TREE_INT_CST_HIGH (tree01) == 0
4698 && TREE_INT_CST_HIGH (tree11) == 0
4699 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
4700 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
4701 return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
4702 code0 == LSHIFT_EXPR ? tree01 : tree11);
| 5045 code01 = TREE_CODE (tree01);
5046 code11 = TREE_CODE (tree11);
5047 if (code01 == INTEGER_CST
5048 && code11 == INTEGER_CST
5049 && TREE_INT_CST_HIGH (tree01) == 0
5050 && TREE_INT_CST_HIGH (tree11) == 0
5051 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
5052 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
5053 return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
5054 code0 == LSHIFT_EXPR ? tree01 : tree11);
|
4703 else if (code11 == MINUS_EXPR
4704 && TREE_CODE (TREE_OPERAND (tree11, 0)) == INTEGER_CST
4705 && TREE_INT_CST_HIGH (TREE_OPERAND (tree11, 0)) == 0
4706 && TREE_INT_CST_LOW (TREE_OPERAND (tree11, 0))
4707 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
4708 && operand_equal_p (tree01, TREE_OPERAND (tree11, 1), 0))
4709 return build (code0 == LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
4710 type, TREE_OPERAND (arg0, 0), tree01);
4711 else if (code01 == MINUS_EXPR
4712 && TREE_CODE (TREE_OPERAND (tree01, 0)) == INTEGER_CST
4713 && TREE_INT_CST_HIGH (TREE_OPERAND (tree01, 0)) == 0
4714 && TREE_INT_CST_LOW (TREE_OPERAND (tree01, 0))
4715 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
4716 && operand_equal_p (tree11, TREE_OPERAND (tree01, 1), 0))
4717 return build (code0 != LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
4718 type, TREE_OPERAND (arg0, 0), tree11);
| 5055 else if (code11 == MINUS_EXPR)
5056 {
5057 tree tree110, tree111;
5058 tree110 = TREE_OPERAND (tree11, 0);
5059 tree111 = TREE_OPERAND (tree11, 1);
5060 STRIP_NOPS (tree110);
5061 STRIP_NOPS (tree111);
5062 if (TREE_CODE (tree110) == INTEGER_CST
5063 && TREE_INT_CST_HIGH (tree110) == 0
5064 && (TREE_INT_CST_LOW (tree110)
5065 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5066 && operand_equal_p (tree01, tree111, 0))
5067 return build ((code0 == LSHIFT_EXPR
5068 ? LROTATE_EXPR
5069 : RROTATE_EXPR),
5070 type, TREE_OPERAND (arg0, 0), tree01);
5071 }
5072 else if (code01 == MINUS_EXPR)
5073 {
5074 tree tree010, tree011;
5075 tree010 = TREE_OPERAND (tree01, 0);
5076 tree011 = TREE_OPERAND (tree01, 1);
5077 STRIP_NOPS (tree010);
5078 STRIP_NOPS (tree011);
5079 if (TREE_CODE (tree010) == INTEGER_CST
5080 && TREE_INT_CST_HIGH (tree010) == 0
5081 && (TREE_INT_CST_LOW (tree010)
5082 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5083 && operand_equal_p (tree11, tree011, 0))
5084 return build ((code0 != LSHIFT_EXPR
5085 ? LROTATE_EXPR
5086 : RROTATE_EXPR),
5087 type, TREE_OPERAND (arg0, 0), tree11);
5088 }
|
4719 }
4720
4721 goto associate;
4722 }
4723
4724 case BIT_XOR_EXPR:
4725 if (integer_zerop (arg1))
4726 return non_lvalue (convert (type, arg0));
4727 if (integer_all_onesp (arg1))
4728 return fold (build1 (BIT_NOT_EXPR, type, arg0));
4729 goto associate;
4730
4731 case BIT_AND_EXPR:
4732 bit_and:
4733 if (integer_all_onesp (arg1))
4734 return non_lvalue (convert (type, arg0));
4735 if (integer_zerop (arg1))
4736 return omit_one_operand (type, arg1, arg0);
4737 t1 = distribute_bit_expr (code, type, arg0, arg1);
4738 if (t1 != NULL_TREE)
4739 return t1;
4740 /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
4741 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
4742 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
4743 {
4744 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
4745 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
4746 && (~TREE_INT_CST_LOW (arg0)
4747 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
4748 return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
4749 }
4750 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
4751 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
4752 {
4753 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
4754 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
4755 && (~TREE_INT_CST_LOW (arg1)
4756 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
4757 return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
4758 }
4759 goto associate;
4760
4761 case BIT_ANDTC_EXPR:
4762 if (integer_all_onesp (arg0))
4763 return non_lvalue (convert (type, arg1));
4764 if (integer_zerop (arg0))
4765 return omit_one_operand (type, arg0, arg1);
4766 if (TREE_CODE (arg1) == INTEGER_CST)
4767 {
4768 arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
4769 code = BIT_AND_EXPR;
4770 goto bit_and;
4771 }
4772 goto binary;
4773
4774 case RDIV_EXPR:
4775 /* In most cases, do nothing with a divide by zero. */
4776#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
4777#ifndef REAL_INFINITY
4778 if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
4779 return t;
4780#endif
4781#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4782
4783 /* In IEEE floating point, x/1 is not equivalent to x for snans.
4784 However, ANSI says we can drop signals, so we can do this anyway. */
4785 if (real_onep (arg1))
4786 return non_lvalue (convert (type, arg0));
4787
4788 /* If ARG1 is a constant, we can convert this to a multiply by the
4789 reciprocal. This does not have the same rounding properties,
4790 so only do this if -ffast-math. We can actually always safely
4791 do it if ARG1 is a power of two, but it's hard to tell if it is
4792 or not in a portable manner. */
4793 if (TREE_CODE (arg1) == REAL_CST)
4794 {
4795 if (flag_fast_math
4796 && 0 != (tem = const_binop (code, build_real (type, dconst1),
4797 arg1, 0)))
4798 return fold (build (MULT_EXPR, type, arg0, tem));
4799 /* Find the reciprocal if optimizing and the result is exact. */
4800 else if (optimize)
4801 {
4802 REAL_VALUE_TYPE r;
4803 r = TREE_REAL_CST (arg1);
4804 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
4805 {
4806 tem = build_real (type, r);
4807 return fold (build (MULT_EXPR, type, arg0, tem));
4808 }
4809 }
4810 }
4811 goto binary;
4812
4813 case TRUNC_DIV_EXPR:
4814 case ROUND_DIV_EXPR:
4815 case FLOOR_DIV_EXPR:
4816 case CEIL_DIV_EXPR:
4817 case EXACT_DIV_EXPR:
4818 if (integer_onep (arg1))
4819 return non_lvalue (convert (type, arg0));
4820 if (integer_zerop (arg1))
4821 return t;
4822
4823 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
4824 operation, EXACT_DIV_EXPR.
4825
4826 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
4827 At one time others generated faster code, it's not clear if they do
4828 after the last round to changes to the DIV code in expmed.c. */
4829 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
4830 && multiple_of_p (type, arg0, arg1))
4831 return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
4832
4833 /* If we have ((a / C1) / C2) where both division are the same type, try
4834 to simplify. First see if C1 * C2 overflows or not. */
4835 if (TREE_CODE (arg0) == code && TREE_CODE (arg1) == INTEGER_CST
4836 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
4837 {
4838 tree new_divisor;
4839
4840 new_divisor = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 1), arg1, 0);
4841 tem = const_binop (FLOOR_DIV_EXPR, new_divisor, arg1, 0);
4842
4843 if (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_LOW (tem)
4844 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_HIGH (tem))
4845 {
4846 /* If no overflow, divide by C1*C2. */
4847 return fold (build (code, type, TREE_OPERAND (arg0, 0), new_divisor));
4848 }
4849 }
4850
4851 /* Look for ((a * C1) / C3) or (((a * C1) + C2) / C3),
4852 where C1 % C3 == 0 or C3 % C1 == 0. We can simplify these
4853 expressions, which often appear in the offsets or sizes of
4854 objects with a varying size. Only deal with positive divisors
4855 and multiplicands. If C2 is negative, we must have C2 % C3 == 0.
4856
4857 Look for NOPs and SAVE_EXPRs inside. */
4858
4859 if (TREE_CODE (arg1) == INTEGER_CST
4860 && tree_int_cst_sgn (arg1) >= 0)
4861 {
4862 int have_save_expr = 0;
4863 tree c2 = integer_zero_node;
4864 tree xarg0 = arg0;
4865
4866 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
4867 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
4868
4869 STRIP_NOPS (xarg0);
4870
4871 /* Look inside the dividend and simplify using EXACT_DIV_EXPR
4872 if possible. */
4873 if (TREE_CODE (xarg0) == MULT_EXPR
4874 && multiple_of_p (type, TREE_OPERAND (xarg0, 0), arg1))
4875 {
4876 tree t;
4877
4878 t = fold (build (MULT_EXPR, type,
4879 fold (build (EXACT_DIV_EXPR, type,
4880 TREE_OPERAND (xarg0, 0), arg1)),
4881 TREE_OPERAND (xarg0, 1)));
4882 if (have_save_expr)
4883 t = save_expr (t);
4884 return t;
4885
4886 }
4887
4888 if (TREE_CODE (xarg0) == MULT_EXPR
4889 && multiple_of_p (type, TREE_OPERAND (xarg0, 1), arg1))
4890 {
4891 tree t;
4892
4893 t = fold (build (MULT_EXPR, type,
4894 fold (build (EXACT_DIV_EXPR, type,
4895 TREE_OPERAND (xarg0, 1), arg1)),
4896 TREE_OPERAND (xarg0, 0)));
4897 if (have_save_expr)
4898 t = save_expr (t);
4899 return t;
4900 }
4901
4902 if (TREE_CODE (xarg0) == PLUS_EXPR
4903 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
4904 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
4905 else if (TREE_CODE (xarg0) == MINUS_EXPR
4906 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4907 /* If we are doing this computation unsigned, the negate
4908 is incorrect. */
4909 && ! TREE_UNSIGNED (type))
4910 {
4911 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
4912 xarg0 = TREE_OPERAND (xarg0, 0);
4913 }
4914
4915 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
4916 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
4917
4918 STRIP_NOPS (xarg0);
4919
4920 if (TREE_CODE (xarg0) == MULT_EXPR
4921 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4922 && tree_int_cst_sgn (TREE_OPERAND (xarg0, 1)) >= 0
4923 && (integer_zerop (const_binop (TRUNC_MOD_EXPR,
4924 TREE_OPERAND (xarg0, 1), arg1, 1))
4925 || integer_zerop (const_binop (TRUNC_MOD_EXPR, arg1,
4926 TREE_OPERAND (xarg0, 1), 1)))
4927 && (tree_int_cst_sgn (c2) >= 0
4928 || integer_zerop (const_binop (TRUNC_MOD_EXPR, c2,
4929 arg1, 1))))
4930 {
4931 tree outer_div = integer_one_node;
4932 tree c1 = TREE_OPERAND (xarg0, 1);
4933 tree c3 = arg1;
4934
4935 /* If C3 > C1, set them equal and do a divide by
4936 C3/C1 at the end of the operation. */
4937 if (tree_int_cst_lt (c1, c3))
4938 outer_div = const_binop (code, c3, c1, 0), c3 = c1;
4939
4940 /* The result is A * (C1/C3) + (C2/C3). */
4941 t = fold (build (PLUS_EXPR, type,
4942 fold (build (MULT_EXPR, type,
4943 TREE_OPERAND (xarg0, 0),
4944 const_binop (code, c1, c3, 1))),
4945 const_binop (code, c2, c3, 1)));
4946
4947 if (! integer_onep (outer_div))
4948 t = fold (build (code, type, t, convert (type, outer_div)));
4949
4950 if (have_save_expr)
4951 t = save_expr (t);
4952
4953 return t;
4954 }
4955 }
4956
4957 goto binary;
4958
4959 case CEIL_MOD_EXPR:
4960 case FLOOR_MOD_EXPR:
4961 case ROUND_MOD_EXPR:
4962 case TRUNC_MOD_EXPR:
4963 if (integer_onep (arg1))
4964 return omit_one_operand (type, integer_zero_node, arg0);
4965 if (integer_zerop (arg1))
4966 return t;
4967
4968 /* Look for ((a * C1) % C3) or (((a * C1) + C2) % C3),
4969 where C1 % C3 == 0. Handle similarly to the division case,
4970 but don't bother with SAVE_EXPRs. */
4971
4972 if (TREE_CODE (arg1) == INTEGER_CST
4973 && ! integer_zerop (arg1))
4974 {
4975 tree c2 = integer_zero_node;
4976 tree xarg0 = arg0;
4977
4978 if (TREE_CODE (xarg0) == PLUS_EXPR
4979 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
4980 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
4981 else if (TREE_CODE (xarg0) == MINUS_EXPR
4982 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4983 && ! TREE_UNSIGNED (type))
4984 {
4985 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
4986 xarg0 = TREE_OPERAND (xarg0, 0);
4987 }
4988
4989 STRIP_NOPS (xarg0);
4990
4991 if (TREE_CODE (xarg0) == MULT_EXPR
4992 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4993 && integer_zerop (const_binop (TRUNC_MOD_EXPR,
4994 TREE_OPERAND (xarg0, 1),
4995 arg1, 1))
4996 && tree_int_cst_sgn (c2) >= 0)
4997 /* The result is (C2%C3). */
4998 return omit_one_operand (type, const_binop (code, c2, arg1, 1),
4999 TREE_OPERAND (xarg0, 0));
5000 }
5001
5002 goto binary;
5003
5004 case LSHIFT_EXPR:
5005 case RSHIFT_EXPR:
5006 case LROTATE_EXPR:
5007 case RROTATE_EXPR:
5008 if (integer_zerop (arg1))
5009 return non_lvalue (convert (type, arg0));
5010 /* Since negative shift count is not well-defined,
5011 don't try to compute it in the compiler. */
5012 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5013 return t;
5014 /* Rewrite an LROTATE_EXPR by a constant into an
5015 RROTATE_EXPR by a new constant. */
5016 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5017 {
5018 TREE_SET_CODE (t, RROTATE_EXPR);
5019 code = RROTATE_EXPR;
5020 TREE_OPERAND (t, 1) = arg1
5021 = const_binop
5022 (MINUS_EXPR,
5023 convert (TREE_TYPE (arg1),
5024 build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5025 arg1, 0);
5026 if (tree_int_cst_sgn (arg1) < 0)
5027 return t;
5028 }
5029
5030 /* If we have a rotate of a bit operation with the rotate count and
5031 the second operand of the bit operation both constant,
5032 permute the two operations. */
5033 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5034 && (TREE_CODE (arg0) == BIT_AND_EXPR
5035 || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5036 || TREE_CODE (arg0) == BIT_IOR_EXPR
5037 || TREE_CODE (arg0) == BIT_XOR_EXPR)
5038 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5039 return fold (build (TREE_CODE (arg0), type,
5040 fold (build (code, type,
5041 TREE_OPERAND (arg0, 0), arg1)),
5042 fold (build (code, type,
5043 TREE_OPERAND (arg0, 1), arg1))));
5044
5045 /* Two consecutive rotates adding up to the width of the mode can
5046 be ignored. */
5047 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5048 && TREE_CODE (arg0) == RROTATE_EXPR
5049 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5050 && TREE_INT_CST_HIGH (arg1) == 0
5051 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5052 && ((TREE_INT_CST_LOW (arg1)
5053 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5054 == GET_MODE_BITSIZE (TYPE_MODE (type))))
5055 return TREE_OPERAND (arg0, 0);
5056
5057 goto binary;
5058
5059 case MIN_EXPR:
5060 if (operand_equal_p (arg0, arg1, 0))
5061 return arg0;
5062 if (INTEGRAL_TYPE_P (type)
5063 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5064 return omit_one_operand (type, arg1, arg0);
5065 goto associate;
5066
5067 case MAX_EXPR:
5068 if (operand_equal_p (arg0, arg1, 0))
5069 return arg0;
5070 if (INTEGRAL_TYPE_P (type)
5071 && TYPE_MAX_VALUE (type)
5072 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5073 return omit_one_operand (type, arg1, arg0);
5074 goto associate;
5075
5076 case TRUTH_NOT_EXPR:
5077 /* Note that the operand of this must be an int
5078 and its values must be 0 or 1.
5079 ("true" is a fixed value perhaps depending on the language,
5080 but we don't handle values other than 1 correctly yet.) */
5081 tem = invert_truthvalue (arg0);
5082 /* Avoid infinite recursion. */
5083 if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5084 return t;
5085 return convert (type, tem);
5086
5087 case TRUTH_ANDIF_EXPR:
5088 /* Note that the operands of this must be ints
5089 and their values must be 0 or 1.
5090 ("true" is a fixed value perhaps depending on the language.) */
5091 /* If first arg is constant zero, return it. */
5092 if (integer_zerop (arg0))
5093 return arg0;
5094 case TRUTH_AND_EXPR:
5095 /* If either arg is constant true, drop it. */
5096 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5097 return non_lvalue (arg1);
5098 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5099 return non_lvalue (arg0);
5100 /* If second arg is constant zero, result is zero, but first arg
5101 must be evaluated. */
5102 if (integer_zerop (arg1))
5103 return omit_one_operand (type, arg1, arg0);
5104 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5105 case will be handled here. */
5106 if (integer_zerop (arg0))
5107 return omit_one_operand (type, arg0, arg1);
5108
5109 truth_andor:
5110 /* We only do these simplifications if we are optimizing. */
5111 if (!optimize)
5112 return t;
5113
5114 /* Check for things like (A || B) && (A || C). We can convert this
5115 to A || (B && C). Note that either operator can be any of the four
5116 truth and/or operations and the transformation will still be
5117 valid. Also note that we only care about order for the
5118 ANDIF and ORIF operators. If B contains side effects, this
5119 might change the truth-value of A. */
5120 if (TREE_CODE (arg0) == TREE_CODE (arg1)
5121 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5122 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5123 || TREE_CODE (arg0) == TRUTH_AND_EXPR
5124 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5125 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5126 {
5127 tree a00 = TREE_OPERAND (arg0, 0);
5128 tree a01 = TREE_OPERAND (arg0, 1);
5129 tree a10 = TREE_OPERAND (arg1, 0);
5130 tree a11 = TREE_OPERAND (arg1, 1);
5131 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5132 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5133 && (code == TRUTH_AND_EXPR
5134 || code == TRUTH_OR_EXPR));
5135
5136 if (operand_equal_p (a00, a10, 0))
5137 return fold (build (TREE_CODE (arg0), type, a00,
5138 fold (build (code, type, a01, a11))));
5139 else if (commutative && operand_equal_p (a00, a11, 0))
5140 return fold (build (TREE_CODE (arg0), type, a00,
5141 fold (build (code, type, a01, a10))));
5142 else if (commutative && operand_equal_p (a01, a10, 0))
5143 return fold (build (TREE_CODE (arg0), type, a01,
5144 fold (build (code, type, a00, a11))));
5145
5146 /* This case if tricky because we must either have commutative
5147 operators or else A10 must not have side-effects. */
5148
5149 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5150 && operand_equal_p (a01, a11, 0))
5151 return fold (build (TREE_CODE (arg0), type,
5152 fold (build (code, type, a00, a10)),
5153 a01));
5154 }
5155
5156 /* See if we can build a range comparison. */
5157 if (0 != (tem = fold_range_test (t)))
5158 return tem;
5159
5160 /* Check for the possibility of merging component references. If our
5161 lhs is another similar operation, try to merge its rhs with our
5162 rhs. Then try to merge our lhs and rhs. */
5163 if (TREE_CODE (arg0) == code
5164 && 0 != (tem = fold_truthop (code, type,
5165 TREE_OPERAND (arg0, 1), arg1)))
5166 return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5167
5168 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5169 return tem;
5170
5171 return t;
5172
5173 case TRUTH_ORIF_EXPR:
5174 /* Note that the operands of this must be ints
5175 and their values must be 0 or true.
5176 ("true" is a fixed value perhaps depending on the language.) */
5177 /* If first arg is constant true, return it. */
5178 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5179 return arg0;
5180 case TRUTH_OR_EXPR:
5181 /* If either arg is constant zero, drop it. */
5182 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5183 return non_lvalue (arg1);
5184 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
5185 return non_lvalue (arg0);
5186 /* If second arg is constant true, result is true, but we must
5187 evaluate first arg. */
5188 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5189 return omit_one_operand (type, arg1, arg0);
5190 /* Likewise for first arg, but note this only occurs here for
5191 TRUTH_OR_EXPR. */
5192 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5193 return omit_one_operand (type, arg0, arg1);
5194 goto truth_andor;
5195
5196 case TRUTH_XOR_EXPR:
5197 /* If either arg is constant zero, drop it. */
5198 if (integer_zerop (arg0))
5199 return non_lvalue (arg1);
5200 if (integer_zerop (arg1))
5201 return non_lvalue (arg0);
5202 /* If either arg is constant true, this is a logical inversion. */
5203 if (integer_onep (arg0))
5204 return non_lvalue (invert_truthvalue (arg1));
5205 if (integer_onep (arg1))
5206 return non_lvalue (invert_truthvalue (arg0));
5207 return t;
5208
5209 case EQ_EXPR:
5210 case NE_EXPR:
5211 case LT_EXPR:
5212 case GT_EXPR:
5213 case LE_EXPR:
5214 case GE_EXPR:
5215 /* If one arg is a constant integer, put it last. */
5216 if (TREE_CODE (arg0) == INTEGER_CST
5217 && TREE_CODE (arg1) != INTEGER_CST)
5218 {
5219 TREE_OPERAND (t, 0) = arg1;
5220 TREE_OPERAND (t, 1) = arg0;
5221 arg0 = TREE_OPERAND (t, 0);
5222 arg1 = TREE_OPERAND (t, 1);
5223 code = swap_tree_comparison (code);
5224 TREE_SET_CODE (t, code);
5225 }
5226
5227 /* Convert foo++ == CONST into ++foo == CONST + INCR.
5228 First, see if one arg is constant; find the constant arg
5229 and the other one. */
5230 {
5231 tree constop = 0, varop = NULL_TREE;
5232 int constopnum = -1;
5233
5234 if (TREE_CONSTANT (arg1))
5235 constopnum = 1, constop = arg1, varop = arg0;
5236 if (TREE_CONSTANT (arg0))
5237 constopnum = 0, constop = arg0, varop = arg1;
5238
5239 if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5240 {
5241 /* This optimization is invalid for ordered comparisons
5242 if CONST+INCR overflows or if foo+incr might overflow.
5243 This optimization is invalid for floating point due to rounding.
5244 For pointer types we assume overflow doesn't happen. */
5245 if (POINTER_TYPE_P (TREE_TYPE (varop))
5246 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5247 && (code == EQ_EXPR || code == NE_EXPR)))
5248 {
5249 tree newconst
5250 = fold (build (PLUS_EXPR, TREE_TYPE (varop),
5251 constop, TREE_OPERAND (varop, 1)));
5252 TREE_SET_CODE (varop, PREINCREMENT_EXPR);
5253
5254 /* If VAROP is a reference to a bitfield, we must mask
5255 the constant by the width of the field. */
5256 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5257 && DECL_BIT_FIELD(TREE_OPERAND
5258 (TREE_OPERAND (varop, 0), 1)))
5259 {
5260 int size
5261 = TREE_INT_CST_LOW (DECL_SIZE
5262 (TREE_OPERAND
5263 (TREE_OPERAND (varop, 0), 1)));
5264 tree mask, unsigned_type;
5265 int precision;
5266 tree folded_compare;
5267
5268 /* First check whether the comparison would come out
5269 always the same. If we don't do that we would
5270 change the meaning with the masking. */
5271 if (constopnum == 0)
5272 folded_compare = fold (build (code, type, constop,
5273 TREE_OPERAND (varop, 0)));
5274 else
5275 folded_compare = fold (build (code, type,
5276 TREE_OPERAND (varop, 0),
5277 constop));
5278 if (integer_zerop (folded_compare)
5279 || integer_onep (folded_compare))
5280 return omit_one_operand (type, folded_compare, varop);
5281
5282 unsigned_type = type_for_size (size, 1);
5283 precision = TYPE_PRECISION (unsigned_type);
5284 mask = build_int_2 (~0, ~0);
5285 TREE_TYPE (mask) = unsigned_type;
5286 force_fit_type (mask, 0);
5287 mask = const_binop (RSHIFT_EXPR, mask,
5288 size_int (precision - size), 0);
5289 newconst = fold (build (BIT_AND_EXPR,
5290 TREE_TYPE (varop), newconst,
5291 convert (TREE_TYPE (varop),
5292 mask)));
5293 }
5294
5295
5296 t = build (code, type, TREE_OPERAND (t, 0),
5297 TREE_OPERAND (t, 1));
5298 TREE_OPERAND (t, constopnum) = newconst;
5299 return t;
5300 }
5301 }
5302 else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
5303 {
5304 if (POINTER_TYPE_P (TREE_TYPE (varop))
5305 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5306 && (code == EQ_EXPR || code == NE_EXPR)))
5307 {
5308 tree newconst
5309 = fold (build (MINUS_EXPR, TREE_TYPE (varop),
5310 constop, TREE_OPERAND (varop, 1)));
5311 TREE_SET_CODE (varop, PREDECREMENT_EXPR);
5312
5313 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5314 && DECL_BIT_FIELD(TREE_OPERAND
5315 (TREE_OPERAND (varop, 0), 1)))
5316 {
5317 int size
5318 = TREE_INT_CST_LOW (DECL_SIZE
5319 (TREE_OPERAND
5320 (TREE_OPERAND (varop, 0), 1)));
5321 tree mask, unsigned_type;
5322 int precision;
5323 tree folded_compare;
5324
5325 if (constopnum == 0)
5326 folded_compare = fold (build (code, type, constop,
5327 TREE_OPERAND (varop, 0)));
5328 else
5329 folded_compare = fold (build (code, type,
5330 TREE_OPERAND (varop, 0),
5331 constop));
5332 if (integer_zerop (folded_compare)
5333 || integer_onep (folded_compare))
5334 return omit_one_operand (type, folded_compare, varop);
5335
5336 unsigned_type = type_for_size (size, 1);
5337 precision = TYPE_PRECISION (unsigned_type);
5338 mask = build_int_2 (~0, ~0);
5339 TREE_TYPE (mask) = TREE_TYPE (varop);
5340 force_fit_type (mask, 0);
5341 mask = const_binop (RSHIFT_EXPR, mask,
5342 size_int (precision - size), 0);
5343 newconst = fold (build (BIT_AND_EXPR,
5344 TREE_TYPE (varop), newconst,
5345 convert (TREE_TYPE (varop),
5346 mask)));
5347 }
5348
5349
5350 t = build (code, type, TREE_OPERAND (t, 0),
5351 TREE_OPERAND (t, 1));
5352 TREE_OPERAND (t, constopnum) = newconst;
5353 return t;
5354 }
5355 }
5356 }
5357
5358 /* Change X >= CST to X > (CST - 1) if CST is positive. */
5359 if (TREE_CODE (arg1) == INTEGER_CST
5360 && TREE_CODE (arg0) != INTEGER_CST
5361 && tree_int_cst_sgn (arg1) > 0)
5362 {
5363 switch (TREE_CODE (t))
5364 {
5365 case GE_EXPR:
5366 code = GT_EXPR;
5367 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
5368 t = build (code, type, TREE_OPERAND (t, 0), arg1);
5369 break;
5370
5371 case LT_EXPR:
5372 code = LE_EXPR;
5373 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
5374 t = build (code, type, TREE_OPERAND (t, 0), arg1);
5375 break;
5376
5377 default:
5378 break;
5379 }
5380 }
5381
5382 /* If this is an EQ or NE comparison with zero and ARG0 is
5383 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
5384 two operations, but the latter can be done in one less insn
5385 on machines that have only two-operand insns or on which a
5386 constant cannot be the first operand. */
5387 if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
5388 && TREE_CODE (arg0) == BIT_AND_EXPR)
5389 {
5390 if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
5391 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
5392 return
5393 fold (build (code, type,
5394 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5395 build (RSHIFT_EXPR,
5396 TREE_TYPE (TREE_OPERAND (arg0, 0)),
5397 TREE_OPERAND (arg0, 1),
5398 TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
5399 convert (TREE_TYPE (arg0),
5400 integer_one_node)),
5401 arg1));
5402 else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
5403 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
5404 return
5405 fold (build (code, type,
5406 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5407 build (RSHIFT_EXPR,
5408 TREE_TYPE (TREE_OPERAND (arg0, 1)),
5409 TREE_OPERAND (arg0, 0),
5410 TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
5411 convert (TREE_TYPE (arg0),
5412 integer_one_node)),
5413 arg1));
5414 }
5415
5416 /* If this is an NE or EQ comparison of zero against the result of a
5417 signed MOD operation whose second operand is a power of 2, make
5418 the MOD operation unsigned since it is simpler and equivalent. */
5419 if ((code == NE_EXPR || code == EQ_EXPR)
5420 && integer_zerop (arg1)
5421 && ! TREE_UNSIGNED (TREE_TYPE (arg0))
5422 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
5423 || TREE_CODE (arg0) == CEIL_MOD_EXPR
5424 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
5425 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
5426 && integer_pow2p (TREE_OPERAND (arg0, 1)))
5427 {
5428 tree newtype = unsigned_type (TREE_TYPE (arg0));
5429 tree newmod = build (TREE_CODE (arg0), newtype,
5430 convert (newtype, TREE_OPERAND (arg0, 0)),
5431 convert (newtype, TREE_OPERAND (arg0, 1)));
5432
5433 return build (code, type, newmod, convert (newtype, arg1));
5434 }
5435
5436 /* If this is an NE comparison of zero with an AND of one, remove the
5437 comparison since the AND will give the correct value. */
5438 if (code == NE_EXPR && integer_zerop (arg1)
5439 && TREE_CODE (arg0) == BIT_AND_EXPR
5440 && integer_onep (TREE_OPERAND (arg0, 1)))
5441 return convert (type, arg0);
5442
5443 /* If we have (A & C) == C where C is a power of 2, convert this into
5444 (A & C) != 0. Similarly for NE_EXPR. */
5445 if ((code == EQ_EXPR || code == NE_EXPR)
5446 && TREE_CODE (arg0) == BIT_AND_EXPR
5447 && integer_pow2p (TREE_OPERAND (arg0, 1))
5448 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
5449 return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
5450 arg0, integer_zero_node);
5451
5452 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
5453 and similarly for >= into !=. */
5454 if ((code == LT_EXPR || code == GE_EXPR)
5455 && TREE_UNSIGNED (TREE_TYPE (arg0))
5456 && TREE_CODE (arg1) == LSHIFT_EXPR
5457 && integer_onep (TREE_OPERAND (arg1, 0)))
5458 return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5459 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5460 TREE_OPERAND (arg1, 1)),
5461 convert (TREE_TYPE (arg0), integer_zero_node));
5462
5463 else if ((code == LT_EXPR || code == GE_EXPR)
5464 && TREE_UNSIGNED (TREE_TYPE (arg0))
5465 && (TREE_CODE (arg1) == NOP_EXPR
5466 || TREE_CODE (arg1) == CONVERT_EXPR)
5467 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
5468 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
5469 return
5470 build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5471 convert (TREE_TYPE (arg0),
5472 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5473 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
5474 convert (TREE_TYPE (arg0), integer_zero_node));
5475
5476 /* Simplify comparison of something with itself. (For IEEE
5477 floating-point, we can only do some of these simplifications.) */
5478 if (operand_equal_p (arg0, arg1, 0))
5479 {
5480 switch (code)
5481 {
5482 case EQ_EXPR:
5483 case GE_EXPR:
5484 case LE_EXPR:
5485 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5486 return constant_boolean_node (1, type);
5487 code = EQ_EXPR;
5488 TREE_SET_CODE (t, code);
5489 break;
5490
5491 case NE_EXPR:
5492 /* For NE, we can only do this simplification if integer. */
5493 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5494 break;
5495 /* ... fall through ... */
5496 case GT_EXPR:
5497 case LT_EXPR:
5498 return constant_boolean_node (0, type);
5499 default:
5500 abort ();
5501 }
5502 }
5503
5504 /* An unsigned comparison against 0 can be simplified. */
5505 if (integer_zerop (arg1)
5506 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
5507 || POINTER_TYPE_P (TREE_TYPE (arg1)))
5508 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5509 {
5510 switch (TREE_CODE (t))
5511 {
5512 case GT_EXPR:
5513 code = NE_EXPR;
5514 TREE_SET_CODE (t, NE_EXPR);
5515 break;
5516 case LE_EXPR:
5517 code = EQ_EXPR;
5518 TREE_SET_CODE (t, EQ_EXPR);
5519 break;
5520 case GE_EXPR:
5521 return omit_one_operand (type,
5522 convert (type, integer_one_node),
5523 arg0);
5524 case LT_EXPR:
5525 return omit_one_operand (type,
5526 convert (type, integer_zero_node),
5527 arg0);
5528 default:
5529 break;
5530 }
5531 }
5532
5533 /* An unsigned <= 0x7fffffff can be simplified. */
5534 {
5535 int width = TYPE_PRECISION (TREE_TYPE (arg1));
5536 if (TREE_CODE (arg1) == INTEGER_CST
5537 && ! TREE_CONSTANT_OVERFLOW (arg1)
5538 && width <= HOST_BITS_PER_WIDE_INT
5539 && TREE_INT_CST_LOW (arg1) == ((HOST_WIDE_INT) 1 << (width - 1)) - 1
5540 && TREE_INT_CST_HIGH (arg1) == 0
5541 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
5542 || POINTER_TYPE_P (TREE_TYPE (arg1)))
5543 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5544 {
5545 switch (TREE_CODE (t))
5546 {
5547 case LE_EXPR:
5548 return fold (build (GE_EXPR, type,
5549 convert (signed_type (TREE_TYPE (arg0)),
5550 arg0),
5551 convert (signed_type (TREE_TYPE (arg1)),
5552 integer_zero_node)));
5553 case GT_EXPR:
5554 return fold (build (LT_EXPR, type,
5555 convert (signed_type (TREE_TYPE (arg0)),
5556 arg0),
5557 convert (signed_type (TREE_TYPE (arg1)),
5558 integer_zero_node)));
5559 default:
5560 break;
5561 }
5562 }
5563 }
5564
5565 /* If we are comparing an expression that just has comparisons
5566 of two integer values, arithmetic expressions of those comparisons,
5567 and constants, we can simplify it. There are only three cases
5568 to check: the two values can either be equal, the first can be
5569 greater, or the second can be greater. Fold the expression for
5570 those three values. Since each value must be 0 or 1, we have
5571 eight possibilities, each of which corresponds to the constant 0
5572 or 1 or one of the six possible comparisons.
5573
5574 This handles common cases like (a > b) == 0 but also handles
5575 expressions like ((x > y) - (y > x)) > 0, which supposedly
5576 occur in macroized code. */
5577
5578 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
5579 {
5580 tree cval1 = 0, cval2 = 0;
5581 int save_p = 0;
5582
5583 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
5584 /* Don't handle degenerate cases here; they should already
5585 have been handled anyway. */
5586 && cval1 != 0 && cval2 != 0
5587 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
5588 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
5589 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
5590 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
5591 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
5592 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
5593 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
5594 {
5595 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
5596 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
5597
5598 /* We can't just pass T to eval_subst in case cval1 or cval2
5599 was the same as ARG1. */
5600
5601 tree high_result
5602 = fold (build (code, type,
5603 eval_subst (arg0, cval1, maxval, cval2, minval),
5604 arg1));
5605 tree equal_result
5606 = fold (build (code, type,
5607 eval_subst (arg0, cval1, maxval, cval2, maxval),
5608 arg1));
5609 tree low_result
5610 = fold (build (code, type,
5611 eval_subst (arg0, cval1, minval, cval2, maxval),
5612 arg1));
5613
5614 /* All three of these results should be 0 or 1. Confirm they
5615 are. Then use those values to select the proper code
5616 to use. */
5617
5618 if ((integer_zerop (high_result)
5619 || integer_onep (high_result))
5620 && (integer_zerop (equal_result)
5621 || integer_onep (equal_result))
5622 && (integer_zerop (low_result)
5623 || integer_onep (low_result)))
5624 {
5625 /* Make a 3-bit mask with the high-order bit being the
5626 value for `>', the next for '=', and the low for '<'. */
5627 switch ((integer_onep (high_result) * 4)
5628 + (integer_onep (equal_result) * 2)
5629 + integer_onep (low_result))
5630 {
5631 case 0:
5632 /* Always false. */
5633 return omit_one_operand (type, integer_zero_node, arg0);
5634 case 1:
5635 code = LT_EXPR;
5636 break;
5637 case 2:
5638 code = EQ_EXPR;
5639 break;
5640 case 3:
5641 code = LE_EXPR;
5642 break;
5643 case 4:
5644 code = GT_EXPR;
5645 break;
5646 case 5:
5647 code = NE_EXPR;
5648 break;
5649 case 6:
5650 code = GE_EXPR;
5651 break;
5652 case 7:
5653 /* Always true. */
5654 return omit_one_operand (type, integer_one_node, arg0);
5655 }
5656
5657 t = build (code, type, cval1, cval2);
5658 if (save_p)
5659 return save_expr (t);
5660 else
5661 return fold (t);
5662 }
5663 }
5664 }
5665
5666 /* If this is a comparison of a field, we may be able to simplify it. */
5667 if ((TREE_CODE (arg0) == COMPONENT_REF
5668 || TREE_CODE (arg0) == BIT_FIELD_REF)
5669 && (code == EQ_EXPR || code == NE_EXPR)
5670 /* Handle the constant case even without -O
5671 to make sure the warnings are given. */
5672 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
5673 {
5674 t1 = optimize_bit_field_compare (code, type, arg0, arg1);
5675 return t1 ? t1 : t;
5676 }
5677
5678 /* If this is a comparison of complex values and either or both sides
5679 are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
5680 comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
5681 This may prevent needless evaluations. */
5682 if ((code == EQ_EXPR || code == NE_EXPR)
5683 && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
5684 && (TREE_CODE (arg0) == COMPLEX_EXPR
5685 || TREE_CODE (arg1) == COMPLEX_EXPR
5686 || TREE_CODE (arg0) == COMPLEX_CST
5687 || TREE_CODE (arg1) == COMPLEX_CST))
5688 {
5689 tree subtype = TREE_TYPE (TREE_TYPE (arg0));
5690 tree real0, imag0, real1, imag1;
5691
5692 arg0 = save_expr (arg0);
5693 arg1 = save_expr (arg1);
5694 real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
5695 imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
5696 real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
5697 imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
5698
5699 return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
5700 : TRUTH_ORIF_EXPR),
5701 type,
5702 fold (build (code, type, real0, real1)),
5703 fold (build (code, type, imag0, imag1))));
5704 }
5705
5706 /* From here on, the only cases we handle are when the result is
5707 known to be a constant.
5708
5709 To compute GT, swap the arguments and do LT.
5710 To compute GE, do LT and invert the result.
5711 To compute LE, swap the arguments, do LT and invert the result.
5712 To compute NE, do EQ and invert the result.
5713
5714 Therefore, the code below must handle only EQ and LT. */
5715
5716 if (code == LE_EXPR || code == GT_EXPR)
5717 {
5718 tem = arg0, arg0 = arg1, arg1 = tem;
5719 code = swap_tree_comparison (code);
5720 }
5721
5722 /* Note that it is safe to invert for real values here because we
5723 will check below in the one case that it matters. */
5724
5725 invert = 0;
5726 if (code == NE_EXPR || code == GE_EXPR)
5727 {
5728 invert = 1;
5729 code = invert_tree_comparison (code);
5730 }
5731
5732 /* Compute a result for LT or EQ if args permit;
5733 otherwise return T. */
5734 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
5735 {
5736 if (code == EQ_EXPR)
5737 t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
5738 == TREE_INT_CST_LOW (arg1))
5739 && (TREE_INT_CST_HIGH (arg0)
5740 == TREE_INT_CST_HIGH (arg1)),
5741 0);
5742 else
5743 t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
5744 ? INT_CST_LT_UNSIGNED (arg0, arg1)
5745 : INT_CST_LT (arg0, arg1)),
5746 0);
5747 }
5748
5749#if 0 /* This is no longer useful, but breaks some real code. */
5750 /* Assume a nonexplicit constant cannot equal an explicit one,
5751 since such code would be undefined anyway.
5752 Exception: on sysvr4, using #pragma weak,
5753 a label can come out as 0. */
5754 else if (TREE_CODE (arg1) == INTEGER_CST
5755 && !integer_zerop (arg1)
5756 && TREE_CONSTANT (arg0)
5757 && TREE_CODE (arg0) == ADDR_EXPR
5758 && code == EQ_EXPR)
5759 t1 = build_int_2 (0, 0);
5760#endif
5761 /* Two real constants can be compared explicitly. */
5762 else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
5763 {
5764 /* If either operand is a NaN, the result is false with two
5765 exceptions: First, an NE_EXPR is true on NaNs, but that case
5766 is already handled correctly since we will be inverting the
5767 result for NE_EXPR. Second, if we had inverted a LE_EXPR
5768 or a GE_EXPR into a LT_EXPR, we must return true so that it
5769 will be inverted into false. */
5770
5771 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
5772 || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
5773 t1 = build_int_2 (invert && code == LT_EXPR, 0);
5774
5775 else if (code == EQ_EXPR)
5776 t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
5777 TREE_REAL_CST (arg1)),
5778 0);
5779 else
5780 t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
5781 TREE_REAL_CST (arg1)),
5782 0);
5783 }
5784
5785 if (t1 == NULL_TREE)
5786 return t;
5787
5788 if (invert)
5789 TREE_INT_CST_LOW (t1) ^= 1;
5790
5791 TREE_TYPE (t1) = type;
5792 if (TREE_CODE (type) == BOOLEAN_TYPE)
5793 return truthvalue_conversion (t1);
5794 return t1;
5795
5796 case COND_EXPR:
5797 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
5798 so all simple results must be passed through pedantic_non_lvalue. */
5799 if (TREE_CODE (arg0) == INTEGER_CST)
5800 return pedantic_non_lvalue
5801 (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
5802 else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
5803 return pedantic_omit_one_operand (type, arg1, arg0);
5804
5805 /* If the second operand is zero, invert the comparison and swap
5806 the second and third operands. Likewise if the second operand
5807 is constant and the third is not or if the third operand is
5808 equivalent to the first operand of the comparison. */
5809
5810 if (integer_zerop (arg1)
5811 || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
5812 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
5813 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
5814 TREE_OPERAND (t, 2),
5815 TREE_OPERAND (arg0, 1))))
5816 {
5817 /* See if this can be inverted. If it can't, possibly because
5818 it was a floating-point inequality comparison, don't do
5819 anything. */
5820 tem = invert_truthvalue (arg0);
5821
5822 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
5823 {
5824 t = build (code, type, tem,
5825 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
5826 arg0 = tem;
| 5089 }
5090
5091 goto associate;
5092 }
5093
5094 case BIT_XOR_EXPR:
5095 if (integer_zerop (arg1))
5096 return non_lvalue (convert (type, arg0));
5097 if (integer_all_onesp (arg1))
5098 return fold (build1 (BIT_NOT_EXPR, type, arg0));
5099 goto associate;
5100
5101 case BIT_AND_EXPR:
5102 bit_and:
5103 if (integer_all_onesp (arg1))
5104 return non_lvalue (convert (type, arg0));
5105 if (integer_zerop (arg1))
5106 return omit_one_operand (type, arg1, arg0);
5107 t1 = distribute_bit_expr (code, type, arg0, arg1);
5108 if (t1 != NULL_TREE)
5109 return t1;
5110 /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
5111 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
5112 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
5113 {
5114 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
5115 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5116 && (~TREE_INT_CST_LOW (arg0)
5117 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5118 return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
5119 }
5120 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
5121 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
5122 {
5123 int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
5124 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
5125 && (~TREE_INT_CST_LOW (arg1)
5126 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
5127 return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
5128 }
5129 goto associate;
5130
5131 case BIT_ANDTC_EXPR:
5132 if (integer_all_onesp (arg0))
5133 return non_lvalue (convert (type, arg1));
5134 if (integer_zerop (arg0))
5135 return omit_one_operand (type, arg0, arg1);
5136 if (TREE_CODE (arg1) == INTEGER_CST)
5137 {
5138 arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
5139 code = BIT_AND_EXPR;
5140 goto bit_and;
5141 }
5142 goto binary;
5143
5144 case RDIV_EXPR:
5145 /* In most cases, do nothing with a divide by zero. */
5146#if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
5147#ifndef REAL_INFINITY
5148 if (TREE_CODE (arg1) == REAL_CST && real_zerop (arg1))
5149 return t;
5150#endif
5151#endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
5152
5153 /* In IEEE floating point, x/1 is not equivalent to x for snans.
5154 However, ANSI says we can drop signals, so we can do this anyway. */
5155 if (real_onep (arg1))
5156 return non_lvalue (convert (type, arg0));
5157
5158 /* If ARG1 is a constant, we can convert this to a multiply by the
5159 reciprocal. This does not have the same rounding properties,
5160 so only do this if -ffast-math. We can actually always safely
5161 do it if ARG1 is a power of two, but it's hard to tell if it is
5162 or not in a portable manner. */
5163 if (TREE_CODE (arg1) == REAL_CST)
5164 {
5165 if (flag_fast_math
5166 && 0 != (tem = const_binop (code, build_real (type, dconst1),
5167 arg1, 0)))
5168 return fold (build (MULT_EXPR, type, arg0, tem));
5169 /* Find the reciprocal if optimizing and the result is exact. */
5170 else if (optimize)
5171 {
5172 REAL_VALUE_TYPE r;
5173 r = TREE_REAL_CST (arg1);
5174 if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
5175 {
5176 tem = build_real (type, r);
5177 return fold (build (MULT_EXPR, type, arg0, tem));
5178 }
5179 }
5180 }
5181 goto binary;
5182
5183 case TRUNC_DIV_EXPR:
5184 case ROUND_DIV_EXPR:
5185 case FLOOR_DIV_EXPR:
5186 case CEIL_DIV_EXPR:
5187 case EXACT_DIV_EXPR:
5188 if (integer_onep (arg1))
5189 return non_lvalue (convert (type, arg0));
5190 if (integer_zerop (arg1))
5191 return t;
5192
5193 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
5194 operation, EXACT_DIV_EXPR.
5195
5196 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
5197 At one time others generated faster code, it's not clear if they do
5198 after the last round to changes to the DIV code in expmed.c. */
5199 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
5200 && multiple_of_p (type, arg0, arg1))
5201 return fold (build (EXACT_DIV_EXPR, type, arg0, arg1));
5202
5203 /* If we have ((a / C1) / C2) where both division are the same type, try
5204 to simplify. First see if C1 * C2 overflows or not. */
5205 if (TREE_CODE (arg0) == code && TREE_CODE (arg1) == INTEGER_CST
5206 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5207 {
5208 tree new_divisor;
5209
5210 new_divisor = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 1), arg1, 0);
5211 tem = const_binop (FLOOR_DIV_EXPR, new_divisor, arg1, 0);
5212
5213 if (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_LOW (tem)
5214 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == TREE_INT_CST_HIGH (tem))
5215 {
5216 /* If no overflow, divide by C1*C2. */
5217 return fold (build (code, type, TREE_OPERAND (arg0, 0), new_divisor));
5218 }
5219 }
5220
5221 /* Look for ((a * C1) / C3) or (((a * C1) + C2) / C3),
5222 where C1 % C3 == 0 or C3 % C1 == 0. We can simplify these
5223 expressions, which often appear in the offsets or sizes of
5224 objects with a varying size. Only deal with positive divisors
5225 and multiplicands. If C2 is negative, we must have C2 % C3 == 0.
5226
5227 Look for NOPs and SAVE_EXPRs inside. */
5228
5229 if (TREE_CODE (arg1) == INTEGER_CST
5230 && tree_int_cst_sgn (arg1) >= 0)
5231 {
5232 int have_save_expr = 0;
5233 tree c2 = integer_zero_node;
5234 tree xarg0 = arg0;
5235
5236 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
5237 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
5238
5239 STRIP_NOPS (xarg0);
5240
5241 /* Look inside the dividend and simplify using EXACT_DIV_EXPR
5242 if possible. */
5243 if (TREE_CODE (xarg0) == MULT_EXPR
5244 && multiple_of_p (type, TREE_OPERAND (xarg0, 0), arg1))
5245 {
5246 tree t;
5247
5248 t = fold (build (MULT_EXPR, type,
5249 fold (build (EXACT_DIV_EXPR, type,
5250 TREE_OPERAND (xarg0, 0), arg1)),
5251 TREE_OPERAND (xarg0, 1)));
5252 if (have_save_expr)
5253 t = save_expr (t);
5254 return t;
5255
5256 }
5257
5258 if (TREE_CODE (xarg0) == MULT_EXPR
5259 && multiple_of_p (type, TREE_OPERAND (xarg0, 1), arg1))
5260 {
5261 tree t;
5262
5263 t = fold (build (MULT_EXPR, type,
5264 fold (build (EXACT_DIV_EXPR, type,
5265 TREE_OPERAND (xarg0, 1), arg1)),
5266 TREE_OPERAND (xarg0, 0)));
5267 if (have_save_expr)
5268 t = save_expr (t);
5269 return t;
5270 }
5271
5272 if (TREE_CODE (xarg0) == PLUS_EXPR
5273 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
5274 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
5275 else if (TREE_CODE (xarg0) == MINUS_EXPR
5276 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
5277 /* If we are doing this computation unsigned, the negate
5278 is incorrect. */
5279 && ! TREE_UNSIGNED (type))
5280 {
5281 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
5282 xarg0 = TREE_OPERAND (xarg0, 0);
5283 }
5284
5285 if (TREE_CODE (xarg0) == SAVE_EXPR && SAVE_EXPR_RTL (xarg0) == 0)
5286 have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
5287
5288 STRIP_NOPS (xarg0);
5289
5290 if (TREE_CODE (xarg0) == MULT_EXPR
5291 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
5292 && tree_int_cst_sgn (TREE_OPERAND (xarg0, 1)) >= 0
5293 && (integer_zerop (const_binop (TRUNC_MOD_EXPR,
5294 TREE_OPERAND (xarg0, 1), arg1, 1))
5295 || integer_zerop (const_binop (TRUNC_MOD_EXPR, arg1,
5296 TREE_OPERAND (xarg0, 1), 1)))
5297 && (tree_int_cst_sgn (c2) >= 0
5298 || integer_zerop (const_binop (TRUNC_MOD_EXPR, c2,
5299 arg1, 1))))
5300 {
5301 tree outer_div = integer_one_node;
5302 tree c1 = TREE_OPERAND (xarg0, 1);
5303 tree c3 = arg1;
5304
5305 /* If C3 > C1, set them equal and do a divide by
5306 C3/C1 at the end of the operation. */
5307 if (tree_int_cst_lt (c1, c3))
5308 outer_div = const_binop (code, c3, c1, 0), c3 = c1;
5309
5310 /* The result is A * (C1/C3) + (C2/C3). */
5311 t = fold (build (PLUS_EXPR, type,
5312 fold (build (MULT_EXPR, type,
5313 TREE_OPERAND (xarg0, 0),
5314 const_binop (code, c1, c3, 1))),
5315 const_binop (code, c2, c3, 1)));
5316
5317 if (! integer_onep (outer_div))
5318 t = fold (build (code, type, t, convert (type, outer_div)));
5319
5320 if (have_save_expr)
5321 t = save_expr (t);
5322
5323 return t;
5324 }
5325 }
5326
5327 goto binary;
5328
5329 case CEIL_MOD_EXPR:
5330 case FLOOR_MOD_EXPR:
5331 case ROUND_MOD_EXPR:
5332 case TRUNC_MOD_EXPR:
5333 if (integer_onep (arg1))
5334 return omit_one_operand (type, integer_zero_node, arg0);
5335 if (integer_zerop (arg1))
5336 return t;
5337
5338 /* Look for ((a * C1) % C3) or (((a * C1) + C2) % C3),
5339 where C1 % C3 == 0. Handle similarly to the division case,
5340 but don't bother with SAVE_EXPRs. */
5341
5342 if (TREE_CODE (arg1) == INTEGER_CST
5343 && ! integer_zerop (arg1))
5344 {
5345 tree c2 = integer_zero_node;
5346 tree xarg0 = arg0;
5347
5348 if (TREE_CODE (xarg0) == PLUS_EXPR
5349 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
5350 c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
5351 else if (TREE_CODE (xarg0) == MINUS_EXPR
5352 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
5353 && ! TREE_UNSIGNED (type))
5354 {
5355 c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
5356 xarg0 = TREE_OPERAND (xarg0, 0);
5357 }
5358
5359 STRIP_NOPS (xarg0);
5360
5361 if (TREE_CODE (xarg0) == MULT_EXPR
5362 && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
5363 && integer_zerop (const_binop (TRUNC_MOD_EXPR,
5364 TREE_OPERAND (xarg0, 1),
5365 arg1, 1))
5366 && tree_int_cst_sgn (c2) >= 0)
5367 /* The result is (C2%C3). */
5368 return omit_one_operand (type, const_binop (code, c2, arg1, 1),
5369 TREE_OPERAND (xarg0, 0));
5370 }
5371
5372 goto binary;
5373
5374 case LSHIFT_EXPR:
5375 case RSHIFT_EXPR:
5376 case LROTATE_EXPR:
5377 case RROTATE_EXPR:
5378 if (integer_zerop (arg1))
5379 return non_lvalue (convert (type, arg0));
5380 /* Since negative shift count is not well-defined,
5381 don't try to compute it in the compiler. */
5382 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
5383 return t;
5384 /* Rewrite an LROTATE_EXPR by a constant into an
5385 RROTATE_EXPR by a new constant. */
5386 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
5387 {
5388 TREE_SET_CODE (t, RROTATE_EXPR);
5389 code = RROTATE_EXPR;
5390 TREE_OPERAND (t, 1) = arg1
5391 = const_binop
5392 (MINUS_EXPR,
5393 convert (TREE_TYPE (arg1),
5394 build_int_2 (GET_MODE_BITSIZE (TYPE_MODE (type)), 0)),
5395 arg1, 0);
5396 if (tree_int_cst_sgn (arg1) < 0)
5397 return t;
5398 }
5399
5400 /* If we have a rotate of a bit operation with the rotate count and
5401 the second operand of the bit operation both constant,
5402 permute the two operations. */
5403 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5404 && (TREE_CODE (arg0) == BIT_AND_EXPR
5405 || TREE_CODE (arg0) == BIT_ANDTC_EXPR
5406 || TREE_CODE (arg0) == BIT_IOR_EXPR
5407 || TREE_CODE (arg0) == BIT_XOR_EXPR)
5408 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
5409 return fold (build (TREE_CODE (arg0), type,
5410 fold (build (code, type,
5411 TREE_OPERAND (arg0, 0), arg1)),
5412 fold (build (code, type,
5413 TREE_OPERAND (arg0, 1), arg1))));
5414
5415 /* Two consecutive rotates adding up to the width of the mode can
5416 be ignored. */
5417 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
5418 && TREE_CODE (arg0) == RROTATE_EXPR
5419 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5420 && TREE_INT_CST_HIGH (arg1) == 0
5421 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
5422 && ((TREE_INT_CST_LOW (arg1)
5423 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
5424 == GET_MODE_BITSIZE (TYPE_MODE (type))))
5425 return TREE_OPERAND (arg0, 0);
5426
5427 goto binary;
5428
5429 case MIN_EXPR:
5430 if (operand_equal_p (arg0, arg1, 0))
5431 return arg0;
5432 if (INTEGRAL_TYPE_P (type)
5433 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
5434 return omit_one_operand (type, arg1, arg0);
5435 goto associate;
5436
5437 case MAX_EXPR:
5438 if (operand_equal_p (arg0, arg1, 0))
5439 return arg0;
5440 if (INTEGRAL_TYPE_P (type)
5441 && TYPE_MAX_VALUE (type)
5442 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
5443 return omit_one_operand (type, arg1, arg0);
5444 goto associate;
5445
5446 case TRUTH_NOT_EXPR:
5447 /* Note that the operand of this must be an int
5448 and its values must be 0 or 1.
5449 ("true" is a fixed value perhaps depending on the language,
5450 but we don't handle values other than 1 correctly yet.) */
5451 tem = invert_truthvalue (arg0);
5452 /* Avoid infinite recursion. */
5453 if (TREE_CODE (tem) == TRUTH_NOT_EXPR)
5454 return t;
5455 return convert (type, tem);
5456
5457 case TRUTH_ANDIF_EXPR:
5458 /* Note that the operands of this must be ints
5459 and their values must be 0 or 1.
5460 ("true" is a fixed value perhaps depending on the language.) */
5461 /* If first arg is constant zero, return it. */
5462 if (integer_zerop (arg0))
5463 return arg0;
5464 case TRUTH_AND_EXPR:
5465 /* If either arg is constant true, drop it. */
5466 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5467 return non_lvalue (arg1);
5468 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5469 return non_lvalue (arg0);
5470 /* If second arg is constant zero, result is zero, but first arg
5471 must be evaluated. */
5472 if (integer_zerop (arg1))
5473 return omit_one_operand (type, arg1, arg0);
5474 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
5475 case will be handled here. */
5476 if (integer_zerop (arg0))
5477 return omit_one_operand (type, arg0, arg1);
5478
5479 truth_andor:
5480 /* We only do these simplifications if we are optimizing. */
5481 if (!optimize)
5482 return t;
5483
5484 /* Check for things like (A || B) && (A || C). We can convert this
5485 to A || (B && C). Note that either operator can be any of the four
5486 truth and/or operations and the transformation will still be
5487 valid. Also note that we only care about order for the
5488 ANDIF and ORIF operators. If B contains side effects, this
5489 might change the truth-value of A. */
5490 if (TREE_CODE (arg0) == TREE_CODE (arg1)
5491 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
5492 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
5493 || TREE_CODE (arg0) == TRUTH_AND_EXPR
5494 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
5495 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
5496 {
5497 tree a00 = TREE_OPERAND (arg0, 0);
5498 tree a01 = TREE_OPERAND (arg0, 1);
5499 tree a10 = TREE_OPERAND (arg1, 0);
5500 tree a11 = TREE_OPERAND (arg1, 1);
5501 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
5502 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
5503 && (code == TRUTH_AND_EXPR
5504 || code == TRUTH_OR_EXPR));
5505
5506 if (operand_equal_p (a00, a10, 0))
5507 return fold (build (TREE_CODE (arg0), type, a00,
5508 fold (build (code, type, a01, a11))));
5509 else if (commutative && operand_equal_p (a00, a11, 0))
5510 return fold (build (TREE_CODE (arg0), type, a00,
5511 fold (build (code, type, a01, a10))));
5512 else if (commutative && operand_equal_p (a01, a10, 0))
5513 return fold (build (TREE_CODE (arg0), type, a01,
5514 fold (build (code, type, a00, a11))));
5515
5516 /* This case if tricky because we must either have commutative
5517 operators or else A10 must not have side-effects. */
5518
5519 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
5520 && operand_equal_p (a01, a11, 0))
5521 return fold (build (TREE_CODE (arg0), type,
5522 fold (build (code, type, a00, a10)),
5523 a01));
5524 }
5525
5526 /* See if we can build a range comparison. */
5527 if (0 != (tem = fold_range_test (t)))
5528 return tem;
5529
5530 /* Check for the possibility of merging component references. If our
5531 lhs is another similar operation, try to merge its rhs with our
5532 rhs. Then try to merge our lhs and rhs. */
5533 if (TREE_CODE (arg0) == code
5534 && 0 != (tem = fold_truthop (code, type,
5535 TREE_OPERAND (arg0, 1), arg1)))
5536 return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
5537
5538 if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
5539 return tem;
5540
5541 return t;
5542
5543 case TRUTH_ORIF_EXPR:
5544 /* Note that the operands of this must be ints
5545 and their values must be 0 or true.
5546 ("true" is a fixed value perhaps depending on the language.) */
5547 /* If first arg is constant true, return it. */
5548 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5549 return arg0;
5550 case TRUTH_OR_EXPR:
5551 /* If either arg is constant zero, drop it. */
5552 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
5553 return non_lvalue (arg1);
5554 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
5555 return non_lvalue (arg0);
5556 /* If second arg is constant true, result is true, but we must
5557 evaluate first arg. */
5558 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
5559 return omit_one_operand (type, arg1, arg0);
5560 /* Likewise for first arg, but note this only occurs here for
5561 TRUTH_OR_EXPR. */
5562 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
5563 return omit_one_operand (type, arg0, arg1);
5564 goto truth_andor;
5565
5566 case TRUTH_XOR_EXPR:
5567 /* If either arg is constant zero, drop it. */
5568 if (integer_zerop (arg0))
5569 return non_lvalue (arg1);
5570 if (integer_zerop (arg1))
5571 return non_lvalue (arg0);
5572 /* If either arg is constant true, this is a logical inversion. */
5573 if (integer_onep (arg0))
5574 return non_lvalue (invert_truthvalue (arg1));
5575 if (integer_onep (arg1))
5576 return non_lvalue (invert_truthvalue (arg0));
5577 return t;
5578
5579 case EQ_EXPR:
5580 case NE_EXPR:
5581 case LT_EXPR:
5582 case GT_EXPR:
5583 case LE_EXPR:
5584 case GE_EXPR:
5585 /* If one arg is a constant integer, put it last. */
5586 if (TREE_CODE (arg0) == INTEGER_CST
5587 && TREE_CODE (arg1) != INTEGER_CST)
5588 {
5589 TREE_OPERAND (t, 0) = arg1;
5590 TREE_OPERAND (t, 1) = arg0;
5591 arg0 = TREE_OPERAND (t, 0);
5592 arg1 = TREE_OPERAND (t, 1);
5593 code = swap_tree_comparison (code);
5594 TREE_SET_CODE (t, code);
5595 }
5596
5597 /* Convert foo++ == CONST into ++foo == CONST + INCR.
5598 First, see if one arg is constant; find the constant arg
5599 and the other one. */
5600 {
5601 tree constop = 0, varop = NULL_TREE;
5602 int constopnum = -1;
5603
5604 if (TREE_CONSTANT (arg1))
5605 constopnum = 1, constop = arg1, varop = arg0;
5606 if (TREE_CONSTANT (arg0))
5607 constopnum = 0, constop = arg0, varop = arg1;
5608
5609 if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
5610 {
5611 /* This optimization is invalid for ordered comparisons
5612 if CONST+INCR overflows or if foo+incr might overflow.
5613 This optimization is invalid for floating point due to rounding.
5614 For pointer types we assume overflow doesn't happen. */
5615 if (POINTER_TYPE_P (TREE_TYPE (varop))
5616 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5617 && (code == EQ_EXPR || code == NE_EXPR)))
5618 {
5619 tree newconst
5620 = fold (build (PLUS_EXPR, TREE_TYPE (varop),
5621 constop, TREE_OPERAND (varop, 1)));
5622 TREE_SET_CODE (varop, PREINCREMENT_EXPR);
5623
5624 /* If VAROP is a reference to a bitfield, we must mask
5625 the constant by the width of the field. */
5626 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5627 && DECL_BIT_FIELD(TREE_OPERAND
5628 (TREE_OPERAND (varop, 0), 1)))
5629 {
5630 int size
5631 = TREE_INT_CST_LOW (DECL_SIZE
5632 (TREE_OPERAND
5633 (TREE_OPERAND (varop, 0), 1)));
5634 tree mask, unsigned_type;
5635 int precision;
5636 tree folded_compare;
5637
5638 /* First check whether the comparison would come out
5639 always the same. If we don't do that we would
5640 change the meaning with the masking. */
5641 if (constopnum == 0)
5642 folded_compare = fold (build (code, type, constop,
5643 TREE_OPERAND (varop, 0)));
5644 else
5645 folded_compare = fold (build (code, type,
5646 TREE_OPERAND (varop, 0),
5647 constop));
5648 if (integer_zerop (folded_compare)
5649 || integer_onep (folded_compare))
5650 return omit_one_operand (type, folded_compare, varop);
5651
5652 unsigned_type = type_for_size (size, 1);
5653 precision = TYPE_PRECISION (unsigned_type);
5654 mask = build_int_2 (~0, ~0);
5655 TREE_TYPE (mask) = unsigned_type;
5656 force_fit_type (mask, 0);
5657 mask = const_binop (RSHIFT_EXPR, mask,
5658 size_int (precision - size), 0);
5659 newconst = fold (build (BIT_AND_EXPR,
5660 TREE_TYPE (varop), newconst,
5661 convert (TREE_TYPE (varop),
5662 mask)));
5663 }
5664
5665
5666 t = build (code, type, TREE_OPERAND (t, 0),
5667 TREE_OPERAND (t, 1));
5668 TREE_OPERAND (t, constopnum) = newconst;
5669 return t;
5670 }
5671 }
5672 else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
5673 {
5674 if (POINTER_TYPE_P (TREE_TYPE (varop))
5675 || (! FLOAT_TYPE_P (TREE_TYPE (varop))
5676 && (code == EQ_EXPR || code == NE_EXPR)))
5677 {
5678 tree newconst
5679 = fold (build (MINUS_EXPR, TREE_TYPE (varop),
5680 constop, TREE_OPERAND (varop, 1)));
5681 TREE_SET_CODE (varop, PREDECREMENT_EXPR);
5682
5683 if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
5684 && DECL_BIT_FIELD(TREE_OPERAND
5685 (TREE_OPERAND (varop, 0), 1)))
5686 {
5687 int size
5688 = TREE_INT_CST_LOW (DECL_SIZE
5689 (TREE_OPERAND
5690 (TREE_OPERAND (varop, 0), 1)));
5691 tree mask, unsigned_type;
5692 int precision;
5693 tree folded_compare;
5694
5695 if (constopnum == 0)
5696 folded_compare = fold (build (code, type, constop,
5697 TREE_OPERAND (varop, 0)));
5698 else
5699 folded_compare = fold (build (code, type,
5700 TREE_OPERAND (varop, 0),
5701 constop));
5702 if (integer_zerop (folded_compare)
5703 || integer_onep (folded_compare))
5704 return omit_one_operand (type, folded_compare, varop);
5705
5706 unsigned_type = type_for_size (size, 1);
5707 precision = TYPE_PRECISION (unsigned_type);
5708 mask = build_int_2 (~0, ~0);
5709 TREE_TYPE (mask) = TREE_TYPE (varop);
5710 force_fit_type (mask, 0);
5711 mask = const_binop (RSHIFT_EXPR, mask,
5712 size_int (precision - size), 0);
5713 newconst = fold (build (BIT_AND_EXPR,
5714 TREE_TYPE (varop), newconst,
5715 convert (TREE_TYPE (varop),
5716 mask)));
5717 }
5718
5719
5720 t = build (code, type, TREE_OPERAND (t, 0),
5721 TREE_OPERAND (t, 1));
5722 TREE_OPERAND (t, constopnum) = newconst;
5723 return t;
5724 }
5725 }
5726 }
5727
5728 /* Change X >= CST to X > (CST - 1) if CST is positive. */
5729 if (TREE_CODE (arg1) == INTEGER_CST
5730 && TREE_CODE (arg0) != INTEGER_CST
5731 && tree_int_cst_sgn (arg1) > 0)
5732 {
5733 switch (TREE_CODE (t))
5734 {
5735 case GE_EXPR:
5736 code = GT_EXPR;
5737 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
5738 t = build (code, type, TREE_OPERAND (t, 0), arg1);
5739 break;
5740
5741 case LT_EXPR:
5742 code = LE_EXPR;
5743 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
5744 t = build (code, type, TREE_OPERAND (t, 0), arg1);
5745 break;
5746
5747 default:
5748 break;
5749 }
5750 }
5751
5752 /* If this is an EQ or NE comparison with zero and ARG0 is
5753 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
5754 two operations, but the latter can be done in one less insn
5755 on machines that have only two-operand insns or on which a
5756 constant cannot be the first operand. */
5757 if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
5758 && TREE_CODE (arg0) == BIT_AND_EXPR)
5759 {
5760 if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
5761 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
5762 return
5763 fold (build (code, type,
5764 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5765 build (RSHIFT_EXPR,
5766 TREE_TYPE (TREE_OPERAND (arg0, 0)),
5767 TREE_OPERAND (arg0, 1),
5768 TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
5769 convert (TREE_TYPE (arg0),
5770 integer_one_node)),
5771 arg1));
5772 else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
5773 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
5774 return
5775 fold (build (code, type,
5776 build (BIT_AND_EXPR, TREE_TYPE (arg0),
5777 build (RSHIFT_EXPR,
5778 TREE_TYPE (TREE_OPERAND (arg0, 1)),
5779 TREE_OPERAND (arg0, 0),
5780 TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
5781 convert (TREE_TYPE (arg0),
5782 integer_one_node)),
5783 arg1));
5784 }
5785
5786 /* If this is an NE or EQ comparison of zero against the result of a
5787 signed MOD operation whose second operand is a power of 2, make
5788 the MOD operation unsigned since it is simpler and equivalent. */
5789 if ((code == NE_EXPR || code == EQ_EXPR)
5790 && integer_zerop (arg1)
5791 && ! TREE_UNSIGNED (TREE_TYPE (arg0))
5792 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
5793 || TREE_CODE (arg0) == CEIL_MOD_EXPR
5794 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
5795 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
5796 && integer_pow2p (TREE_OPERAND (arg0, 1)))
5797 {
5798 tree newtype = unsigned_type (TREE_TYPE (arg0));
5799 tree newmod = build (TREE_CODE (arg0), newtype,
5800 convert (newtype, TREE_OPERAND (arg0, 0)),
5801 convert (newtype, TREE_OPERAND (arg0, 1)));
5802
5803 return build (code, type, newmod, convert (newtype, arg1));
5804 }
5805
5806 /* If this is an NE comparison of zero with an AND of one, remove the
5807 comparison since the AND will give the correct value. */
5808 if (code == NE_EXPR && integer_zerop (arg1)
5809 && TREE_CODE (arg0) == BIT_AND_EXPR
5810 && integer_onep (TREE_OPERAND (arg0, 1)))
5811 return convert (type, arg0);
5812
5813 /* If we have (A & C) == C where C is a power of 2, convert this into
5814 (A & C) != 0. Similarly for NE_EXPR. */
5815 if ((code == EQ_EXPR || code == NE_EXPR)
5816 && TREE_CODE (arg0) == BIT_AND_EXPR
5817 && integer_pow2p (TREE_OPERAND (arg0, 1))
5818 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
5819 return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
5820 arg0, integer_zero_node);
5821
5822 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
5823 and similarly for >= into !=. */
5824 if ((code == LT_EXPR || code == GE_EXPR)
5825 && TREE_UNSIGNED (TREE_TYPE (arg0))
5826 && TREE_CODE (arg1) == LSHIFT_EXPR
5827 && integer_onep (TREE_OPERAND (arg1, 0)))
5828 return build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5829 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5830 TREE_OPERAND (arg1, 1)),
5831 convert (TREE_TYPE (arg0), integer_zero_node));
5832
5833 else if ((code == LT_EXPR || code == GE_EXPR)
5834 && TREE_UNSIGNED (TREE_TYPE (arg0))
5835 && (TREE_CODE (arg1) == NOP_EXPR
5836 || TREE_CODE (arg1) == CONVERT_EXPR)
5837 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
5838 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
5839 return
5840 build (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
5841 convert (TREE_TYPE (arg0),
5842 build (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
5843 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1))),
5844 convert (TREE_TYPE (arg0), integer_zero_node));
5845
5846 /* Simplify comparison of something with itself. (For IEEE
5847 floating-point, we can only do some of these simplifications.) */
5848 if (operand_equal_p (arg0, arg1, 0))
5849 {
5850 switch (code)
5851 {
5852 case EQ_EXPR:
5853 case GE_EXPR:
5854 case LE_EXPR:
5855 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5856 return constant_boolean_node (1, type);
5857 code = EQ_EXPR;
5858 TREE_SET_CODE (t, code);
5859 break;
5860
5861 case NE_EXPR:
5862 /* For NE, we can only do this simplification if integer. */
5863 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5864 break;
5865 /* ... fall through ... */
5866 case GT_EXPR:
5867 case LT_EXPR:
5868 return constant_boolean_node (0, type);
5869 default:
5870 abort ();
5871 }
5872 }
5873
5874 /* An unsigned comparison against 0 can be simplified. */
5875 if (integer_zerop (arg1)
5876 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
5877 || POINTER_TYPE_P (TREE_TYPE (arg1)))
5878 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5879 {
5880 switch (TREE_CODE (t))
5881 {
5882 case GT_EXPR:
5883 code = NE_EXPR;
5884 TREE_SET_CODE (t, NE_EXPR);
5885 break;
5886 case LE_EXPR:
5887 code = EQ_EXPR;
5888 TREE_SET_CODE (t, EQ_EXPR);
5889 break;
5890 case GE_EXPR:
5891 return omit_one_operand (type,
5892 convert (type, integer_one_node),
5893 arg0);
5894 case LT_EXPR:
5895 return omit_one_operand (type,
5896 convert (type, integer_zero_node),
5897 arg0);
5898 default:
5899 break;
5900 }
5901 }
5902
5903 /* An unsigned <= 0x7fffffff can be simplified. */
5904 {
5905 int width = TYPE_PRECISION (TREE_TYPE (arg1));
5906 if (TREE_CODE (arg1) == INTEGER_CST
5907 && ! TREE_CONSTANT_OVERFLOW (arg1)
5908 && width <= HOST_BITS_PER_WIDE_INT
5909 && TREE_INT_CST_LOW (arg1) == ((HOST_WIDE_INT) 1 << (width - 1)) - 1
5910 && TREE_INT_CST_HIGH (arg1) == 0
5911 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
5912 || POINTER_TYPE_P (TREE_TYPE (arg1)))
5913 && TREE_UNSIGNED (TREE_TYPE (arg1)))
5914 {
5915 switch (TREE_CODE (t))
5916 {
5917 case LE_EXPR:
5918 return fold (build (GE_EXPR, type,
5919 convert (signed_type (TREE_TYPE (arg0)),
5920 arg0),
5921 convert (signed_type (TREE_TYPE (arg1)),
5922 integer_zero_node)));
5923 case GT_EXPR:
5924 return fold (build (LT_EXPR, type,
5925 convert (signed_type (TREE_TYPE (arg0)),
5926 arg0),
5927 convert (signed_type (TREE_TYPE (arg1)),
5928 integer_zero_node)));
5929 default:
5930 break;
5931 }
5932 }
5933 }
5934
5935 /* If we are comparing an expression that just has comparisons
5936 of two integer values, arithmetic expressions of those comparisons,
5937 and constants, we can simplify it. There are only three cases
5938 to check: the two values can either be equal, the first can be
5939 greater, or the second can be greater. Fold the expression for
5940 those three values. Since each value must be 0 or 1, we have
5941 eight possibilities, each of which corresponds to the constant 0
5942 or 1 or one of the six possible comparisons.
5943
5944 This handles common cases like (a > b) == 0 but also handles
5945 expressions like ((x > y) - (y > x)) > 0, which supposedly
5946 occur in macroized code. */
5947
5948 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
5949 {
5950 tree cval1 = 0, cval2 = 0;
5951 int save_p = 0;
5952
5953 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
5954 /* Don't handle degenerate cases here; they should already
5955 have been handled anyway. */
5956 && cval1 != 0 && cval2 != 0
5957 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
5958 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
5959 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
5960 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
5961 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
5962 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
5963 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
5964 {
5965 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
5966 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
5967
5968 /* We can't just pass T to eval_subst in case cval1 or cval2
5969 was the same as ARG1. */
5970
5971 tree high_result
5972 = fold (build (code, type,
5973 eval_subst (arg0, cval1, maxval, cval2, minval),
5974 arg1));
5975 tree equal_result
5976 = fold (build (code, type,
5977 eval_subst (arg0, cval1, maxval, cval2, maxval),
5978 arg1));
5979 tree low_result
5980 = fold (build (code, type,
5981 eval_subst (arg0, cval1, minval, cval2, maxval),
5982 arg1));
5983
5984 /* All three of these results should be 0 or 1. Confirm they
5985 are. Then use those values to select the proper code
5986 to use. */
5987
5988 if ((integer_zerop (high_result)
5989 || integer_onep (high_result))
5990 && (integer_zerop (equal_result)
5991 || integer_onep (equal_result))
5992 && (integer_zerop (low_result)
5993 || integer_onep (low_result)))
5994 {
5995 /* Make a 3-bit mask with the high-order bit being the
5996 value for `>', the next for '=', and the low for '<'. */
5997 switch ((integer_onep (high_result) * 4)
5998 + (integer_onep (equal_result) * 2)
5999 + integer_onep (low_result))
6000 {
6001 case 0:
6002 /* Always false. */
6003 return omit_one_operand (type, integer_zero_node, arg0);
6004 case 1:
6005 code = LT_EXPR;
6006 break;
6007 case 2:
6008 code = EQ_EXPR;
6009 break;
6010 case 3:
6011 code = LE_EXPR;
6012 break;
6013 case 4:
6014 code = GT_EXPR;
6015 break;
6016 case 5:
6017 code = NE_EXPR;
6018 break;
6019 case 6:
6020 code = GE_EXPR;
6021 break;
6022 case 7:
6023 /* Always true. */
6024 return omit_one_operand (type, integer_one_node, arg0);
6025 }
6026
6027 t = build (code, type, cval1, cval2);
6028 if (save_p)
6029 return save_expr (t);
6030 else
6031 return fold (t);
6032 }
6033 }
6034 }
6035
6036 /* If this is a comparison of a field, we may be able to simplify it. */
6037 if ((TREE_CODE (arg0) == COMPONENT_REF
6038 || TREE_CODE (arg0) == BIT_FIELD_REF)
6039 && (code == EQ_EXPR || code == NE_EXPR)
6040 /* Handle the constant case even without -O
6041 to make sure the warnings are given. */
6042 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
6043 {
6044 t1 = optimize_bit_field_compare (code, type, arg0, arg1);
6045 return t1 ? t1 : t;
6046 }
6047
6048 /* If this is a comparison of complex values and either or both sides
6049 are a COMPLEX_EXPR or COMPLEX_CST, it is best to split up the
6050 comparisons and join them with a TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR.
6051 This may prevent needless evaluations. */
6052 if ((code == EQ_EXPR || code == NE_EXPR)
6053 && TREE_CODE (TREE_TYPE (arg0)) == COMPLEX_TYPE
6054 && (TREE_CODE (arg0) == COMPLEX_EXPR
6055 || TREE_CODE (arg1) == COMPLEX_EXPR
6056 || TREE_CODE (arg0) == COMPLEX_CST
6057 || TREE_CODE (arg1) == COMPLEX_CST))
6058 {
6059 tree subtype = TREE_TYPE (TREE_TYPE (arg0));
6060 tree real0, imag0, real1, imag1;
6061
6062 arg0 = save_expr (arg0);
6063 arg1 = save_expr (arg1);
6064 real0 = fold (build1 (REALPART_EXPR, subtype, arg0));
6065 imag0 = fold (build1 (IMAGPART_EXPR, subtype, arg0));
6066 real1 = fold (build1 (REALPART_EXPR, subtype, arg1));
6067 imag1 = fold (build1 (IMAGPART_EXPR, subtype, arg1));
6068
6069 return fold (build ((code == EQ_EXPR ? TRUTH_ANDIF_EXPR
6070 : TRUTH_ORIF_EXPR),
6071 type,
6072 fold (build (code, type, real0, real1)),
6073 fold (build (code, type, imag0, imag1))));
6074 }
6075
6076 /* From here on, the only cases we handle are when the result is
6077 known to be a constant.
6078
6079 To compute GT, swap the arguments and do LT.
6080 To compute GE, do LT and invert the result.
6081 To compute LE, swap the arguments, do LT and invert the result.
6082 To compute NE, do EQ and invert the result.
6083
6084 Therefore, the code below must handle only EQ and LT. */
6085
6086 if (code == LE_EXPR || code == GT_EXPR)
6087 {
6088 tem = arg0, arg0 = arg1, arg1 = tem;
6089 code = swap_tree_comparison (code);
6090 }
6091
6092 /* Note that it is safe to invert for real values here because we
6093 will check below in the one case that it matters. */
6094
6095 invert = 0;
6096 if (code == NE_EXPR || code == GE_EXPR)
6097 {
6098 invert = 1;
6099 code = invert_tree_comparison (code);
6100 }
6101
6102 /* Compute a result for LT or EQ if args permit;
6103 otherwise return T. */
6104 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
6105 {
6106 if (code == EQ_EXPR)
6107 t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
6108 == TREE_INT_CST_LOW (arg1))
6109 && (TREE_INT_CST_HIGH (arg0)
6110 == TREE_INT_CST_HIGH (arg1)),
6111 0);
6112 else
6113 t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
6114 ? INT_CST_LT_UNSIGNED (arg0, arg1)
6115 : INT_CST_LT (arg0, arg1)),
6116 0);
6117 }
6118
6119#if 0 /* This is no longer useful, but breaks some real code. */
6120 /* Assume a nonexplicit constant cannot equal an explicit one,
6121 since such code would be undefined anyway.
6122 Exception: on sysvr4, using #pragma weak,
6123 a label can come out as 0. */
6124 else if (TREE_CODE (arg1) == INTEGER_CST
6125 && !integer_zerop (arg1)
6126 && TREE_CONSTANT (arg0)
6127 && TREE_CODE (arg0) == ADDR_EXPR
6128 && code == EQ_EXPR)
6129 t1 = build_int_2 (0, 0);
6130#endif
6131 /* Two real constants can be compared explicitly. */
6132 else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
6133 {
6134 /* If either operand is a NaN, the result is false with two
6135 exceptions: First, an NE_EXPR is true on NaNs, but that case
6136 is already handled correctly since we will be inverting the
6137 result for NE_EXPR. Second, if we had inverted a LE_EXPR
6138 or a GE_EXPR into a LT_EXPR, we must return true so that it
6139 will be inverted into false. */
6140
6141 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
6142 || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
6143 t1 = build_int_2 (invert && code == LT_EXPR, 0);
6144
6145 else if (code == EQ_EXPR)
6146 t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
6147 TREE_REAL_CST (arg1)),
6148 0);
6149 else
6150 t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
6151 TREE_REAL_CST (arg1)),
6152 0);
6153 }
6154
6155 if (t1 == NULL_TREE)
6156 return t;
6157
6158 if (invert)
6159 TREE_INT_CST_LOW (t1) ^= 1;
6160
6161 TREE_TYPE (t1) = type;
6162 if (TREE_CODE (type) == BOOLEAN_TYPE)
6163 return truthvalue_conversion (t1);
6164 return t1;
6165
6166 case COND_EXPR:
6167 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
6168 so all simple results must be passed through pedantic_non_lvalue. */
6169 if (TREE_CODE (arg0) == INTEGER_CST)
6170 return pedantic_non_lvalue
6171 (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
6172 else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
6173 return pedantic_omit_one_operand (type, arg1, arg0);
6174
6175 /* If the second operand is zero, invert the comparison and swap
6176 the second and third operands. Likewise if the second operand
6177 is constant and the third is not or if the third operand is
6178 equivalent to the first operand of the comparison. */
6179
6180 if (integer_zerop (arg1)
6181 || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
6182 || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6183 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6184 TREE_OPERAND (t, 2),
6185 TREE_OPERAND (arg0, 1))))
6186 {
6187 /* See if this can be inverted. If it can't, possibly because
6188 it was a floating-point inequality comparison, don't do
6189 anything. */
6190 tem = invert_truthvalue (arg0);
6191
6192 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6193 {
6194 t = build (code, type, tem,
6195 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6196 arg0 = tem;
|
5827 arg1 = TREE_OPERAND (t, 2);
| 6197 /* arg1 should be the first argument of the new T. */
6198 arg1 = TREE_OPERAND (t, 1);
|
5828 STRIP_NOPS (arg1);
5829 }
5830 }
5831
5832 /* If we have A op B ? A : C, we may be able to convert this to a
5833 simpler expression, depending on the operation and the values
5834 of B and C. IEEE floating point prevents this though,
5835 because A or B might be -0.0 or a NaN. */
5836
5837 if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
5838 && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
5839 || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
5840 || flag_fast_math)
5841 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
5842 arg1, TREE_OPERAND (arg0, 1)))
5843 {
5844 tree arg2 = TREE_OPERAND (t, 2);
5845 enum tree_code comp_code = TREE_CODE (arg0);
5846
5847 STRIP_NOPS (arg2);
5848
5849 /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
5850 depending on the comparison operation. */
5851 if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
5852 ? real_zerop (TREE_OPERAND (arg0, 1))
5853 : integer_zerop (TREE_OPERAND (arg0, 1)))
5854 && TREE_CODE (arg2) == NEGATE_EXPR
5855 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5856 switch (comp_code)
5857 {
5858 case EQ_EXPR:
5859 return pedantic_non_lvalue
5860 (fold (build1 (NEGATE_EXPR, type, arg1)));
5861 case NE_EXPR:
5862 return pedantic_non_lvalue (convert (type, arg1));
5863 case GE_EXPR:
5864 case GT_EXPR:
| 6199 STRIP_NOPS (arg1);
6200 }
6201 }
6202
6203 /* If we have A op B ? A : C, we may be able to convert this to a
6204 simpler expression, depending on the operation and the values
6205 of B and C. IEEE floating point prevents this though,
6206 because A or B might be -0.0 or a NaN. */
6207
6208 if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
6209 && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
6210 || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0)))
6211 || flag_fast_math)
6212 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
6213 arg1, TREE_OPERAND (arg0, 1)))
6214 {
6215 tree arg2 = TREE_OPERAND (t, 2);
6216 enum tree_code comp_code = TREE_CODE (arg0);
6217
6218 STRIP_NOPS (arg2);
6219
6220 /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
6221 depending on the comparison operation. */
6222 if ((FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 1)))
6223 ? real_zerop (TREE_OPERAND (arg0, 1))
6224 : integer_zerop (TREE_OPERAND (arg0, 1)))
6225 && TREE_CODE (arg2) == NEGATE_EXPR
6226 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
6227 switch (comp_code)
6228 {
6229 case EQ_EXPR:
6230 return pedantic_non_lvalue
6231 (fold (build1 (NEGATE_EXPR, type, arg1)));
6232 case NE_EXPR:
6233 return pedantic_non_lvalue (convert (type, arg1));
6234 case GE_EXPR:
6235 case GT_EXPR:
|
| 6236 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6237 arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
|
5865 return pedantic_non_lvalue
5866 (convert (type, fold (build1 (ABS_EXPR,
5867 TREE_TYPE (arg1), arg1))));
5868 case LE_EXPR:
5869 case LT_EXPR:
| 6238 return pedantic_non_lvalue
6239 (convert (type, fold (build1 (ABS_EXPR,
6240 TREE_TYPE (arg1), arg1))));
6241 case LE_EXPR:
6242 case LT_EXPR:
|
| 6243 if (TREE_UNSIGNED (TREE_TYPE (arg1)))
6244 arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
|
5870 return pedantic_non_lvalue
5871 (fold (build1 (NEGATE_EXPR, type,
5872 convert (type,
5873 fold (build1 (ABS_EXPR,
5874 TREE_TYPE (arg1),
5875 arg1))))));
5876 default:
5877 abort ();
5878 }
5879
5880 /* If this is A != 0 ? A : 0, this is simply A. For ==, it is
5881 always zero. */
5882
5883 if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
5884 {
5885 if (comp_code == NE_EXPR)
5886 return pedantic_non_lvalue (convert (type, arg1));
5887 else if (comp_code == EQ_EXPR)
5888 return pedantic_non_lvalue (convert (type, integer_zero_node));
5889 }
5890
5891 /* If this is A op B ? A : B, this is either A, B, min (A, B),
5892 or max (A, B), depending on the operation. */
5893
5894 if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
5895 arg2, TREE_OPERAND (arg0, 0)))
5896 {
5897 tree comp_op0 = TREE_OPERAND (arg0, 0);
5898 tree comp_op1 = TREE_OPERAND (arg0, 1);
5899 tree comp_type = TREE_TYPE (comp_op0);
5900
5901 switch (comp_code)
5902 {
5903 case EQ_EXPR:
5904 return pedantic_non_lvalue (convert (type, arg2));
5905 case NE_EXPR:
5906 return pedantic_non_lvalue (convert (type, arg1));
5907 case LE_EXPR:
5908 case LT_EXPR:
5909 /* In C++ a ?: expression can be an lvalue, so put the
5910 operand which will be used if they are equal first
5911 so that we can convert this back to the
5912 corresponding COND_EXPR. */
5913 return pedantic_non_lvalue
5914 (convert (type, (fold (build (MIN_EXPR, comp_type,
5915 (comp_code == LE_EXPR
5916 ? comp_op0 : comp_op1),
5917 (comp_code == LE_EXPR
5918 ? comp_op1 : comp_op0))))));
5919 break;
5920 case GE_EXPR:
5921 case GT_EXPR:
5922 return pedantic_non_lvalue
5923 (convert (type, fold (build (MAX_EXPR, comp_type,
5924 (comp_code == GE_EXPR
5925 ? comp_op0 : comp_op1),
5926 (comp_code == GE_EXPR
5927 ? comp_op1 : comp_op0)))));
5928 break;
5929 default:
5930 abort ();
5931 }
5932 }
5933
5934 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5935 we might still be able to simplify this. For example,
5936 if C1 is one less or one more than C2, this might have started
5937 out as a MIN or MAX and been transformed by this function.
5938 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5939
5940 if (INTEGRAL_TYPE_P (type)
5941 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
5942 && TREE_CODE (arg2) == INTEGER_CST)
5943 switch (comp_code)
5944 {
5945 case EQ_EXPR:
5946 /* We can replace A with C1 in this case. */
5947 arg1 = convert (type, TREE_OPERAND (arg0, 1));
5948 t = build (code, type, TREE_OPERAND (t, 0), arg1,
5949 TREE_OPERAND (t, 2));
5950 break;
5951
5952 case LT_EXPR:
5953 /* If C1 is C2 + 1, this is min(A, C2). */
5954 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
5955 && operand_equal_p (TREE_OPERAND (arg0, 1),
5956 const_binop (PLUS_EXPR, arg2,
5957 integer_one_node, 0), 1))
5958 return pedantic_non_lvalue
5959 (fold (build (MIN_EXPR, type, arg1, arg2)));
5960 break;
5961
5962 case LE_EXPR:
5963 /* If C1 is C2 - 1, this is min(A, C2). */
5964 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
5965 && operand_equal_p (TREE_OPERAND (arg0, 1),
5966 const_binop (MINUS_EXPR, arg2,
5967 integer_one_node, 0), 1))
5968 return pedantic_non_lvalue
5969 (fold (build (MIN_EXPR, type, arg1, arg2)));
5970 break;
5971
5972 case GT_EXPR:
5973 /* If C1 is C2 - 1, this is max(A, C2). */
5974 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
5975 && operand_equal_p (TREE_OPERAND (arg0, 1),
5976 const_binop (MINUS_EXPR, arg2,
5977 integer_one_node, 0), 1))
5978 return pedantic_non_lvalue
5979 (fold (build (MAX_EXPR, type, arg1, arg2)));
5980 break;
5981
5982 case GE_EXPR:
5983 /* If C1 is C2 + 1, this is max(A, C2). */
5984 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
5985 && operand_equal_p (TREE_OPERAND (arg0, 1),
5986 const_binop (PLUS_EXPR, arg2,
5987 integer_one_node, 0), 1))
5988 return pedantic_non_lvalue
5989 (fold (build (MAX_EXPR, type, arg1, arg2)));
5990 break;
5991 case NE_EXPR:
5992 break;
5993 default:
5994 abort ();
5995 }
5996 }
5997
5998 /* If the second operand is simpler than the third, swap them
5999 since that produces better jump optimization results. */
6000 if ((TREE_CONSTANT (arg1) || TREE_CODE_CLASS (TREE_CODE (arg1)) == 'd'
6001 || TREE_CODE (arg1) == SAVE_EXPR)
6002 && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
6003 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 2))) == 'd'
6004 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
6005 {
6006 /* See if this can be inverted. If it can't, possibly because
6007 it was a floating-point inequality comparison, don't do
6008 anything. */
6009 tem = invert_truthvalue (arg0);
6010
6011 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6012 {
6013 t = build (code, type, tem,
6014 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6015 arg0 = tem;
| 6245 return pedantic_non_lvalue
6246 (fold (build1 (NEGATE_EXPR, type,
6247 convert (type,
6248 fold (build1 (ABS_EXPR,
6249 TREE_TYPE (arg1),
6250 arg1))))));
6251 default:
6252 abort ();
6253 }
6254
6255 /* If this is A != 0 ? A : 0, this is simply A. For ==, it is
6256 always zero. */
6257
6258 if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
6259 {
6260 if (comp_code == NE_EXPR)
6261 return pedantic_non_lvalue (convert (type, arg1));
6262 else if (comp_code == EQ_EXPR)
6263 return pedantic_non_lvalue (convert (type, integer_zero_node));
6264 }
6265
6266 /* If this is A op B ? A : B, this is either A, B, min (A, B),
6267 or max (A, B), depending on the operation. */
6268
6269 if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
6270 arg2, TREE_OPERAND (arg0, 0)))
6271 {
6272 tree comp_op0 = TREE_OPERAND (arg0, 0);
6273 tree comp_op1 = TREE_OPERAND (arg0, 1);
6274 tree comp_type = TREE_TYPE (comp_op0);
6275
6276 switch (comp_code)
6277 {
6278 case EQ_EXPR:
6279 return pedantic_non_lvalue (convert (type, arg2));
6280 case NE_EXPR:
6281 return pedantic_non_lvalue (convert (type, arg1));
6282 case LE_EXPR:
6283 case LT_EXPR:
6284 /* In C++ a ?: expression can be an lvalue, so put the
6285 operand which will be used if they are equal first
6286 so that we can convert this back to the
6287 corresponding COND_EXPR. */
6288 return pedantic_non_lvalue
6289 (convert (type, (fold (build (MIN_EXPR, comp_type,
6290 (comp_code == LE_EXPR
6291 ? comp_op0 : comp_op1),
6292 (comp_code == LE_EXPR
6293 ? comp_op1 : comp_op0))))));
6294 break;
6295 case GE_EXPR:
6296 case GT_EXPR:
6297 return pedantic_non_lvalue
6298 (convert (type, fold (build (MAX_EXPR, comp_type,
6299 (comp_code == GE_EXPR
6300 ? comp_op0 : comp_op1),
6301 (comp_code == GE_EXPR
6302 ? comp_op1 : comp_op0)))));
6303 break;
6304 default:
6305 abort ();
6306 }
6307 }
6308
6309 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
6310 we might still be able to simplify this. For example,
6311 if C1 is one less or one more than C2, this might have started
6312 out as a MIN or MAX and been transformed by this function.
6313 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
6314
6315 if (INTEGRAL_TYPE_P (type)
6316 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
6317 && TREE_CODE (arg2) == INTEGER_CST)
6318 switch (comp_code)
6319 {
6320 case EQ_EXPR:
6321 /* We can replace A with C1 in this case. */
6322 arg1 = convert (type, TREE_OPERAND (arg0, 1));
6323 t = build (code, type, TREE_OPERAND (t, 0), arg1,
6324 TREE_OPERAND (t, 2));
6325 break;
6326
6327 case LT_EXPR:
6328 /* If C1 is C2 + 1, this is min(A, C2). */
6329 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6330 && operand_equal_p (TREE_OPERAND (arg0, 1),
6331 const_binop (PLUS_EXPR, arg2,
6332 integer_one_node, 0), 1))
6333 return pedantic_non_lvalue
6334 (fold (build (MIN_EXPR, type, arg1, arg2)));
6335 break;
6336
6337 case LE_EXPR:
6338 /* If C1 is C2 - 1, this is min(A, C2). */
6339 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6340 && operand_equal_p (TREE_OPERAND (arg0, 1),
6341 const_binop (MINUS_EXPR, arg2,
6342 integer_one_node, 0), 1))
6343 return pedantic_non_lvalue
6344 (fold (build (MIN_EXPR, type, arg1, arg2)));
6345 break;
6346
6347 case GT_EXPR:
6348 /* If C1 is C2 - 1, this is max(A, C2). */
6349 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
6350 && operand_equal_p (TREE_OPERAND (arg0, 1),
6351 const_binop (MINUS_EXPR, arg2,
6352 integer_one_node, 0), 1))
6353 return pedantic_non_lvalue
6354 (fold (build (MAX_EXPR, type, arg1, arg2)));
6355 break;
6356
6357 case GE_EXPR:
6358 /* If C1 is C2 + 1, this is max(A, C2). */
6359 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
6360 && operand_equal_p (TREE_OPERAND (arg0, 1),
6361 const_binop (PLUS_EXPR, arg2,
6362 integer_one_node, 0), 1))
6363 return pedantic_non_lvalue
6364 (fold (build (MAX_EXPR, type, arg1, arg2)));
6365 break;
6366 case NE_EXPR:
6367 break;
6368 default:
6369 abort ();
6370 }
6371 }
6372
6373 /* If the second operand is simpler than the third, swap them
6374 since that produces better jump optimization results. */
6375 if ((TREE_CONSTANT (arg1) || TREE_CODE_CLASS (TREE_CODE (arg1)) == 'd'
6376 || TREE_CODE (arg1) == SAVE_EXPR)
6377 && ! (TREE_CONSTANT (TREE_OPERAND (t, 2))
6378 || TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (t, 2))) == 'd'
6379 || TREE_CODE (TREE_OPERAND (t, 2)) == SAVE_EXPR))
6380 {
6381 /* See if this can be inverted. If it can't, possibly because
6382 it was a floating-point inequality comparison, don't do
6383 anything. */
6384 tem = invert_truthvalue (arg0);
6385
6386 if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
6387 {
6388 t = build (code, type, tem,
6389 TREE_OPERAND (t, 2), TREE_OPERAND (t, 1));
6390 arg0 = tem;
|
6016 arg1 = TREE_OPERAND (t, 2);
| 6391 /* arg1 should be the first argument of the new T. */
6392 arg1 = TREE_OPERAND (t, 1);
|
6017 STRIP_NOPS (arg1);
6018 }
6019 }
6020
6021 /* Convert A ? 1 : 0 to simply A. */
6022 if (integer_onep (TREE_OPERAND (t, 1))
6023 && integer_zerop (TREE_OPERAND (t, 2))
6024 /* If we try to convert TREE_OPERAND (t, 0) to our type, the
6025 call to fold will try to move the conversion inside
6026 a COND, which will recurse. In that case, the COND_EXPR
6027 is probably the best choice, so leave it alone. */
6028 && type == TREE_TYPE (arg0))
6029 return pedantic_non_lvalue (arg0);
6030
6031 /* Look for expressions of the form A & 2 ? 2 : 0. The result of this
6032 operation is simply A & 2. */
6033
6034 if (integer_zerop (TREE_OPERAND (t, 2))
6035 && TREE_CODE (arg0) == NE_EXPR
6036 && integer_zerop (TREE_OPERAND (arg0, 1))
6037 && integer_pow2p (arg1)
6038 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
6039 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
6040 arg1, 1))
6041 return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
6042
6043 return t;
6044
6045 case COMPOUND_EXPR:
6046 /* When pedantic, a compound expression can be neither an lvalue
6047 nor an integer constant expression. */
6048 if (TREE_SIDE_EFFECTS (arg0) || pedantic)
6049 return t;
6050 /* Don't let (0, 0) be null pointer constant. */
6051 if (integer_zerop (arg1))
| 6393 STRIP_NOPS (arg1);
6394 }
6395 }
6396
6397 /* Convert A ? 1 : 0 to simply A. */
6398 if (integer_onep (TREE_OPERAND (t, 1))
6399 && integer_zerop (TREE_OPERAND (t, 2))
6400 /* If we try to convert TREE_OPERAND (t, 0) to our type, the
6401 call to fold will try to move the conversion inside
6402 a COND, which will recurse. In that case, the COND_EXPR
6403 is probably the best choice, so leave it alone. */
6404 && type == TREE_TYPE (arg0))
6405 return pedantic_non_lvalue (arg0);
6406
6407 /* Look for expressions of the form A & 2 ? 2 : 0. The result of this
6408 operation is simply A & 2. */
6409
6410 if (integer_zerop (TREE_OPERAND (t, 2))
6411 && TREE_CODE (arg0) == NE_EXPR
6412 && integer_zerop (TREE_OPERAND (arg0, 1))
6413 && integer_pow2p (arg1)
6414 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
6415 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
6416 arg1, 1))
6417 return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
6418
6419 return t;
6420
6421 case COMPOUND_EXPR:
6422 /* When pedantic, a compound expression can be neither an lvalue
6423 nor an integer constant expression. */
6424 if (TREE_SIDE_EFFECTS (arg0) || pedantic)
6425 return t;
6426 /* Don't let (0, 0) be null pointer constant. */
6427 if (integer_zerop (arg1))
|
6052 return non_lvalue (arg1);
| 6428 return build1 (NOP_EXPR, TREE_TYPE (arg1), arg1);
|
6053 return arg1;
6054
6055 case COMPLEX_EXPR:
6056 if (wins)
6057 return build_complex (type, arg0, arg1);
6058 return t;
6059
6060 case REALPART_EXPR:
6061 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6062 return t;
6063 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6064 return omit_one_operand (type, TREE_OPERAND (arg0, 0),
6065 TREE_OPERAND (arg0, 1));
6066 else if (TREE_CODE (arg0) == COMPLEX_CST)
6067 return TREE_REALPART (arg0);
6068 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6069 return fold (build (TREE_CODE (arg0), type,
6070 fold (build1 (REALPART_EXPR, type,
6071 TREE_OPERAND (arg0, 0))),
6072 fold (build1 (REALPART_EXPR,
6073 type, TREE_OPERAND (arg0, 1)))));
6074 return t;
6075
6076 case IMAGPART_EXPR:
6077 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6078 return convert (type, integer_zero_node);
6079 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6080 return omit_one_operand (type, TREE_OPERAND (arg0, 1),
6081 TREE_OPERAND (arg0, 0));
6082 else if (TREE_CODE (arg0) == COMPLEX_CST)
6083 return TREE_IMAGPART (arg0);
6084 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6085 return fold (build (TREE_CODE (arg0), type,
6086 fold (build1 (IMAGPART_EXPR, type,
6087 TREE_OPERAND (arg0, 0))),
6088 fold (build1 (IMAGPART_EXPR, type,
6089 TREE_OPERAND (arg0, 1)))));
6090 return t;
6091
6092 /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6093 appropriate. */
6094 case CLEANUP_POINT_EXPR:
6095 if (! has_cleanups (arg0))
6096 return TREE_OPERAND (t, 0);
6097
6098 {
6099 enum tree_code code0 = TREE_CODE (arg0);
6100 int kind0 = TREE_CODE_CLASS (code0);
6101 tree arg00 = TREE_OPERAND (arg0, 0);
6102 tree arg01;
6103
6104 if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
6105 return fold (build1 (code0, type,
6106 fold (build1 (CLEANUP_POINT_EXPR,
6107 TREE_TYPE (arg00), arg00))));
6108
6109 if (kind0 == '<' || kind0 == '2'
6110 || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
6111 || code0 == TRUTH_AND_EXPR || code0 == TRUTH_OR_EXPR
6112 || code0 == TRUTH_XOR_EXPR)
6113 {
6114 arg01 = TREE_OPERAND (arg0, 1);
6115
6116 if (TREE_CONSTANT (arg00)
6117 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
6118 && ! has_cleanups (arg00)))
6119 return fold (build (code0, type, arg00,
6120 fold (build1 (CLEANUP_POINT_EXPR,
6121 TREE_TYPE (arg01), arg01))));
6122
6123 if (TREE_CONSTANT (arg01))
6124 return fold (build (code0, type,
6125 fold (build1 (CLEANUP_POINT_EXPR,
6126 TREE_TYPE (arg00), arg00)),
6127 arg01));
6128 }
6129
6130 return t;
6131 }
6132
6133 default:
6134 return t;
6135 } /* switch (code) */
6136}
6137
6138/* Determine if first argument is a multiple of second argument.
6139 Return 0 if it is not, or is not easily determined to so be.
6140
6141 An example of the sort of thing we care about (at this point --
6142 this routine could surely be made more general, and expanded
6143 to do what the *_DIV_EXPR's fold() cases do now) is discovering
6144 that
6145
6146 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6147
6148 is a multiple of
6149
6150 SAVE_EXPR (J * 8)
6151
6152 when we know that the two `SAVE_EXPR (J * 8)' nodes are the
6153 same node (which means they will have the same value at run
6154 time, even though we don't know when they'll be assigned).
6155
6156 This code also handles discovering that
6157
6158 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6159
6160 is a multiple of
6161
6162 8
6163
6164 (of course) so we don't have to worry about dealing with a
6165 possible remainder.
6166
6167 Note that we _look_ inside a SAVE_EXPR only to determine
6168 how it was calculated; it is not safe for fold() to do much
6169 of anything else with the internals of a SAVE_EXPR, since
6170 fold() cannot know when it will be evaluated at run time.
6171 For example, the latter example above _cannot_ be implemented
6172 as
6173
6174 SAVE_EXPR (I) * J
6175
6176 or any variant thereof, since the value of J at evaluation time
6177 of the original SAVE_EXPR is not necessarily the same at the time
6178 the new expression is evaluated. The only optimization of this
6179 sort that would be valid is changing
6180
6181 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
6182 divided by
6183 8
6184
6185 to
6186
6187 SAVE_EXPR (I) * SAVE_EXPR (J)
6188
6189 (where the same SAVE_EXPR (J) is used in the original and the
6190 transformed version). */
6191
6192static int
6193multiple_of_p (type, top, bottom)
6194 tree type;
6195 tree top;
6196 tree bottom;
6197{
6198 if (operand_equal_p (top, bottom, 0))
6199 return 1;
6200
6201 if (TREE_CODE (type) != INTEGER_TYPE)
6202 return 0;
6203
6204 switch (TREE_CODE (top))
6205 {
6206 case MULT_EXPR:
6207 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6208 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6209
6210 case PLUS_EXPR:
6211 case MINUS_EXPR:
6212 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6213 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6214
6215 case NOP_EXPR:
6216 /* Punt if conversion from non-integral or wider integral type. */
6217 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
6218 || (TYPE_PRECISION (type)
6219 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
6220 return 0;
6221 /* Fall through. */
6222 case SAVE_EXPR:
6223 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
6224
6225 case INTEGER_CST:
6226 if ((TREE_CODE (bottom) != INTEGER_CST)
6227 || (tree_int_cst_sgn (top) < 0)
6228 || (tree_int_cst_sgn (bottom) < 0))
6229 return 0;
6230 return integer_zerop (const_binop (TRUNC_MOD_EXPR,
6231 top, bottom, 0));
6232
6233 default:
6234 return 0;
6235 }
6236}
6237
| 6429 return arg1;
6430
6431 case COMPLEX_EXPR:
6432 if (wins)
6433 return build_complex (type, arg0, arg1);
6434 return t;
6435
6436 case REALPART_EXPR:
6437 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6438 return t;
6439 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6440 return omit_one_operand (type, TREE_OPERAND (arg0, 0),
6441 TREE_OPERAND (arg0, 1));
6442 else if (TREE_CODE (arg0) == COMPLEX_CST)
6443 return TREE_REALPART (arg0);
6444 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6445 return fold (build (TREE_CODE (arg0), type,
6446 fold (build1 (REALPART_EXPR, type,
6447 TREE_OPERAND (arg0, 0))),
6448 fold (build1 (REALPART_EXPR,
6449 type, TREE_OPERAND (arg0, 1)))));
6450 return t;
6451
6452 case IMAGPART_EXPR:
6453 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
6454 return convert (type, integer_zero_node);
6455 else if (TREE_CODE (arg0) == COMPLEX_EXPR)
6456 return omit_one_operand (type, TREE_OPERAND (arg0, 1),
6457 TREE_OPERAND (arg0, 0));
6458 else if (TREE_CODE (arg0) == COMPLEX_CST)
6459 return TREE_IMAGPART (arg0);
6460 else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
6461 return fold (build (TREE_CODE (arg0), type,
6462 fold (build1 (IMAGPART_EXPR, type,
6463 TREE_OPERAND (arg0, 0))),
6464 fold (build1 (IMAGPART_EXPR, type,
6465 TREE_OPERAND (arg0, 1)))));
6466 return t;
6467
6468 /* Pull arithmetic ops out of the CLEANUP_POINT_EXPR where
6469 appropriate. */
6470 case CLEANUP_POINT_EXPR:
6471 if (! has_cleanups (arg0))
6472 return TREE_OPERAND (t, 0);
6473
6474 {
6475 enum tree_code code0 = TREE_CODE (arg0);
6476 int kind0 = TREE_CODE_CLASS (code0);
6477 tree arg00 = TREE_OPERAND (arg0, 0);
6478 tree arg01;
6479
6480 if (kind0 == '1' || code0 == TRUTH_NOT_EXPR)
6481 return fold (build1 (code0, type,
6482 fold (build1 (CLEANUP_POINT_EXPR,
6483 TREE_TYPE (arg00), arg00))));
6484
6485 if (kind0 == '<' || kind0 == '2'
6486 || code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR
6487 || code0 == TRUTH_AND_EXPR || code0 == TRUTH_OR_EXPR
6488 || code0 == TRUTH_XOR_EXPR)
6489 {
6490 arg01 = TREE_OPERAND (arg0, 1);
6491
6492 if (TREE_CONSTANT (arg00)
6493 || ((code0 == TRUTH_ANDIF_EXPR || code0 == TRUTH_ORIF_EXPR)
6494 && ! has_cleanups (arg00)))
6495 return fold (build (code0, type, arg00,
6496 fold (build1 (CLEANUP_POINT_EXPR,
6497 TREE_TYPE (arg01), arg01))));
6498
6499 if (TREE_CONSTANT (arg01))
6500 return fold (build (code0, type,
6501 fold (build1 (CLEANUP_POINT_EXPR,
6502 TREE_TYPE (arg00), arg00)),
6503 arg01));
6504 }
6505
6506 return t;
6507 }
6508
6509 default:
6510 return t;
6511 } /* switch (code) */
6512}
6513
6514/* Determine if first argument is a multiple of second argument.
6515 Return 0 if it is not, or is not easily determined to so be.
6516
6517 An example of the sort of thing we care about (at this point --
6518 this routine could surely be made more general, and expanded
6519 to do what the *_DIV_EXPR's fold() cases do now) is discovering
6520 that
6521
6522 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6523
6524 is a multiple of
6525
6526 SAVE_EXPR (J * 8)
6527
6528 when we know that the two `SAVE_EXPR (J * 8)' nodes are the
6529 same node (which means they will have the same value at run
6530 time, even though we don't know when they'll be assigned).
6531
6532 This code also handles discovering that
6533
6534 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
6535
6536 is a multiple of
6537
6538 8
6539
6540 (of course) so we don't have to worry about dealing with a
6541 possible remainder.
6542
6543 Note that we _look_ inside a SAVE_EXPR only to determine
6544 how it was calculated; it is not safe for fold() to do much
6545 of anything else with the internals of a SAVE_EXPR, since
6546 fold() cannot know when it will be evaluated at run time.
6547 For example, the latter example above _cannot_ be implemented
6548 as
6549
6550 SAVE_EXPR (I) * J
6551
6552 or any variant thereof, since the value of J at evaluation time
6553 of the original SAVE_EXPR is not necessarily the same at the time
6554 the new expression is evaluated. The only optimization of this
6555 sort that would be valid is changing
6556
6557 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
6558 divided by
6559 8
6560
6561 to
6562
6563 SAVE_EXPR (I) * SAVE_EXPR (J)
6564
6565 (where the same SAVE_EXPR (J) is used in the original and the
6566 transformed version). */
6567
6568static int
6569multiple_of_p (type, top, bottom)
6570 tree type;
6571 tree top;
6572 tree bottom;
6573{
6574 if (operand_equal_p (top, bottom, 0))
6575 return 1;
6576
6577 if (TREE_CODE (type) != INTEGER_TYPE)
6578 return 0;
6579
6580 switch (TREE_CODE (top))
6581 {
6582 case MULT_EXPR:
6583 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6584 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6585
6586 case PLUS_EXPR:
6587 case MINUS_EXPR:
6588 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
6589 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
6590
6591 case NOP_EXPR:
6592 /* Punt if conversion from non-integral or wider integral type. */
6593 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
6594 || (TYPE_PRECISION (type)
6595 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
6596 return 0;
6597 /* Fall through. */
6598 case SAVE_EXPR:
6599 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
6600
6601 case INTEGER_CST:
6602 if ((TREE_CODE (bottom) != INTEGER_CST)
6603 || (tree_int_cst_sgn (top) < 0)
6604 || (tree_int_cst_sgn (bottom) < 0))
6605 return 0;
6606 return integer_zerop (const_binop (TRUNC_MOD_EXPR,
6607 top, bottom, 0));
6608
6609 default:
6610 return 0;
6611 }
6612}
6613
|