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 "toplev.h"
51
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));
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;
380 int prec;
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. */
531 if (hden == 0 && lden < 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, &ltwice, &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{
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}
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
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;
1274 REAL_VALUE_TYPE value;
1275 tree t;
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;
1286 else if (setjmp (float_error))
1287 {
1288 t = copy_node (arg1);
1289 overflow = 1;
1290 goto got_float;
1291 }
1292
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
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 {
1652 if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
1653 {
1654 t = arg1;
1655 TREE_TYPE (arg1) = type;
1656 return t;
1657 }
1658 else if (setjmp (float_error))
1659 {
1660 overflow = 1;
1661 t = copy_node (arg1);
1662 goto got_it;
1663 }
1664 set_float_handler (float_error);
1665
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
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. */
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)
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 }
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 }
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 }
2154 /* 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)))
2239 && 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 {
2540 warning ("comparison is always %s due to width of bitfield",
2541 code == NE_EXPR ? "one" : "zero");
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 {
2553 warning ("comparison is always %s due to width of bitfield",
2554 code == NE_EXPR ? "one" : "zero");
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;
2835 tree arg0, arg1, 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
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:
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
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;
3434 tree type, 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 {
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)));
3539 }
3540 else
3541 return 0;
3542 }
3543
3544 if (rcode != wanted_code)
3545 {
3546 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
3547 {
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)));
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);
3572 type = 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
3581 ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
3582 size_int (xll_bitpos), 0);
3583 rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
3584 size_int (xrl_bitpos), 0);
3585
3586 if (l_const)
3587 {
3588 l_const = convert (type, 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,
3593 type, ll_mask)),
3594 0)))
3595 {
3596 warning ("comparison is always %s",
3597 wanted_code == NE_EXPR ? "one" : "zero");
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 {
3606 r_const = convert (type, 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,
3611 type, rl_mask)),
3612 0)))
3613 {
3614 warning ("comparison is always %s",
3615 wanted_code == NE_EXPR ? "one" : "zero");
3616
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);
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
3653 lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
3654 size_int (xlr_bitpos), 0);
3655 rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
3656 size_int (xrr_bitpos), 0);
3657
3658 /* 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
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);
3664 if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
3665 {
3666 lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
3667 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))
3671 {
3672 lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
3673 rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
3674 }
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
3680 field containing them both. */
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))
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));
3694
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 {
3714 warning ("`and' of mutually exclusive equal-tests is always zero");
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. */
3723 result = make_bit_field_ref (ll_inner, type, 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))
3728 result = build (BIT_AND_EXPR, type, 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
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) != '<'))
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) != '<'))
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
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. */
4431
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)));
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);
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);
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);
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;
5827 arg1 = TREE_OPERAND (t, 2);
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:
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:
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;
6016 arg1 = TREE_OPERAND (t, 2);
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))
6052 return non_lvalue (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