![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fold-const.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to fold-const.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Fold a constant sub-tree into a single node for C-compiler
2: Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /*@@ Fix lossage on folding division of big integers. */
21:
22: /*@@ This file should be rewritten to use an arbitrary precision
23: @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
24: @@ Perhaps the routines could also be used for bc/dc, and made a lib.
25: @@ The routines that translate from the ap rep should
26: @@ warn if precision et. al. is lost.
27: @@ This would also make life easier when this technology is used
28: @@ for cross-compilers. */
29:
30:
31: /* The entry points in this file are fold, size_int and size_binop.
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: #include <stdio.h>
43: #include <setjmp.h>
44: #include "config.h"
45: #include "flags.h"
46: #include "tree.h"
47:
48: /* Handle floating overflow for `const_binop'. */
49: static jmp_buf float_error;
50:
51: static void encode PROTO((short *, HOST_WIDE_INT, HOST_WIDE_INT));
52: static void decode PROTO((short *, HOST_WIDE_INT *, HOST_WIDE_INT *));
53: static int div_and_round_double PROTO((enum tree_code, int, HOST_WIDE_INT,
54: HOST_WIDE_INT, HOST_WIDE_INT,
55: HOST_WIDE_INT, HOST_WIDE_INT *,
56: HOST_WIDE_INT *, HOST_WIDE_INT *,
57: HOST_WIDE_INT *));
58: static int split_tree PROTO((tree, enum tree_code, tree *, tree *, int *));
59: static tree const_binop PROTO((enum tree_code, tree, tree, int));
60: static tree fold_convert PROTO((tree, tree));
61: static enum tree_code invert_tree_comparison PROTO((enum tree_code));
62: static enum tree_code swap_tree_comparison PROTO((enum tree_code));
63: static int operand_equal_for_comparison_p PROTO((tree, tree, tree));
64: static int twoval_comparison_p PROTO((tree, tree *, tree *, int *));
65: static tree eval_subst PROTO((tree, tree, tree, tree, tree));
66: static tree omit_one_operand PROTO((tree, tree, tree));
67: static tree distribute_bit_expr PROTO((enum tree_code, tree, tree, tree));
68: static tree make_bit_field_ref PROTO((tree, tree, int, int, int));
69: static tree optimize_bit_field_compare PROTO((enum tree_code, tree,
70: tree, tree));
71: static tree decode_field_reference PROTO((tree, int *, int *,
72: enum machine_mode *, int *,
73: int *, tree *));
74: static int all_ones_mask_p PROTO((tree, int));
75: static int simple_operand_p PROTO((tree));
76: static tree range_test PROTO((enum tree_code, tree, enum tree_code,
77: enum tree_code, tree, tree, tree));
78: static tree fold_truthop PROTO((enum tree_code, tree, tree, tree));
79:
80: #ifndef BRANCH_COST
81: #define BRANCH_COST 1
82: #endif
83:
84: /* Yield nonzero if a signed left shift of A by B bits overflows. */
85: #define left_shift_overflows(a, b) ((a) != ((a) << (b)) >> (b))
86:
87: /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
88: Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
89: Then this yields nonzero if overflow occurred during the addition.
90: Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
91: Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
92: #define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
93:
94: /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
95: We do that by representing the two-word integer as MAX_SHORTS shorts,
96: with only 8 bits stored in each short, as a positive number. */
97:
98: /* Unpack a two-word integer into MAX_SHORTS shorts.
99: LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
100: SHORTS points to the array of shorts. */
101:
102: static void
103: encode (shorts, low, hi)
104: short *shorts;
105: HOST_WIDE_INT low, hi;
106: {
107: register int i;
108:
109: for (i = 0; i < MAX_SHORTS / 2; i++)
110: {
111: shorts[i] = (low >> (i * 8)) & 0xff;
112: shorts[i + MAX_SHORTS / 2] = (hi >> (i * 8) & 0xff);
113: }
114: }
115:
116: /* Pack an array of MAX_SHORTS shorts into a two-word integer.
117: SHORTS points to the array of shorts.
118: The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces. */
119:
120: static void
121: decode (shorts, low, hi)
122: short *shorts;
123: HOST_WIDE_INT *low, *hi;
124: {
125: register int i;
126: HOST_WIDE_INT lv = 0, hv = 0;
127:
128: for (i = 0; i < MAX_SHORTS / 2; i++)
129: {
130: lv |= (HOST_WIDE_INT) shorts[i] << (i * 8);
131: hv |= (HOST_WIDE_INT) shorts[i + MAX_SHORTS / 2] << (i * 8);
132: }
133:
134: *low = lv, *hi = hv;
135: }
136:
137: /* Make the integer constant T valid for its type
138: by setting to 0 or 1 all the bits in the constant
139: that don't belong in the type.
140: Yield 1 if a signed overflow occurs, 0 otherwise.
141: If OVERFLOW is nonzero, a signed overflow has already occurred
142: in calculating T, so propagate it. */
143:
144: int
145: force_fit_type (t, overflow)
146: tree t;
147: int overflow;
148: {
149: HOST_WIDE_INT low, high;
150: register int prec;
151:
152: if (TREE_CODE (t) != INTEGER_CST)
153: return overflow;
154:
155: low = TREE_INT_CST_LOW (t);
156: high = TREE_INT_CST_HIGH (t);
157:
158: if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
159: prec = POINTER_SIZE;
160: else
161: prec = TYPE_PRECISION (TREE_TYPE (t));
162:
163: /* First clear all bits that are beyond the type's precision. */
164:
165: if (prec == 2 * HOST_BITS_PER_WIDE_INT)
166: ;
167: else if (prec > HOST_BITS_PER_WIDE_INT)
168: {
169: TREE_INT_CST_HIGH (t)
170: &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
171: }
172: else
173: {
174: TREE_INT_CST_HIGH (t) = 0;
175: if (prec < HOST_BITS_PER_WIDE_INT)
176: TREE_INT_CST_LOW (t) &= ~((HOST_WIDE_INT) (-1) << prec);
177: }
178:
179: /* Unsigned types do not suffer sign extension or overflow. */
180: if (TREE_UNSIGNED (TREE_TYPE (t)))
181: return 0;
182:
183: /* If the value's sign bit is set, extend the sign. */
184: if (prec != 2 * HOST_BITS_PER_WIDE_INT
185: && (prec > HOST_BITS_PER_WIDE_INT
186: ? (TREE_INT_CST_HIGH (t)
187: & ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
188: : TREE_INT_CST_LOW (t) & ((HOST_WIDE_INT) 1 << (prec - 1))))
189: {
190: /* Value is negative:
191: set to 1 all the bits that are outside this type's precision. */
192: if (prec > HOST_BITS_PER_WIDE_INT)
193: {
194: TREE_INT_CST_HIGH (t)
195: |= ((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
196: }
197: else
198: {
199: TREE_INT_CST_HIGH (t) = -1;
200: if (prec < HOST_BITS_PER_WIDE_INT)
201: TREE_INT_CST_LOW (t) |= ((HOST_WIDE_INT) (-1) << prec);
202: }
203: }
204:
205: /* Yield nonzero if signed overflow occurred. */
206: return
207: ((overflow | (low ^ TREE_INT_CST_LOW (t)) | (high ^ TREE_INT_CST_HIGH (t)))
208: != 0);
209: }
210:
211: /* Add two doubleword integers with doubleword result.
212: Each argument is given as two `HOST_WIDE_INT' pieces.
213: One argument is L1 and H1; the other, L2 and H2.
214: The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
215: We use the 8-shorts representation internally. */
216:
217: int
218: add_double (l1, h1, l2, h2, lv, hv)
219: HOST_WIDE_INT l1, h1, l2, h2;
220: HOST_WIDE_INT *lv, *hv;
221: {
222: short arg1[MAX_SHORTS];
223: short arg2[MAX_SHORTS];
224: register int carry = 0;
225: register int i;
226:
227: encode (arg1, l1, h1);
228: encode (arg2, l2, h2);
229:
230: for (i = 0; i < MAX_SHORTS; i++)
231: {
232: carry += arg1[i] + arg2[i];
233: arg1[i] = carry & 0xff;
234: carry >>= 8;
235: }
236:
237: decode (arg1, lv, hv);
238: return overflow_sum_sign (h1, h2, *hv);
239: }
240:
241: /* Negate a doubleword integer with doubleword result.
242: Return nonzero if the operation overflows, assuming it's signed.
243: The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
244: The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
245: We use the 8-shorts representation internally. */
246:
247: int
248: neg_double (l1, h1, lv, hv)
249: HOST_WIDE_INT l1, h1;
250: HOST_WIDE_INT *lv, *hv;
251: {
252: if (l1 == 0)
253: {
254: *lv = 0;
255: *hv = - h1;
256: return (*hv & h1) < 0;
257: }
258: else
259: {
260: *lv = - l1;
261: *hv = ~ h1;
262: return 0;
263: }
264: }
265:
266: /* Multiply two doubleword integers with doubleword result.
267: Return nonzero if the operation overflows, assuming it's signed.
268: Each argument is given as two `HOST_WIDE_INT' pieces.
269: One argument is L1 and H1; the other, L2 and H2.
270: The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.
271: We use the 8-shorts representation internally. */
272:
273: int
274: mul_double (l1, h1, l2, h2, lv, hv)
275: HOST_WIDE_INT l1, h1, l2, h2;
276: HOST_WIDE_INT *lv, *hv;
277: {
278: short arg1[MAX_SHORTS];
279: short arg2[MAX_SHORTS];
280: short prod[MAX_SHORTS * 2];
281: register int carry = 0;
282: register int i, j, k;
283: HOST_WIDE_INT toplow, tophigh, neglow, neghigh;
284:
285: /* These cases are used extensively, arising from pointer combinations. */
286: if (h2 == 0)
287: {
288: if (l2 == 2)
289: {
290: int overflow = left_shift_overflows (h1, 1);
291: unsigned HOST_WIDE_INT temp = l1 + l1;
292: *hv = (h1 << 1) + (temp < l1);
293: *lv = temp;
294: return overflow;
295: }
296: if (l2 == 4)
297: {
298: int overflow = left_shift_overflows (h1, 2);
299: unsigned HOST_WIDE_INT temp = l1 + l1;
300: h1 = (h1 << 2) + ((temp < l1) << 1);
301: l1 = temp;
302: temp += temp;
303: h1 += (temp < l1);
304: *lv = temp;
305: *hv = h1;
306: return overflow;
307: }
308: if (l2 == 8)
309: {
310: int overflow = left_shift_overflows (h1, 3);
311: unsigned HOST_WIDE_INT temp = l1 + l1;
312: h1 = (h1 << 3) + ((temp < l1) << 2);
313: l1 = temp;
314: temp += temp;
315: h1 += (temp < l1) << 1;
316: l1 = temp;
317: temp += temp;
318: h1 += (temp < l1);
319: *lv = temp;
320: *hv = h1;
321: return overflow;
322: }
323: }
324:
325: encode (arg1, l1, h1);
326: encode (arg2, l2, h2);
327:
328: bzero (prod, sizeof prod);
329:
330: for (i = 0; i < MAX_SHORTS; i++)
331: for (j = 0; j < MAX_SHORTS; j++)
332: {
333: k = i + j;
334: carry = arg1[i] * arg2[j];
335: while (carry)
336: {
337: carry += prod[k];
338: prod[k] = carry & 0xff;
339: carry >>= 8;
340: k++;
341: }
342: }
343:
344: decode (prod, lv, hv); /* This ignores
345: prod[MAX_SHORTS] -> prod[MAX_SHORTS*2-1] */
346:
347: /* Check for overflow by calculating the top half of the answer in full;
348: it should agree with the low half's sign bit. */
349: decode (prod+MAX_SHORTS, &toplow, &tophigh);
350: if (h1 < 0)
351: {
352: neg_double (l2, h2, &neglow, &neghigh);
353: add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
354: }
355: if (h2 < 0)
356: {
357: neg_double (l1, h1, &neglow, &neghigh);
358: add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
359: }
360: return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
361: }
362:
363: /* Shift the doubleword integer in L1, H1 left by COUNT places
364: keeping only PREC bits of result.
365: Shift right if COUNT is negative.
366: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
367: Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
368:
369: void
370: lshift_double (l1, h1, count, prec, lv, hv, arith)
371: HOST_WIDE_INT l1, h1, count;
372: int prec;
373: HOST_WIDE_INT *lv, *hv;
374: int arith;
375: {
376: short arg1[MAX_SHORTS];
377: register int i;
378: register int carry;
379:
380: if (count < 0)
381: {
382: rshift_double (l1, h1, - count, prec, lv, hv, arith);
383: return;
384: }
385:
386: encode (arg1, l1, h1);
387:
388: if (count > prec)
389: count = prec;
390:
391: while (count > 0)
392: {
393: carry = 0;
394: for (i = 0; i < MAX_SHORTS; i++)
395: {
396: carry += arg1[i] << 1;
397: arg1[i] = carry & 0xff;
398: carry >>= 8;
399: }
400: count--;
401: }
402:
403: decode (arg1, lv, hv);
404: }
405:
406: /* Shift the doubleword integer in L1, H1 right by COUNT places
407: keeping only PREC bits of result. COUNT must be positive.
408: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
409: Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
410:
411: void
412: rshift_double (l1, h1, count, prec, lv, hv, arith)
413: HOST_WIDE_INT l1, h1, count;
414: int prec;
415: HOST_WIDE_INT *lv, *hv;
416: int arith;
417: {
418: short arg1[MAX_SHORTS];
419: register int i;
420: register int carry;
421:
422: encode (arg1, l1, h1);
423:
424: if (count > prec)
425: count = prec;
426:
427: while (count > 0)
428: {
429: carry = arith && arg1[7] >> 7;
430: for (i = MAX_SHORTS - 1; i >= 0; i--)
431: {
432: carry <<= 8;
433: carry += arg1[i];
434: arg1[i] = (carry >> 1) & 0xff;
435: }
436: count--;
437: }
438:
439: decode (arg1, lv, hv);
440: }
441:
442: /* Rotate the doubldword integer in L1, H1 left by COUNT places
443: keeping only PREC bits of result.
444: Rotate right if COUNT is negative.
445: Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
446:
447: void
448: lrotate_double (l1, h1, count, prec, lv, hv)
449: HOST_WIDE_INT l1, h1, count;
450: int prec;
451: HOST_WIDE_INT *lv, *hv;
452: {
453: short arg1[MAX_SHORTS];
454: register int i;
455: register int carry;
456:
457: if (count < 0)
458: {
459: rrotate_double (l1, h1, - count, prec, lv, hv);
460: return;
461: }
462:
463: encode (arg1, l1, h1);
464:
465: if (count > prec)
466: count = prec;
467:
468: carry = arg1[MAX_SHORTS - 1] >> 7;
469: while (count > 0)
470: {
471: for (i = 0; i < MAX_SHORTS; i++)
472: {
473: carry += arg1[i] << 1;
474: arg1[i] = carry & 0xff;
475: carry >>= 8;
476: }
477: count--;
478: }
479:
480: decode (arg1, lv, hv);
481: }
482:
483: /* Rotate the doubleword integer in L1, H1 left by COUNT places
484: keeping only PREC bits of result. COUNT must be positive.
485: Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV. */
486:
487: void
488: rrotate_double (l1, h1, count, prec, lv, hv)
489: HOST_WIDE_INT l1, h1, count;
490: int prec;
491: HOST_WIDE_INT *lv, *hv;
492: {
493: short arg1[MAX_SHORTS];
494: register int i;
495: register int carry;
496:
497: encode (arg1, l1, h1);
498:
499: if (count > prec)
500: count = prec;
501:
502: carry = arg1[0] & 1;
503: while (count > 0)
504: {
505: for (i = MAX_SHORTS - 1; i >= 0; i--)
506: {
507: carry <<= 8;
508: carry += arg1[i];
509: arg1[i] = (carry >> 1) & 0xff;
510: }
511: count--;
512: }
513:
514: decode (arg1, lv, hv);
515: }
516:
517: /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
518: for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
519: CODE is a tree code for a kind of division, one of
520: TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
521: or EXACT_DIV_EXPR
522: It controls how the quotient is rounded to a integer.
523: Return nonzero if the operation overflows.
524: UNS nonzero says do unsigned division. */
525:
526: static int
527: div_and_round_double (code, uns,
528: lnum_orig, hnum_orig, lden_orig, hden_orig,
529: lquo, hquo, lrem, hrem)
530: enum tree_code code;
531: int uns;
532: HOST_WIDE_INT lnum_orig, hnum_orig; /* num == numerator == dividend */
533: HOST_WIDE_INT lden_orig, hden_orig; /* den == denominator == divisor */
534: HOST_WIDE_INT *lquo, *hquo, *lrem, *hrem;
535: {
536: int quo_neg = 0;
537: short num[MAX_SHORTS + 1]; /* extra element for scaling. */
538: short den[MAX_SHORTS], quo[MAX_SHORTS];
539: register int i, j, work;
540: register int carry = 0;
541: HOST_WIDE_INT lnum = lnum_orig;
542: HOST_WIDE_INT hnum = hnum_orig;
543: HOST_WIDE_INT lden = lden_orig;
544: HOST_WIDE_INT hden = hden_orig;
545: int overflow = 0;
546:
547: if ((hden == 0) && (lden == 0))
548: abort ();
549:
550: /* calculate quotient sign and convert operands to unsigned. */
551: if (!uns)
552: {
553: if (hnum < 0)
554: {
555: quo_neg = ~ quo_neg;
556: /* (minimum integer) / (-1) is the only overflow case. */
557: if (neg_double (lnum, hnum, &lnum, &hnum) && (lden & hden) == -1)
558: overflow = 1;
559: }
560: if (hden < 0)
561: {
562: quo_neg = ~ quo_neg;
563: neg_double (lden, hden, &lden, &hden);
564: }
565: }
566:
567: if (hnum == 0 && hden == 0)
568: { /* single precision */
569: *hquo = *hrem = 0;
570: /* This unsigned division rounds toward zero. */
571: *lquo = lnum / (unsigned HOST_WIDE_INT) lden;
572: goto finish_up;
573: }
574:
575: if (hnum == 0)
576: { /* trivial case: dividend < divisor */
577: /* hden != 0 already checked. */
578: *hquo = *lquo = 0;
579: *hrem = hnum;
580: *lrem = lnum;
581: goto finish_up;
582: }
583:
584: bzero (quo, sizeof quo);
585:
586: bzero (num, sizeof num); /* to zero 9th element */
587: bzero (den, sizeof den);
588:
589: encode (num, lnum, hnum);
590: encode (den, lden, hden);
591:
592: /* This code requires more than just hden == 0.
593: We also have to require that we don't need more than three bytes
594: to hold CARRY. If we ever did need four bytes to hold it, we
595: would lose part of it when computing WORK on the next round. */
596: if (hden == 0 && (((unsigned HOST_WIDE_INT) lden << 8) >> 8) == lden)
597: { /* simpler algorithm */
598: /* hnum != 0 already checked. */
599: for (i = MAX_SHORTS - 1; i >= 0; i--)
600: {
601: work = num[i] + (carry << 8);
602: quo[i] = work / (unsigned HOST_WIDE_INT) lden;
603: carry = work % (unsigned HOST_WIDE_INT) lden;
604: }
605: }
606: else { /* full double precision,
607: with thanks to Don Knuth's
608: "Seminumerical Algorithms". */
609: #define BASE 256
610: int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
611:
612: /* Find the highest non-zero divisor digit. */
613: for (i = MAX_SHORTS - 1; ; i--)
614: if (den[i] != 0) {
615: den_hi_sig = i;
616: break;
617: }
618: for (i = MAX_SHORTS - 1; ; i--)
619: if (num[i] != 0) {
620: num_hi_sig = i;
621: break;
622: }
623: quo_hi_sig = num_hi_sig - den_hi_sig + 1;
624:
625: /* Insure that the first digit of the divisor is at least BASE/2.
626: This is required by the quotient digit estimation algorithm. */
627:
628: scale = BASE / (den[den_hi_sig] + 1);
629: if (scale > 1) { /* scale divisor and dividend */
630: carry = 0;
631: for (i = 0; i <= MAX_SHORTS - 1; i++) {
632: work = (num[i] * scale) + carry;
633: num[i] = work & 0xff;
634: carry = work >> 8;
635: if (num[i] != 0) num_hi_sig = i;
636: }
637: carry = 0;
638: for (i = 0; i <= MAX_SHORTS - 1; i++) {
639: work = (den[i] * scale) + carry;
640: den[i] = work & 0xff;
641: carry = work >> 8;
642: if (den[i] != 0) den_hi_sig = i;
643: }
644: }
645:
646: /* Main loop */
647: for (i = quo_hi_sig; i > 0; i--) {
648: /* guess the next quotient digit, quo_est, by dividing the first
649: two remaining dividend digits by the high order quotient digit.
650: quo_est is never low and is at most 2 high. */
651:
652: int num_hi; /* index of highest remaining dividend digit */
653:
654: num_hi = i + den_hi_sig;
655:
656: work = (num[num_hi] * BASE) + (num_hi > 0 ? num[num_hi - 1] : 0);
657: if (num[num_hi] != den[den_hi_sig]) {
658: quo_est = work / den[den_hi_sig];
659: }
660: else {
661: quo_est = BASE - 1;
662: }
663:
664: /* refine quo_est so it's usually correct, and at most one high. */
665: while ((den[den_hi_sig - 1] * quo_est)
666: > (((work - (quo_est * den[den_hi_sig])) * BASE)
667: + ((num_hi - 1) > 0 ? num[num_hi - 2] : 0)))
668: quo_est--;
669:
670: /* Try QUO_EST as the quotient digit, by multiplying the
671: divisor by QUO_EST and subtracting from the remaining dividend.
672: Keep in mind that QUO_EST is the I - 1st digit. */
673:
674: carry = 0;
675:
676: for (j = 0; j <= den_hi_sig; j++)
677: {
678: int digit;
679:
680: work = num[i + j - 1] - (quo_est * den[j]) + carry;
681: digit = work & 0xff;
682: carry = work >> 8;
683: if (digit < 0)
684: {
685: digit += BASE;
686: carry--;
687: }
688: num[i + j - 1] = digit;
689: }
690:
691: /* if quo_est was high by one, then num[i] went negative and
692: we need to correct things. */
693:
694: if (num[num_hi] < 0)
695: {
696: quo_est--;
697: carry = 0; /* add divisor back in */
698: for (j = 0; j <= den_hi_sig; j++)
699: {
700: work = num[i + j - 1] + den[j] + carry;
701: if (work > BASE)
702: {
703: work -= BASE;
704: carry = 1;
705: }
706: else
707: {
708: carry = 0;
709: }
710: num[i + j - 1] = work;
711: }
712: num [num_hi] += carry;
713: }
714:
715: /* store the quotient digit. */
716: quo[i - 1] = quo_est;
717: }
718: }
719:
720: decode (quo, lquo, hquo);
721:
722: finish_up:
723: /* if result is negative, make it so. */
724: if (quo_neg)
725: neg_double (*lquo, *hquo, lquo, hquo);
726:
727: /* compute trial remainder: rem = num - (quo * den) */
728: mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
729: neg_double (*lrem, *hrem, lrem, hrem);
730: add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
731:
732: switch (code)
733: {
734: case TRUNC_DIV_EXPR:
735: case TRUNC_MOD_EXPR: /* round toward zero */
736: case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
737: return overflow;
738:
739: case FLOOR_DIV_EXPR:
740: case FLOOR_MOD_EXPR: /* round toward negative infinity */
741: if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
742: {
743: /* quo = quo - 1; */
744: add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1,
745: lquo, hquo);
746: }
747: else return overflow;
748: break;
749:
750: case CEIL_DIV_EXPR:
751: case CEIL_MOD_EXPR: /* round toward positive infinity */
752: if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
753: {
754: add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
755: lquo, hquo);
756: }
757: else return overflow;
758: break;
759:
760: case ROUND_DIV_EXPR:
761: case ROUND_MOD_EXPR: /* round to closest integer */
762: {
763: HOST_WIDE_INT labs_rem = *lrem, habs_rem = *hrem;
764: HOST_WIDE_INT labs_den = lden, habs_den = hden, ltwice, htwice;
765:
766: /* get absolute values */
767: if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
768: if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
769:
770: /* if (2 * abs (lrem) >= abs (lden)) */
771: mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
772: labs_rem, habs_rem, <wice, &htwice);
773: if (((unsigned HOST_WIDE_INT) habs_den
774: < (unsigned HOST_WIDE_INT) htwice)
775: || (((unsigned HOST_WIDE_INT) habs_den
776: == (unsigned HOST_WIDE_INT) htwice)
777: && ((HOST_WIDE_INT unsigned) labs_den
778: < (unsigned HOST_WIDE_INT) ltwice)))
779: {
780: if (*hquo < 0)
781: /* quo = quo - 1; */
782: add_double (*lquo, *hquo,
783: (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
784: else
785: /* quo = quo + 1; */
786: add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
787: lquo, hquo);
788: }
789: else return overflow;
790: }
791: break;
792:
793: default:
794: abort ();
795: }
796:
797: /* compute true remainder: rem = num - (quo * den) */
798: mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
799: neg_double (*lrem, *hrem, lrem, hrem);
800: add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
801: return overflow;
802: }
803:
804: #ifndef REAL_ARITHMETIC
805: /* Effectively truncate a real value to represent
806: the nearest possible value in a narrower mode.
807: The result is actually represented in the same data type as the argument,
808: but its value is usually different. */
809:
810: REAL_VALUE_TYPE
811: real_value_truncate (mode, arg)
812: enum machine_mode mode;
813: REAL_VALUE_TYPE arg;
814: {
815: #ifdef __STDC__
816: /* Make sure the value is actually stored in memory before we turn off
817: the handler. */
818: volatile
819: #endif
820: REAL_VALUE_TYPE value;
821: jmp_buf handler, old_handler;
822: int handled;
823:
824: if (setjmp (handler))
825: {
826: error ("floating overflow");
827: return dconst0;
828: }
829: handled = push_float_handler (handler, old_handler);
830: value = REAL_VALUE_TRUNCATE (mode, arg);
831: pop_float_handler (handled, old_handler);
832: return value;
833: }
834:
835: #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
836:
837: /* Check for infinity in an IEEE double precision number. */
838:
839: int
840: target_isinf (x)
841: REAL_VALUE_TYPE x;
842: {
843: /* The IEEE 64-bit double format. */
844: union {
845: REAL_VALUE_TYPE d;
846: struct {
847: unsigned sign : 1;
848: unsigned exponent : 11;
849: unsigned mantissa1 : 20;
850: unsigned mantissa2;
851: } little_endian;
852: struct {
853: unsigned mantissa2;
854: unsigned mantissa1 : 20;
855: unsigned exponent : 11;
856: unsigned sign : 1;
857: } big_endian;
858: } u;
859:
860: u.d = dconstm1;
861: if (u.big_endian.sign == 1)
862: {
863: u.d = x;
864: return (u.big_endian.exponent == 2047
865: && u.big_endian.mantissa1 == 0
866: && u.big_endian.mantissa2 == 0);
867: }
868: else
869: {
870: u.d = x;
871: return (u.little_endian.exponent == 2047
872: && u.little_endian.mantissa1 == 0
873: && u.little_endian.mantissa2 == 0);
874: }
875: }
876:
877: /* Check whether an IEEE double precision number is a NaN. */
878:
879: int
880: target_isnan (x)
881: REAL_VALUE_TYPE x;
882: {
883: /* The IEEE 64-bit double format. */
884: union {
885: REAL_VALUE_TYPE d;
886: struct {
887: unsigned sign : 1;
888: unsigned exponent : 11;
889: unsigned mantissa1 : 20;
890: unsigned mantissa2;
891: } little_endian;
892: struct {
893: unsigned mantissa2;
894: unsigned mantissa1 : 20;
895: unsigned exponent : 11;
896: unsigned sign : 1;
897: } big_endian;
898: } u;
899:
900: u.d = dconstm1;
901: if (u.big_endian.sign == 1)
902: {
903: u.d = x;
904: return (u.big_endian.exponent == 2047
905: && (u.big_endian.mantissa1 != 0
906: || u.big_endian.mantissa2 != 0));
907: }
908: else
909: {
910: u.d = x;
911: return (u.little_endian.exponent == 2047
912: && (u.little_endian.mantissa1 != 0
913: || u.little_endian.mantissa2 != 0));
914: }
915: }
916:
917: /* Check for a negative IEEE double precision number. */
918:
919: int
920: target_negative (x)
921: REAL_VALUE_TYPE x;
922: {
923: /* The IEEE 64-bit double format. */
924: union {
925: REAL_VALUE_TYPE d;
926: struct {
927: unsigned sign : 1;
928: unsigned exponent : 11;
929: unsigned mantissa1 : 20;
930: unsigned mantissa2;
931: } little_endian;
932: struct {
933: unsigned mantissa2;
934: unsigned mantissa1 : 20;
935: unsigned exponent : 11;
936: unsigned sign : 1;
937: } big_endian;
938: } u;
939:
940: u.d = dconstm1;
941: if (u.big_endian.sign == 1)
942: {
943: u.d = x;
944: return u.big_endian.sign;
945: }
946: else
947: {
948: u.d = x;
949: return u.little_endian.sign;
950: }
951: }
952: #else /* Target not IEEE */
953:
954: /* Let's assume other float formats don't have infinity.
955: (This can be overridden by redefining REAL_VALUE_ISINF.) */
956:
957: target_isinf (x)
958: REAL_VALUE_TYPE x;
959: {
960: return 0;
961: }
962:
963: /* Let's assume other float formats don't have NaNs.
964: (This can be overridden by redefining REAL_VALUE_ISNAN.) */
965:
966: target_isnan (x)
967: REAL_VALUE_TYPE x;
968: {
969: return 0;
970: }
971:
972: /* Let's assume other float formats don't have minus zero.
973: (This can be overridden by redefining REAL_VALUE_NEGATIVE.) */
974:
975: target_negative (x)
976: REAL_VALUE_TYPE x;
977: {
978: return x < 0;
979: }
980: #endif /* Target not IEEE */
981: #endif /* no REAL_ARITHMETIC */
982:
983: /* Split a tree IN into a constant and a variable part
984: that could be combined with CODE to make IN.
985: CODE must be a commutative arithmetic operation.
986: Store the constant part into *CONP and the variable in &VARP.
987: Return 1 if this was done; zero means the tree IN did not decompose
988: this way.
989:
990: If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
991: Therefore, we must tell the caller whether the variable part
992: was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
993: The value stored is the coefficient for the variable term.
994: The constant term we return should always be added;
995: we negate it if necessary. */
996:
997: static int
998: split_tree (in, code, varp, conp, varsignp)
999: tree in;
1000: enum tree_code code;
1001: tree *varp, *conp;
1002: int *varsignp;
1003: {
1004: register tree outtype = TREE_TYPE (in);
1005: *varp = 0;
1006: *conp = 0;
1007:
1008: /* Strip any conversions that don't change the machine mode. */
1009: while ((TREE_CODE (in) == NOP_EXPR
1010: || TREE_CODE (in) == CONVERT_EXPR)
1011: && (TYPE_MODE (TREE_TYPE (in))
1012: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
1013: in = TREE_OPERAND (in, 0);
1014:
1015: if (TREE_CODE (in) == code
1016: || (! FLOAT_TYPE_P (TREE_TYPE (in))
1017: /* We can associate addition and subtraction together
1018: (even though the C standard doesn't say so)
1019: for integers because the value is not affected.
1020: For reals, the value might be affected, so we can't. */
1021: && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1022: || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1023: {
1024: enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
1025: if (code == INTEGER_CST)
1026: {
1027: *conp = TREE_OPERAND (in, 0);
1028: *varp = TREE_OPERAND (in, 1);
1029: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1030: && TREE_TYPE (*varp) != outtype)
1031: *varp = convert (outtype, *varp);
1032: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1033: return 1;
1034: }
1035: if (TREE_CONSTANT (TREE_OPERAND (in, 1)))
1036: {
1037: *conp = TREE_OPERAND (in, 1);
1038: *varp = TREE_OPERAND (in, 0);
1039: *varsignp = 1;
1040: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1041: && TREE_TYPE (*varp) != outtype)
1042: *varp = convert (outtype, *varp);
1043: if (TREE_CODE (in) == MINUS_EXPR)
1044: {
1045: /* If operation is subtraction and constant is second,
1046: must negate it to get an additive constant.
1047: And this cannot be done unless it is a manifest constant.
1048: It could also be the address of a static variable.
1049: We cannot negate that, so give up. */
1050: if (TREE_CODE (*conp) == INTEGER_CST)
1051: /* Subtracting from integer_zero_node loses for long long. */
1052: *conp = fold (build1 (NEGATE_EXPR, TREE_TYPE (*conp), *conp));
1053: else
1054: return 0;
1055: }
1056: return 1;
1057: }
1058: if (TREE_CONSTANT (TREE_OPERAND (in, 0)))
1059: {
1060: *conp = TREE_OPERAND (in, 0);
1061: *varp = TREE_OPERAND (in, 1);
1062: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
1063: && TREE_TYPE (*varp) != outtype)
1064: *varp = convert (outtype, *varp);
1065: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
1066: return 1;
1067: }
1068: }
1069: return 0;
1070: }
1071:
1072: /* Combine two constants NUM and ARG2 under operation CODE
1073: to produce a new constant.
1074: We assume ARG1 and ARG2 have the same data type,
1075: or at least are the same kind of constant and the same machine mode.
1076:
1077: If NOTRUNC is nonzero, do not truncate the result to fit the data type. */
1078:
1079: static tree
1080: const_binop (code, arg1, arg2, notrunc)
1081: enum tree_code code;
1082: register tree arg1, arg2;
1083: int notrunc;
1084: {
1085: if (TREE_CODE (arg1) == INTEGER_CST)
1086: {
1087: register HOST_WIDE_INT int1l = TREE_INT_CST_LOW (arg1);
1088: register HOST_WIDE_INT int1h = TREE_INT_CST_HIGH (arg1);
1089: HOST_WIDE_INT int2l = TREE_INT_CST_LOW (arg2);
1090: HOST_WIDE_INT int2h = TREE_INT_CST_HIGH (arg2);
1091: HOST_WIDE_INT low, hi;
1092: HOST_WIDE_INT garbagel, garbageh;
1093: register tree t;
1094: int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
1095: int overflow = 0;
1096:
1097: switch (code)
1098: {
1099: case BIT_IOR_EXPR:
1100: t = build_int_2 (int1l | int2l, int1h | int2h);
1101: break;
1102:
1103: case BIT_XOR_EXPR:
1104: t = build_int_2 (int1l ^ int2l, int1h ^ int2h);
1105: break;
1106:
1107: case BIT_AND_EXPR:
1108: t = build_int_2 (int1l & int2l, int1h & int2h);
1109: break;
1110:
1111: case BIT_ANDTC_EXPR:
1112: t = build_int_2 (int1l & ~int2l, int1h & ~int2h);
1113: break;
1114:
1115: case RSHIFT_EXPR:
1116: int2l = - int2l;
1117: case LSHIFT_EXPR:
1118: /* It's unclear from the C standard whether shifts can overflow.
1119: The following code ignores overflow; perhaps a C standard
1120: interpretation ruling is needed. */
1121: lshift_double (int1l, int1h, int2l,
1122: TYPE_PRECISION (TREE_TYPE (arg1)),
1123: &low, &hi,
1124: !uns);
1125: t = build_int_2 (low, hi);
1126: TREE_TYPE (t) = TREE_TYPE (arg1);
1127: if (!notrunc)
1128: force_fit_type (t, 0);
1129: TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1130: TREE_CONSTANT_OVERFLOW (t)
1131: = TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2);
1132: return t;
1133:
1134: case RROTATE_EXPR:
1135: int2l = - int2l;
1136: case LROTATE_EXPR:
1137: lrotate_double (int1l, int1h, int2l,
1138: TYPE_PRECISION (TREE_TYPE (arg1)),
1139: &low, &hi);
1140: t = build_int_2 (low, hi);
1141: break;
1142:
1143: case PLUS_EXPR:
1144: if (int1h == 0)
1145: {
1146: int2l += int1l;
1147: if ((unsigned HOST_WIDE_INT) int2l < int1l)
1148: {
1149: hi = int2h++;
1150: overflow = int2h < hi;
1151: }
1152: t = build_int_2 (int2l, int2h);
1153: break;
1154: }
1155: if (int2h == 0)
1156: {
1157: int1l += int2l;
1158: if ((unsigned HOST_WIDE_INT) int1l < int2l)
1159: {
1160: hi = int1h++;
1161: overflow = int1h < hi;
1162: }
1163: t = build_int_2 (int1l, int1h);
1164: break;
1165: }
1166: overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1167: t = build_int_2 (low, hi);
1168: break;
1169:
1170: case MINUS_EXPR:
1171: if (int2h == 0 && int2l == 0)
1172: {
1173: t = build_int_2 (int1l, int1h);
1174: break;
1175: }
1176: neg_double (int2l, int2h, &low, &hi);
1177: add_double (int1l, int1h, low, hi, &low, &hi);
1178: overflow = overflow_sum_sign (hi, int2h, int1h);
1179: t = build_int_2 (low, hi);
1180: break;
1181:
1182: case MULT_EXPR:
1183: /* Optimize simple cases. */
1184: if (int1h == 0)
1185: {
1186: unsigned HOST_WIDE_INT temp;
1187:
1188: switch (int1l)
1189: {
1190: case 0:
1191: t = build_int_2 (0, 0);
1192: goto got_it;
1193: case 1:
1194: t = build_int_2 (int2l, int2h);
1195: goto got_it;
1196: case 2:
1197: overflow = left_shift_overflows (int2h, 1);
1198: temp = int2l + int2l;
1199: int2h = (int2h << 1) + (temp < int2l);
1200: t = build_int_2 (temp, int2h);
1201: goto got_it;
1202: #if 0 /* This code can lose carries. */
1203: case 3:
1204: temp = int2l + int2l + int2l;
1205: int2h = int2h * 3 + (temp < int2l);
1206: t = build_int_2 (temp, int2h);
1207: goto got_it;
1208: #endif
1209: case 4:
1210: overflow = left_shift_overflows (int2h, 2);
1211: temp = int2l + int2l;
1212: int2h = (int2h << 2) + ((temp < int2l) << 1);
1213: int2l = temp;
1214: temp += temp;
1215: int2h += (temp < int2l);
1216: t = build_int_2 (temp, int2h);
1217: goto got_it;
1218: case 8:
1219: overflow = left_shift_overflows (int2h, 3);
1220: temp = int2l + int2l;
1221: int2h = (int2h << 3) + ((temp < int2l) << 2);
1222: int2l = temp;
1223: temp += temp;
1224: int2h += (temp < int2l) << 1;
1225: int2l = temp;
1226: temp += temp;
1227: int2h += (temp < int2l);
1228: t = build_int_2 (temp, int2h);
1229: goto got_it;
1230: default:
1231: break;
1232: }
1233: }
1234:
1235: if (int2h == 0)
1236: {
1237: if (int2l == 0)
1238: {
1239: t = build_int_2 (0, 0);
1240: break;
1241: }
1242: if (int2l == 1)
1243: {
1244: t = build_int_2 (int1l, int1h);
1245: break;
1246: }
1247: }
1248:
1249: overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1250: t = build_int_2 (low, hi);
1251: break;
1252:
1253: case TRUNC_DIV_EXPR:
1254: case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1255: case EXACT_DIV_EXPR:
1256: /* This is a shortcut for a common special case.
1257: It reduces the number of tree nodes generated
1258: and saves time. */
1259: if (int2h == 0 && int2l > 0
1260: && TREE_TYPE (arg1) == sizetype
1261: && int1h == 0 && int1l >= 0)
1262: {
1263: if (code == CEIL_DIV_EXPR)
1264: int1l += int2l-1;
1265: return size_int (int1l / int2l);
1266: }
1267: case ROUND_DIV_EXPR:
1268: if (int2h == 0 && int2l == 1)
1269: {
1270: t = build_int_2 (int1l, int1h);
1271: break;
1272: }
1273: if (int1l == int2l && int1h == int2h)
1274: {
1275: if ((int1l | int1h) == 0)
1276: abort ();
1277: t = build_int_2 (1, 0);
1278: break;
1279: }
1280: overflow = div_and_round_double (code, uns,
1281: int1l, int1h, int2l, int2h,
1282: &low, &hi, &garbagel, &garbageh);
1283: t = build_int_2 (low, hi);
1284: break;
1285:
1286: case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR:
1287: case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1288: overflow = div_and_round_double (code, uns,
1289: int1l, int1h, int2l, int2h,
1290: &garbagel, &garbageh, &low, &hi);
1291: t = build_int_2 (low, hi);
1292: break;
1293:
1294: case MIN_EXPR:
1295: case MAX_EXPR:
1296: if (uns)
1297: {
1298: low = (((unsigned HOST_WIDE_INT) int1h
1299: < (unsigned HOST_WIDE_INT) int2h)
1300: || (((unsigned HOST_WIDE_INT) int1h
1301: == (unsigned HOST_WIDE_INT) int2h)
1302: && ((unsigned HOST_WIDE_INT) int1l
1303: < (unsigned HOST_WIDE_INT) int2l)));
1304: }
1305: else
1306: {
1307: low = ((int1h < int2h)
1308: || ((int1h == int2h)
1309: && ((unsigned HOST_WIDE_INT) int1l
1310: < (unsigned HOST_WIDE_INT) int2l)));
1311: }
1312: if (low == (code == MIN_EXPR))
1313: t = build_int_2 (int1l, int1h);
1314: else
1315: t = build_int_2 (int2l, int2h);
1316: break;
1317:
1318: default:
1319: abort ();
1320: }
1321: got_it:
1322: TREE_TYPE (t) = TREE_TYPE (arg1);
1323: TREE_OVERFLOW (t)
1324: = ((notrunc ? !uns && overflow : force_fit_type (t, overflow))
1325: | TREE_OVERFLOW (arg1)
1326: | TREE_OVERFLOW (arg2));
1327: TREE_CONSTANT_OVERFLOW (t) = (TREE_OVERFLOW (t)
1328: | TREE_CONSTANT_OVERFLOW (arg1)
1329: | TREE_CONSTANT_OVERFLOW (arg2));
1330: return t;
1331: }
1332: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1333: if (TREE_CODE (arg1) == REAL_CST)
1334: {
1335: REAL_VALUE_TYPE d1;
1336: REAL_VALUE_TYPE d2;
1337: REAL_VALUE_TYPE value;
1338: tree t;
1339:
1340: d1 = TREE_REAL_CST (arg1);
1341: d2 = TREE_REAL_CST (arg2);
1342: if (setjmp (float_error))
1343: {
1344: pedwarn ("floating overflow in constant expression");
1345: return build (code, TREE_TYPE (arg1), arg1, arg2);
1346: }
1347: set_float_handler (float_error);
1348:
1349: #ifdef REAL_ARITHMETIC
1350: REAL_ARITHMETIC (value, code, d1, d2);
1351: #else
1352: switch (code)
1353: {
1354: case PLUS_EXPR:
1355: value = d1 + d2;
1356: break;
1357:
1358: case MINUS_EXPR:
1359: value = d1 - d2;
1360: break;
1361:
1362: case MULT_EXPR:
1363: value = d1 * d2;
1364: break;
1365:
1366: case RDIV_EXPR:
1367: #ifndef REAL_INFINITY
1368: if (d2 == 0)
1369: abort ();
1370: #endif
1371:
1372: value = d1 / d2;
1373: break;
1374:
1375: case MIN_EXPR:
1376: value = MIN (d1, d2);
1377: break;
1378:
1379: case MAX_EXPR:
1380: value = MAX (d1, d2);
1381: break;
1382:
1383: default:
1384: abort ();
1385: }
1386: #endif /* no REAL_ARITHMETIC */
1387: t = build_real (TREE_TYPE (arg1),
1388: real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
1389: set_float_handler (NULL_PTR);
1390: return t;
1391: }
1392: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1393: if (TREE_CODE (arg1) == COMPLEX_CST)
1394: {
1395: register tree r1 = TREE_REALPART (arg1);
1396: register tree i1 = TREE_IMAGPART (arg1);
1397: register tree r2 = TREE_REALPART (arg2);
1398: register tree i2 = TREE_IMAGPART (arg2);
1399: register tree t;
1400:
1401: switch (code)
1402: {
1403: case PLUS_EXPR:
1404: t = build_complex (const_binop (PLUS_EXPR, r1, r2, notrunc),
1405: const_binop (PLUS_EXPR, i1, i2, notrunc));
1406: break;
1407:
1408: case MINUS_EXPR:
1409: t = build_complex (const_binop (MINUS_EXPR, r1, r2, notrunc),
1410: const_binop (MINUS_EXPR, i1, i2, notrunc));
1411: break;
1412:
1413: case MULT_EXPR:
1414: t = build_complex (const_binop (MINUS_EXPR,
1415: const_binop (MULT_EXPR,
1416: r1, r2, notrunc),
1417: const_binop (MULT_EXPR,
1418: i1, i2, notrunc),
1419: notrunc),
1420: const_binop (PLUS_EXPR,
1421: const_binop (MULT_EXPR,
1422: r1, i2, notrunc),
1423: const_binop (MULT_EXPR,
1424: i1, r2, notrunc),
1425: notrunc));
1426: break;
1427:
1428: case RDIV_EXPR:
1429: {
1430: register tree magsquared
1431: = const_binop (PLUS_EXPR,
1432: const_binop (MULT_EXPR, r2, r2, notrunc),
1433: const_binop (MULT_EXPR, i2, i2, notrunc),
1434: notrunc);
1435: t = build_complex (const_binop (RDIV_EXPR,
1436: const_binop (PLUS_EXPR,
1437: const_binop (MULT_EXPR, r1, r2, notrunc),
1438: const_binop (MULT_EXPR, i1, i2, notrunc),
1439: notrunc),
1440: magsquared, notrunc),
1441: const_binop (RDIV_EXPR,
1442: const_binop (MINUS_EXPR,
1443: const_binop (MULT_EXPR, i1, r2, notrunc),
1444: const_binop (MULT_EXPR, r1, i2, notrunc),
1445: notrunc),
1446: magsquared, notrunc));
1447: }
1448: break;
1449:
1450: default:
1451: abort ();
1452: }
1453: TREE_TYPE (t) = TREE_TYPE (arg1);
1454: return t;
1455: }
1456: return 0;
1457: }
1458:
1459: /* Return an INTEGER_CST with value V and type from `sizetype'. */
1460:
1461: tree
1462: size_int (number)
1463: unsigned int number;
1464: {
1465: register tree t;
1466: /* Type-size nodes already made for small sizes. */
1467: static tree size_table[2*HOST_BITS_PER_WIDE_INT + 1];
1468:
1469: if (number < 2*HOST_BITS_PER_WIDE_INT + 1
1470: && size_table[number] != 0)
1471: return size_table[number];
1472: if (number < 2*HOST_BITS_PER_WIDE_INT + 1)
1473: {
1474: push_obstacks_nochange ();
1475: /* Make this a permanent node. */
1476: end_temporary_allocation ();
1477: t = build_int_2 (number, 0);
1478: TREE_TYPE (t) = sizetype;
1479: size_table[number] = t;
1480: pop_obstacks ();
1481: }
1482: else
1483: {
1484: t = build_int_2 (number, 0);
1485: TREE_TYPE (t) = sizetype;
1486: }
1487: return t;
1488: }
1489:
1490: /* Combine operands OP1 and OP2 with arithmetic operation CODE.
1491: CODE is a tree code. Data type is taken from `sizetype',
1492: If the operands are constant, so is the result. */
1493:
1494: tree
1495: size_binop (code, arg0, arg1)
1496: enum tree_code code;
1497: tree arg0, arg1;
1498: {
1499: /* Handle the special case of two integer constants faster. */
1500: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1501: {
1502: /* And some specific cases even faster than that. */
1503: if (code == PLUS_EXPR
1504: && TREE_INT_CST_LOW (arg0) == 0
1505: && TREE_INT_CST_HIGH (arg0) == 0)
1506: return arg1;
1507: if (code == MINUS_EXPR
1508: && TREE_INT_CST_LOW (arg1) == 0
1509: && TREE_INT_CST_HIGH (arg1) == 0)
1510: return arg0;
1511: if (code == MULT_EXPR
1512: && TREE_INT_CST_LOW (arg0) == 1
1513: && TREE_INT_CST_HIGH (arg0) == 0)
1514: return arg1;
1515: /* Handle general case of two integer constants. */
1516: return const_binop (code, arg0, arg1, 1);
1517: }
1518:
1519: if (arg0 == error_mark_node || arg1 == error_mark_node)
1520: return error_mark_node;
1521:
1522: return fold (build (code, sizetype, arg0, arg1));
1523: }
1524:
1525: /* Given T, a tree representing type conversion of ARG1, a constant,
1526: return a constant tree representing the result of conversion. */
1527:
1528: static tree
1529: fold_convert (t, arg1)
1530: register tree t;
1531: register tree arg1;
1532: {
1533: register tree type = TREE_TYPE (t);
1534:
1535: if (TREE_CODE (type) == POINTER_TYPE || INTEGRAL_TYPE_P (type))
1536: {
1537: if (TREE_CODE (arg1) == INTEGER_CST)
1538: {
1539: /* Given an integer constant, make new constant with new type,
1540: appropriately sign-extended or truncated. */
1541: t = build_int_2 (TREE_INT_CST_LOW (arg1),
1542: TREE_INT_CST_HIGH (arg1));
1543: TREE_TYPE (t) = type;
1544: /* Indicate an overflow if (1) ARG1 already overflowed,
1545: or (2) force_fit_type indicates an overflow.
1546: Tell force_fit_type that an overflow has already occurred
1547: if ARG1 is a too-large unsigned value and T is signed. */
1548: TREE_OVERFLOW (t)
1549: = (TREE_OVERFLOW (arg1)
1550: | force_fit_type (t,
1551: (TREE_INT_CST_HIGH (arg1) < 0
1552: & (TREE_UNSIGNED (type)
1553: < TREE_UNSIGNED (TREE_TYPE (arg1))))));
1554: TREE_CONSTANT_OVERFLOW (t)
1555: = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
1556: }
1557: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1558: else if (TREE_CODE (arg1) == REAL_CST)
1559: {
1560: REAL_VALUE_TYPE l, x, u;
1561:
1562: l = real_value_from_int_cst (TYPE_MIN_VALUE (type));
1563: x = TREE_REAL_CST (arg1);
1564: u = real_value_from_int_cst (TYPE_MAX_VALUE (type));
1565:
1566: /* See if X will be in range after truncation towards 0.
1567: To compensate for truncation, move the bounds away from 0,
1568: but reject if X exactly equals the adjusted bounds. */
1569: #ifdef REAL_ARITHMETIC
1570: REAL_ARITHMETIC (l, MINUS_EXPR, l, dconst1);
1571: REAL_ARITHMETIC (u, PLUS_EXPR, u, dconst1);
1572: #else
1573: l--;
1574: u++;
1575: #endif
1576: if (! (REAL_VALUES_LESS (l, x) && REAL_VALUES_LESS (x, u)))
1577: {
1578: pedwarn ("real constant out of range for integer conversion");
1579: return t;
1580: }
1581: #ifndef REAL_ARITHMETIC
1582: {
1583: REAL_VALUE_TYPE d;
1584: HOST_WIDE_INT low, high;
1585: HOST_WIDE_INT half_word
1586: = (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2);
1587:
1588: d = TREE_REAL_CST (arg1);
1589: if (d < 0)
1590: d = -d;
1591:
1592: high = (HOST_WIDE_INT) (d / half_word / half_word);
1593: d -= (REAL_VALUE_TYPE) high * half_word * half_word;
1594: if (d >= (REAL_VALUE_TYPE) half_word * half_word / 2)
1595: {
1596: low = d - (REAL_VALUE_TYPE) half_word * half_word / 2;
1597: low |= (HOST_WIDE_INT) -1 << (HOST_BITS_PER_WIDE_INT - 1);
1598: }
1599: else
1600: low = (HOST_WIDE_INT) d;
1601: if (TREE_REAL_CST (arg1) < 0)
1602: neg_double (low, high, &low, &high);
1603: t = build_int_2 (low, high);
1604: }
1605: #else
1606: {
1607: HOST_WIDE_INT low, high;
1608: REAL_VALUE_TO_INT (&low, &high, (TREE_REAL_CST (arg1)));
1609: t = build_int_2 (low, high);
1610: }
1611: #endif
1612: TREE_TYPE (t) = type;
1613: force_fit_type (t, 0);
1614: }
1615: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1616: TREE_TYPE (t) = type;
1617: }
1618: else if (TREE_CODE (type) == REAL_TYPE)
1619: {
1620: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1621: if (TREE_CODE (arg1) == INTEGER_CST)
1622: return build_real_from_int_cst (type, arg1);
1623: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1624: if (TREE_CODE (arg1) == REAL_CST)
1625: {
1626: if (setjmp (float_error))
1627: {
1628: pedwarn ("floating overflow in constant expression");
1629: return t;
1630: }
1631: set_float_handler (float_error);
1632:
1633: t = build_real (type, real_value_truncate (TYPE_MODE (type),
1634: TREE_REAL_CST (arg1)));
1635: set_float_handler (NULL_PTR);
1636: return t;
1637: }
1638: }
1639: TREE_CONSTANT (t) = 1;
1640: return t;
1641: }
1642:
1643: /* Return an expr equal to X but certainly not valid as an lvalue.
1644: Also make sure it is not valid as an null pointer constant. */
1645:
1646: tree
1647: non_lvalue (x)
1648: tree x;
1649: {
1650: tree result;
1651:
1652: /* These things are certainly not lvalues. */
1653: if (TREE_CODE (x) == NON_LVALUE_EXPR
1654: || TREE_CODE (x) == INTEGER_CST
1655: || TREE_CODE (x) == REAL_CST
1656: || TREE_CODE (x) == STRING_CST
1657: || TREE_CODE (x) == ADDR_EXPR)
1658: {
1659: if (TREE_CODE (x) == INTEGER_CST && integer_zerop (x))
1660: {
1661: /* Use NOP_EXPR instead of NON_LVALUE_EXPR
1662: so convert_for_assignment won't strip it.
1663: This is so this 0 won't be treated as a null pointer constant. */
1664: result = build1 (NOP_EXPR, TREE_TYPE (x), x);
1665: TREE_CONSTANT (result) = TREE_CONSTANT (x);
1666: return result;
1667: }
1668: return x;
1669: }
1670:
1671: result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1672: TREE_CONSTANT (result) = TREE_CONSTANT (x);
1673: return result;
1674: }
1675:
1676: /* When pedantic, return an expr equal to X but certainly not valid as a
1677: pedantic lvalue. Otherwise, return X. */
1678:
1679: tree
1680: pedantic_non_lvalue (x)
1681: tree x;
1682: {
1683: if (pedantic)
1684: return non_lvalue (x);
1685: else
1686: return x;
1687: }
1688:
1689: /* Given a tree comparison code, return the code that is the logical inverse
1690: of the given code. It is not safe to do this for floating-point
1691: comparisons, except for NE_EXPR and EQ_EXPR. */
1692:
1693: static enum tree_code
1694: invert_tree_comparison (code)
1695: enum tree_code code;
1696: {
1697: switch (code)
1698: {
1699: case EQ_EXPR:
1700: return NE_EXPR;
1701: case NE_EXPR:
1702: return EQ_EXPR;
1703: case GT_EXPR:
1704: return LE_EXPR;
1705: case GE_EXPR:
1706: return LT_EXPR;
1707: case LT_EXPR:
1708: return GE_EXPR;
1709: case LE_EXPR:
1710: return GT_EXPR;
1711: default:
1712: abort ();
1713: }
1714: }
1715:
1716: /* Similar, but return the comparison that results if the operands are
1717: swapped. This is safe for floating-point. */
1718:
1719: static enum tree_code
1720: swap_tree_comparison (code)
1721: enum tree_code code;
1722: {
1723: switch (code)
1724: {
1725: case EQ_EXPR:
1726: case NE_EXPR:
1727: return code;
1728: case GT_EXPR:
1729: return LT_EXPR;
1730: case GE_EXPR:
1731: return LE_EXPR;
1732: case LT_EXPR:
1733: return GT_EXPR;
1734: case LE_EXPR:
1735: return GE_EXPR;
1736: default:
1737: abort ();
1738: }
1739: }
1740:
1741: /* Return nonzero if two operands are necessarily equal.
1742: If ONLY_CONST is non-zero, only return non-zero for constants.
1743: This function tests whether the operands are indistinguishable;
1744: it does not test whether they are equal using C's == operation.
1745: The distinction is important for IEEE floating point, because
1746: (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
1747: (2) two NaNs may be indistinguishable, but NaN!=NaN. */
1748:
1749: int
1750: operand_equal_p (arg0, arg1, only_const)
1751: tree arg0, arg1;
1752: int only_const;
1753: {
1754: /* If both types don't have the same signedness, then we can't consider
1755: them equal. We must check this before the STRIP_NOPS calls
1756: because they may change the signedness of the arguments. */
1757: if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
1758: return 0;
1759:
1760: STRIP_NOPS (arg0);
1761: STRIP_NOPS (arg1);
1762:
1763: /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1764: We don't care about side effects in that case because the SAVE_EXPR
1765: takes care of that for us. */
1766: if (TREE_CODE (arg0) == SAVE_EXPR && arg0 == arg1)
1767: return ! only_const;
1768:
1769: if (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1))
1770: return 0;
1771:
1772: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1773: && TREE_CODE (arg0) == ADDR_EXPR
1774: && TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0))
1775: return 1;
1776:
1777: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1778: && TREE_CODE (arg0) == INTEGER_CST
1779: && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
1780: && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1))
1781: return 1;
1782:
1783: /* Detect when real constants are equal. */
1784: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1785: && TREE_CODE (arg0) == REAL_CST)
1786: return !bcmp (&TREE_REAL_CST (arg0), &TREE_REAL_CST (arg1),
1787: sizeof (REAL_VALUE_TYPE));
1788:
1789: if (only_const)
1790: return 0;
1791:
1792: if (arg0 == arg1)
1793: return 1;
1794:
1795: if (TREE_CODE (arg0) != TREE_CODE (arg1))
1796: return 0;
1797: /* This is needed for conversions and for COMPONENT_REF.
1798: Might as well play it safe and always test this. */
1799: if (TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
1800: return 0;
1801:
1802: switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
1803: {
1804: case '1':
1805: /* Two conversions are equal only if signedness and modes match. */
1806: if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
1807: && (TREE_UNSIGNED (TREE_TYPE (arg0))
1808: != TREE_UNSIGNED (TREE_TYPE (arg1))))
1809: return 0;
1810:
1811: return operand_equal_p (TREE_OPERAND (arg0, 0),
1812: TREE_OPERAND (arg1, 0), 0);
1813:
1814: case '<':
1815: case '2':
1816: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1817: TREE_OPERAND (arg1, 0), 0)
1818: && operand_equal_p (TREE_OPERAND (arg0, 1),
1819: TREE_OPERAND (arg1, 1), 0));
1820:
1821: case 'r':
1822: switch (TREE_CODE (arg0))
1823: {
1824: case INDIRECT_REF:
1825: return operand_equal_p (TREE_OPERAND (arg0, 0),
1826: TREE_OPERAND (arg1, 0), 0);
1827:
1828: case COMPONENT_REF:
1829: case ARRAY_REF:
1830: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1831: TREE_OPERAND (arg1, 0), 0)
1832: && operand_equal_p (TREE_OPERAND (arg0, 1),
1833: TREE_OPERAND (arg1, 1), 0));
1834:
1835: case BIT_FIELD_REF:
1836: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1837: TREE_OPERAND (arg1, 0), 0)
1838: && operand_equal_p (TREE_OPERAND (arg0, 1),
1839: TREE_OPERAND (arg1, 1), 0)
1840: && operand_equal_p (TREE_OPERAND (arg0, 2),
1841: TREE_OPERAND (arg1, 2), 0));
1842: }
1843: break;
1844: }
1845:
1846: return 0;
1847: }
1848:
1849: /* Similar to operand_equal_p, but see if ARG0 might have been made by
1850: shorten_compare from ARG1 when ARG1 was being compared with OTHER.
1851:
1852: When in doubt, return 0. */
1853:
1854: static int
1855: operand_equal_for_comparison_p (arg0, arg1, other)
1856: tree arg0, arg1;
1857: tree other;
1858: {
1859: int unsignedp1, unsignedpo;
1860: tree primarg1, primother;
1861: int correct_width;
1862:
1863: if (operand_equal_p (arg0, arg1, 0))
1864: return 1;
1865:
1866: if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
1867: return 0;
1868:
1869: /* Duplicate what shorten_compare does to ARG1 and see if that gives the
1870: actual comparison operand, ARG0.
1871:
1872: First throw away any conversions to wider types
1873: already present in the operands. */
1874:
1875: primarg1 = get_narrower (arg1, &unsignedp1);
1876: primother = get_narrower (other, &unsignedpo);
1877:
1878: correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
1879: if (unsignedp1 == unsignedpo
1880: && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
1881: && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
1882: {
1883: tree type = TREE_TYPE (arg0);
1884:
1885: /* Make sure shorter operand is extended the right way
1886: to match the longer operand. */
1887: primarg1 = convert (signed_or_unsigned_type (unsignedp1,
1888: TREE_TYPE (primarg1)),
1889: primarg1);
1890:
1891: if (operand_equal_p (arg0, convert (type, primarg1), 0))
1892: return 1;
1893: }
1894:
1895: return 0;
1896: }
1897:
1898: /* See if ARG is an expression that is either a comparison or is performing
1899: arithmetic on comparisons. The comparisons must only be comparing
1900: two different values, which will be stored in *CVAL1 and *CVAL2; if
1901: they are non-zero it means that some operands have already been found.
1902: No variables may be used anywhere else in the expression except in the
1903: comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
1904: the expression and save_expr needs to be called with CVAL1 and CVAL2.
1905:
1906: If this is true, return 1. Otherwise, return zero. */
1907:
1908: static int
1909: twoval_comparison_p (arg, cval1, cval2, save_p)
1910: tree arg;
1911: tree *cval1, *cval2;
1912: int *save_p;
1913: {
1914: enum tree_code code = TREE_CODE (arg);
1915: char class = TREE_CODE_CLASS (code);
1916:
1917: /* We can handle some of the 'e' cases here. */
1918: if (class == 'e' && code == TRUTH_NOT_EXPR)
1919: class = '1';
1920: else if (class == 'e'
1921: && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
1922: || code == COMPOUND_EXPR))
1923: class = '2';
1924:
1925: /* ??? Disable this since the SAVE_EXPR might already be in use outside
1926: the expression. There may be no way to make this work, but it needs
1927: to be looked at again for 2.6. */
1928: #if 0
1929: else if (class == 'e' && code == SAVE_EXPR && SAVE_EXPR_RTL (arg) == 0)
1930: {
1931: /* If we've already found a CVAL1 or CVAL2, this expression is
1932: two complex to handle. */
1933: if (*cval1 || *cval2)
1934: return 0;
1935:
1936: class = '1';
1937: *save_p = 1;
1938: }
1939: #endif
1940:
1941: switch (class)
1942: {
1943: case '1':
1944: return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
1945:
1946: case '2':
1947: return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
1948: && twoval_comparison_p (TREE_OPERAND (arg, 1),
1949: cval1, cval2, save_p));
1950:
1951: case 'c':
1952: return 1;
1953:
1954: case 'e':
1955: if (code == COND_EXPR)
1956: return (twoval_comparison_p (TREE_OPERAND (arg, 0),
1957: cval1, cval2, save_p)
1958: && twoval_comparison_p (TREE_OPERAND (arg, 1),
1959: cval1, cval2, save_p)
1960: && twoval_comparison_p (TREE_OPERAND (arg, 2),
1961: cval1, cval2, save_p));
1962: return 0;
1963:
1964: case '<':
1965: /* First see if we can handle the first operand, then the second. For
1966: the second operand, we know *CVAL1 can't be zero. It must be that
1967: one side of the comparison is each of the values; test for the
1968: case where this isn't true by failing if the two operands
1969: are the same. */
1970:
1971: if (operand_equal_p (TREE_OPERAND (arg, 0),
1972: TREE_OPERAND (arg, 1), 0))
1973: return 0;
1974:
1975: if (*cval1 == 0)
1976: *cval1 = TREE_OPERAND (arg, 0);
1977: else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
1978: ;
1979: else if (*cval2 == 0)
1980: *cval2 = TREE_OPERAND (arg, 0);
1981: else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
1982: ;
1983: else
1984: return 0;
1985:
1986: if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
1987: ;
1988: else if (*cval2 == 0)
1989: *cval2 = TREE_OPERAND (arg, 1);
1990: else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
1991: ;
1992: else
1993: return 0;
1994:
1995: return 1;
1996: }
1997:
1998: return 0;
1999: }
2000:
2001: /* ARG is a tree that is known to contain just arithmetic operations and
2002: comparisons. Evaluate the operations in the tree substituting NEW0 for
2003: any occurrence of OLD0 as an operand of a comparison and likewise for
2004: NEW1 and OLD1. */
2005:
2006: static tree
2007: eval_subst (arg, old0, new0, old1, new1)
2008: tree arg;
2009: tree old0, new0, old1, new1;
2010: {
2011: tree type = TREE_TYPE (arg);
2012: enum tree_code code = TREE_CODE (arg);
2013: char class = TREE_CODE_CLASS (code);
2014:
2015: /* We can handle some of the 'e' cases here. */
2016: if (class == 'e' && code == TRUTH_NOT_EXPR)
2017: class = '1';
2018: else if (class == 'e'
2019: && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2020: class = '2';
2021:
2022: switch (class)
2023: {
2024: case '1':
2025: return fold (build1 (code, type,
2026: eval_subst (TREE_OPERAND (arg, 0),
2027: old0, new0, old1, new1)));
2028:
2029: case '2':
2030: return fold (build (code, type,
2031: eval_subst (TREE_OPERAND (arg, 0),
2032: old0, new0, old1, new1),
2033: eval_subst (TREE_OPERAND (arg, 1),
2034: old0, new0, old1, new1)));
2035:
2036: case 'e':
2037: switch (code)
2038: {
2039: case SAVE_EXPR:
2040: return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
2041:
2042: case COMPOUND_EXPR:
2043: return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
2044:
2045: case COND_EXPR:
2046: return fold (build (code, type,
2047: eval_subst (TREE_OPERAND (arg, 0),
2048: old0, new0, old1, new1),
2049: eval_subst (TREE_OPERAND (arg, 1),
2050: old0, new0, old1, new1),
2051: eval_subst (TREE_OPERAND (arg, 2),
2052: old0, new0, old1, new1)));
2053: }
2054:
2055: case '<':
2056: {
2057: tree arg0 = TREE_OPERAND (arg, 0);
2058: tree arg1 = TREE_OPERAND (arg, 1);
2059:
2060: /* We need to check both for exact equality and tree equality. The
2061: former will be true if the operand has a side-effect. In that
2062: case, we know the operand occurred exactly once. */
2063:
2064: if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2065: arg0 = new0;
2066: else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2067: arg0 = new1;
2068:
2069: if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2070: arg1 = new0;
2071: else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2072: arg1 = new1;
2073:
2074: return fold (build (code, type, arg0, arg1));
2075: }
2076: }
2077:
2078: return arg;
2079: }
2080:
2081: /* Return a tree for the case when the result of an expression is RESULT
2082: converted to TYPE and OMITTED was previously an operand of the expression
2083: but is now not needed (e.g., we folded OMITTED * 0).
2084:
2085: If OMITTED has side effects, we must evaluate it. Otherwise, just do
2086: the conversion of RESULT to TYPE. */
2087:
2088: static tree
2089: omit_one_operand (type, result, omitted)
2090: tree type, result, omitted;
2091: {
2092: tree t = convert (type, result);
2093:
2094: if (TREE_SIDE_EFFECTS (omitted))
2095: return build (COMPOUND_EXPR, type, omitted, t);
2096:
2097: return non_lvalue (t);
2098: }
2099:
2100: /* Return a simplified tree node for the truth-negation of ARG. This
2101: never alters ARG itself. We assume that ARG is an operation that
2102: returns a truth value (0 or 1). */
2103:
2104: tree
2105: invert_truthvalue (arg)
2106: tree arg;
2107: {
2108: tree type = TREE_TYPE (arg);
2109: enum tree_code code = TREE_CODE (arg);
2110:
2111: if (code == ERROR_MARK)
2112: return arg;
2113:
2114: /* If this is a comparison, we can simply invert it, except for
2115: floating-point non-equality comparisons, in which case we just
2116: enclose a TRUTH_NOT_EXPR around what we have. */
2117:
2118: if (TREE_CODE_CLASS (code) == '<')
2119: {
2120: if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0)))
2121: && code != NE_EXPR && code != EQ_EXPR)
2122: return build1 (TRUTH_NOT_EXPR, type, arg);
2123: else
2124: return build (invert_tree_comparison (code), type,
2125: TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
2126: }
2127:
2128: switch (code)
2129: {
2130: case INTEGER_CST:
2131: return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
2132: && TREE_INT_CST_HIGH (arg) == 0, 0));
2133:
2134: case TRUTH_AND_EXPR:
2135: return build (TRUTH_OR_EXPR, type,
2136: invert_truthvalue (TREE_OPERAND (arg, 0)),
2137: invert_truthvalue (TREE_OPERAND (arg, 1)));
2138:
2139: case TRUTH_OR_EXPR:
2140: return build (TRUTH_AND_EXPR, type,
2141: invert_truthvalue (TREE_OPERAND (arg, 0)),
2142: invert_truthvalue (TREE_OPERAND (arg, 1)));
2143:
2144: case TRUTH_XOR_EXPR:
2145: /* Here we can invert either operand. We invert the first operand
2146: unless the second operand is a TRUTH_NOT_EXPR in which case our
2147: result is the XOR of the first operand with the inside of the
2148: negation of the second operand. */
2149:
2150: if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
2151: return build (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
2152: TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
2153: else
2154: return build (TRUTH_XOR_EXPR, type,
2155: invert_truthvalue (TREE_OPERAND (arg, 0)),
2156: TREE_OPERAND (arg, 1));
2157:
2158: case TRUTH_ANDIF_EXPR:
2159: return build (TRUTH_ORIF_EXPR, type,
2160: invert_truthvalue (TREE_OPERAND (arg, 0)),
2161: invert_truthvalue (TREE_OPERAND (arg, 1)));
2162:
2163: case TRUTH_ORIF_EXPR:
2164: return build (TRUTH_ANDIF_EXPR, type,
2165: invert_truthvalue (TREE_OPERAND (arg, 0)),
2166: invert_truthvalue (TREE_OPERAND (arg, 1)));
2167:
2168: case TRUTH_NOT_EXPR:
2169: return TREE_OPERAND (arg, 0);
2170:
2171: case COND_EXPR:
2172: return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
2173: invert_truthvalue (TREE_OPERAND (arg, 1)),
2174: invert_truthvalue (TREE_OPERAND (arg, 2)));
2175:
2176: case COMPOUND_EXPR:
2177: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
2178: invert_truthvalue (TREE_OPERAND (arg, 1)));
2179:
2180: case NON_LVALUE_EXPR:
2181: return invert_truthvalue (TREE_OPERAND (arg, 0));
2182:
2183: case NOP_EXPR:
2184: case CONVERT_EXPR:
2185: case FLOAT_EXPR:
2186: return build1 (TREE_CODE (arg), type,
2187: invert_truthvalue (TREE_OPERAND (arg, 0)));
2188:
2189: case BIT_AND_EXPR:
2190: if (!integer_onep (TREE_OPERAND (arg, 1)))
2191: break;
2192: return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
2193:
2194: case SAVE_EXPR:
2195: return build1 (TRUTH_NOT_EXPR, type, arg);
2196: }
2197: if (TREE_CODE (TREE_TYPE (arg)) != BOOLEAN_TYPE)
2198: abort ();
2199: return build1 (TRUTH_NOT_EXPR, type, arg);
2200: }
2201:
2202: /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
2203: operands are another bit-wise operation with a common input. If so,
2204: distribute the bit operations to save an operation and possibly two if
2205: constants are involved. For example, convert
2206: (A | B) & (A | C) into A | (B & C)
2207: Further simplification will occur if B and C are constants.
2208:
2209: If this optimization cannot be done, 0 will be returned. */
2210:
2211: static tree
2212: distribute_bit_expr (code, type, arg0, arg1)
2213: enum tree_code code;
2214: tree type;
2215: tree arg0, arg1;
2216: {
2217: tree common;
2218: tree left, right;
2219:
2220: if (TREE_CODE (arg0) != TREE_CODE (arg1)
2221: || TREE_CODE (arg0) == code
2222: || (TREE_CODE (arg0) != BIT_AND_EXPR
2223: && TREE_CODE (arg0) != BIT_IOR_EXPR))
2224: return 0;
2225:
2226: if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
2227: {
2228: common = TREE_OPERAND (arg0, 0);
2229: left = TREE_OPERAND (arg0, 1);
2230: right = TREE_OPERAND (arg1, 1);
2231: }
2232: else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
2233: {
2234: common = TREE_OPERAND (arg0, 0);
2235: left = TREE_OPERAND (arg0, 1);
2236: right = TREE_OPERAND (arg1, 0);
2237: }
2238: else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
2239: {
2240: common = TREE_OPERAND (arg0, 1);
2241: left = TREE_OPERAND (arg0, 0);
2242: right = TREE_OPERAND (arg1, 1);
2243: }
2244: else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
2245: {
2246: common = TREE_OPERAND (arg0, 1);
2247: left = TREE_OPERAND (arg0, 0);
2248: right = TREE_OPERAND (arg1, 0);
2249: }
2250: else
2251: return 0;
2252:
2253: return fold (build (TREE_CODE (arg0), type, common,
2254: fold (build (code, type, left, right))));
2255: }
2256:
2257: /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
2258: starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
2259:
2260: static tree
2261: make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
2262: tree inner;
2263: tree type;
2264: int bitsize, bitpos;
2265: int unsignedp;
2266: {
2267: tree result = build (BIT_FIELD_REF, type, inner,
2268: size_int (bitsize), size_int (bitpos));
2269:
2270: TREE_UNSIGNED (result) = unsignedp;
2271:
2272: return result;
2273: }
2274:
2275: /* Optimize a bit-field compare.
2276:
2277: There are two cases: First is a compare against a constant and the
2278: second is a comparison of two items where the fields are at the same
2279: bit position relative to the start of a chunk (byte, halfword, word)
2280: large enough to contain it. In these cases we can avoid the shift
2281: implicit in bitfield extractions.
2282:
2283: For constants, we emit a compare of the shifted constant with the
2284: BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
2285: compared. For two fields at the same position, we do the ANDs with the
2286: similar mask and compare the result of the ANDs.
2287:
2288: CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
2289: COMPARE_TYPE is the type of the comparison, and LHS and RHS
2290: are the left and right operands of the comparison, respectively.
2291:
2292: If the optimization described above can be done, we return the resulting
2293: tree. Otherwise we return zero. */
2294:
2295: static tree
2296: optimize_bit_field_compare (code, compare_type, lhs, rhs)
2297: enum tree_code code;
2298: tree compare_type;
2299: tree lhs, rhs;
2300: {
2301: int lbitpos, lbitsize, rbitpos, rbitsize;
2302: int lnbitpos, lnbitsize, rnbitpos, rnbitsize;
2303: tree type = TREE_TYPE (lhs);
2304: tree signed_type, unsigned_type;
2305: int const_p = TREE_CODE (rhs) == INTEGER_CST;
2306: enum machine_mode lmode, rmode, lnmode, rnmode;
2307: int lunsignedp, runsignedp;
2308: int lvolatilep = 0, rvolatilep = 0;
2309: tree linner, rinner;
2310: tree mask;
2311: tree offset;
2312:
2313: /* Get all the information about the extractions being done. If the bit size
2314: if the same as the size of the underlying object, we aren't doing an
2315: extraction at all and so can do nothing. */
2316: linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
2317: &lunsignedp, &lvolatilep);
2318: if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
2319: || offset != 0)
2320: return 0;
2321:
2322: if (!const_p)
2323: {
2324: /* If this is not a constant, we can only do something if bit positions,
2325: sizes, and signedness are the same. */
2326: rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset,
2327: &rmode, &runsignedp, &rvolatilep);
2328:
2329: if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
2330: || lunsignedp != runsignedp || offset != 0)
2331: return 0;
2332: }
2333:
2334: /* See if we can find a mode to refer to this field. We should be able to,
2335: but fail if we can't. */
2336: lnmode = get_best_mode (lbitsize, lbitpos,
2337: TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
2338: lvolatilep);
2339: if (lnmode == VOIDmode)
2340: return 0;
2341:
2342: /* Set signed and unsigned types of the precision of this mode for the
2343: shifts below. */
2344: signed_type = type_for_mode (lnmode, 0);
2345: unsigned_type = type_for_mode (lnmode, 1);
2346:
2347: if (! const_p)
2348: {
2349: rnmode = get_best_mode (rbitsize, rbitpos,
2350: TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
2351: rvolatilep);
2352: if (rnmode == VOIDmode)
2353: return 0;
2354: }
2355:
2356: /* Compute the bit position and size for the new reference and our offset
2357: within it. If the new reference is the same size as the original, we
2358: won't optimize anything, so return zero. */
2359: lnbitsize = GET_MODE_BITSIZE (lnmode);
2360: lnbitpos = lbitpos & ~ (lnbitsize - 1);
2361: lbitpos -= lnbitpos;
2362: if (lnbitsize == lbitsize)
2363: return 0;
2364:
2365: if (! const_p)
2366: {
2367: rnbitsize = GET_MODE_BITSIZE (rnmode);
2368: rnbitpos = rbitpos & ~ (rnbitsize - 1);
2369: rbitpos -= rnbitpos;
2370: if (rnbitsize == rbitsize)
2371: return 0;
2372: }
2373:
2374: #if BYTES_BIG_ENDIAN
2375: lbitpos = lnbitsize - lbitsize - lbitpos;
2376: #endif
2377:
2378: /* Make the mask to be used against the extracted field. */
2379: mask = build_int_2 (~0, ~0);
2380: TREE_TYPE (mask) = unsigned_type;
2381: force_fit_type (mask, 0);
2382: mask = convert (unsigned_type, mask);
2383: mask = const_binop (LSHIFT_EXPR, mask, size_int (lnbitsize - lbitsize), 0);
2384: mask = const_binop (RSHIFT_EXPR, mask,
2385: size_int (lnbitsize - lbitsize - lbitpos), 0);
2386:
2387: if (! const_p)
2388: /* If not comparing with constant, just rework the comparison
2389: and return. */
2390: return build (code, compare_type,
2391: build (BIT_AND_EXPR, unsigned_type,
2392: make_bit_field_ref (linner, unsigned_type,
2393: lnbitsize, lnbitpos, 1),
2394: mask),
2395: build (BIT_AND_EXPR, unsigned_type,
2396: make_bit_field_ref (rinner, unsigned_type,
2397: rnbitsize, rnbitpos, 1),
2398: mask));
2399:
2400: /* Otherwise, we are handling the constant case. See if the constant is too
2401: big for the field. Warn and return a tree of for 0 (false) if so. We do
2402: this not only for its own sake, but to avoid having to test for this
2403: error case below. If we didn't, we might generate wrong code.
2404:
2405: For unsigned fields, the constant shifted right by the field length should
2406: be all zero. For signed fields, the high-order bits should agree with
2407: the sign bit. */
2408:
2409: if (lunsignedp)
2410: {
2411: if (! integer_zerop (const_binop (RSHIFT_EXPR,
2412: convert (unsigned_type, rhs),
2413: size_int (lbitsize), 0)))
2414: {
2415: warning ("comparison is always %s due to width of bitfield",
2416: code == NE_EXPR ? "one" : "zero");
2417: return convert (compare_type,
2418: (code == NE_EXPR
2419: ? integer_one_node : integer_zero_node));
2420: }
2421: }
2422: else
2423: {
2424: tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
2425: size_int (lbitsize - 1), 0);
2426: if (! integer_zerop (tem) && ! integer_all_onesp (tem))
2427: {
2428: warning ("comparison is always %s due to width of bitfield",
2429: code == NE_EXPR ? "one" : "zero");
2430: return convert (compare_type,
2431: (code == NE_EXPR
2432: ? integer_one_node : integer_zero_node));
2433: }
2434: }
2435:
2436: /* Single-bit compares should always be against zero. */
2437: if (lbitsize == 1 && ! integer_zerop (rhs))
2438: {
2439: code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
2440: rhs = convert (type, integer_zero_node);
2441: }
2442:
2443: /* Make a new bitfield reference, shift the constant over the
2444: appropriate number of bits and mask it with the computed mask
2445: (in case this was a signed field). If we changed it, make a new one. */
2446: lhs = make_bit_field_ref (linner, unsigned_type, lnbitsize, lnbitpos, 1);
2447: if (lvolatilep)
2448: {
2449: TREE_SIDE_EFFECTS (lhs) = 1;
2450: TREE_THIS_VOLATILE (lhs) = 1;
2451: }
2452:
2453: rhs = fold (const_binop (BIT_AND_EXPR,
2454: const_binop (LSHIFT_EXPR,
2455: convert (unsigned_type, rhs),
2456: size_int (lbitpos), 0),
2457: mask, 0));
2458:
2459: return build (code, compare_type,
2460: build (BIT_AND_EXPR, unsigned_type, lhs, mask),
2461: rhs);
2462: }
2463:
2464: /* Subroutine for fold_truthop: decode a field reference.
2465:
2466: If EXP is a comparison reference, we return the innermost reference.
2467:
2468: *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
2469: set to the starting bit number.
2470:
2471: If the innermost field can be completely contained in a mode-sized
2472: unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
2473:
2474: *PVOLATILEP is set to 1 if the any expression encountered is volatile;
2475: otherwise it is not changed.
2476:
2477: *PUNSIGNEDP is set to the signedness of the field.
2478:
2479: *PMASK is set to the mask used. This is either contained in a
2480: BIT_AND_EXPR or derived from the width of the field.
2481:
2482: Return 0 if this is not a component reference or is one that we can't
2483: do anything with. */
2484:
2485: static tree
2486: decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
2487: pvolatilep, pmask)
2488: tree exp;
2489: int *pbitsize, *pbitpos;
2490: enum machine_mode *pmode;
2491: int *punsignedp, *pvolatilep;
2492: tree *pmask;
2493: {
2494: tree mask = 0;
2495: tree inner;
2496: tree offset;
2497:
2498: /* All the optimizations using this function assume integer fields.
2499: There are problems with FP fields since the type_for_size call
2500: below can fail for, e.g., XFmode. */
2501: if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
2502: return 0;
2503:
2504: STRIP_NOPS (exp);
2505:
2506: if (TREE_CODE (exp) == BIT_AND_EXPR)
2507: {
2508: mask = TREE_OPERAND (exp, 1);
2509: exp = TREE_OPERAND (exp, 0);
2510: STRIP_NOPS (exp); STRIP_NOPS (mask);
2511: if (TREE_CODE (mask) != INTEGER_CST)
2512: return 0;
2513: }
2514:
2515: if (TREE_CODE (exp) != COMPONENT_REF && TREE_CODE (exp) != ARRAY_REF
2516: && TREE_CODE (exp) != BIT_FIELD_REF)
2517: return 0;
2518:
2519: inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
2520: punsignedp, pvolatilep);
2521: if (inner == exp || *pbitsize < 0 || offset != 0)
2522: return 0;
2523:
2524: if (mask == 0)
2525: {
2526: tree unsigned_type = type_for_size (*pbitsize, 1);
2527: int precision = TYPE_PRECISION (unsigned_type);
2528:
2529: mask = build_int_2 (~0, ~0);
2530: TREE_TYPE (mask) = unsigned_type;
2531: force_fit_type (mask, 0);
2532: mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2533: mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
2534: }
2535:
2536: *pmask = mask;
2537: return inner;
2538: }
2539:
2540: /* Return non-zero if MASK represents a mask of SIZE ones in the low-order
2541: bit positions. */
2542:
2543: static int
2544: all_ones_mask_p (mask, size)
2545: tree mask;
2546: int size;
2547: {
2548: tree type = TREE_TYPE (mask);
2549: int precision = TYPE_PRECISION (type);
2550: tree tmask;
2551:
2552: tmask = build_int_2 (~0, ~0);
2553: TREE_TYPE (tmask) = signed_type (type);
2554: force_fit_type (tmask, 0);
2555: return
2556: operand_equal_p (mask,
2557: const_binop (RSHIFT_EXPR,
2558: const_binop (LSHIFT_EXPR, tmask,
2559: size_int (precision - size), 0),
2560: size_int (precision - size), 0),
2561: 0);
2562: }
2563:
2564: /* Subroutine for fold_truthop: determine if an operand is simple enough
2565: to be evaluated unconditionally. */
2566:
2567: static int
2568: simple_operand_p (exp)
2569: tree exp;
2570: {
2571: /* Strip any conversions that don't change the machine mode. */
2572: while ((TREE_CODE (exp) == NOP_EXPR
2573: || TREE_CODE (exp) == CONVERT_EXPR)
2574: && (TYPE_MODE (TREE_TYPE (exp))
2575: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)))))
2576: exp = TREE_OPERAND (exp, 0);
2577:
2578: return (TREE_CODE_CLASS (TREE_CODE (exp)) == 'c'
2579: || (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
2580: && ! TREE_ADDRESSABLE (exp)
2581: && ! TREE_THIS_VOLATILE (exp)
2582: && ! DECL_NONLOCAL (exp)
2583: /* Don't regard global variables as simple. They may be
2584: allocated in ways unknown to the compiler (shared memory,
2585: #pragma weak, etc). */
2586: && ! TREE_PUBLIC (exp)
2587: && ! DECL_EXTERNAL (exp)
2588: /* Loading a static variable is unduly expensive, but global
2589: registers aren't expensive. */
2590: && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
2591: }
2592:
2593: /* Subroutine for fold_truthop: try to optimize a range test.
2594:
2595: For example, "i >= 2 && i =< 9" can be done as "(unsigned) (i - 2) <= 7".
2596:
2597: JCODE is the logical combination of the two terms. It is TRUTH_AND_EXPR
2598: (representing TRUTH_ANDIF_EXPR and TRUTH_AND_EXPR) or TRUTH_OR_EXPR
2599: (representing TRUTH_ORIF_EXPR and TRUTH_OR_EXPR). TYPE is the type of
2600: the result.
2601:
2602: VAR is the value being tested. LO_CODE and HI_CODE are the comparison
2603: operators comparing VAR to LO_CST and HI_CST. LO_CST is known to be no
2604: larger than HI_CST (they may be equal).
2605:
2606: We return the simplified tree or 0 if no optimization is possible. */
2607:
2608: static tree
2609: range_test (jcode, type, lo_code, hi_code, var, lo_cst, hi_cst)
2610: enum tree_code jcode, lo_code, hi_code;
2611: tree type, var, lo_cst, hi_cst;
2612: {
2613: tree utype;
2614: enum tree_code rcode;
2615:
2616: /* See if this is a range test and normalize the constant terms. */
2617:
2618: if (jcode == TRUTH_AND_EXPR)
2619: {
2620: switch (lo_code)
2621: {
2622: case NE_EXPR:
2623: /* See if we have VAR != CST && VAR != CST+1. */
2624: if (! (hi_code == NE_EXPR
2625: && TREE_INT_CST_LOW (hi_cst) - TREE_INT_CST_LOW (lo_cst) == 1
2626: && tree_int_cst_equal (integer_one_node,
2627: const_binop (MINUS_EXPR,
2628: hi_cst, lo_cst, 0))))
2629: return 0;
2630:
2631: rcode = GT_EXPR;
2632: break;
2633:
2634: case GT_EXPR:
2635: case GE_EXPR:
2636: if (hi_code == LT_EXPR)
2637: hi_cst = const_binop (MINUS_EXPR, hi_cst, integer_one_node, 0);
2638: else if (hi_code != LE_EXPR)
2639: return 0;
2640:
2641: if (lo_code == GT_EXPR)
2642: lo_cst = const_binop (PLUS_EXPR, lo_cst, integer_one_node, 0);
2643:
2644: /* We now have VAR >= LO_CST && VAR <= HI_CST. */
2645: rcode = LE_EXPR;
2646: break;
2647:
2648: default:
2649: return 0;
2650: }
2651: }
2652: else
2653: {
2654: switch (lo_code)
2655: {
2656: case EQ_EXPR:
2657: /* See if we have VAR == CST || VAR == CST+1. */
2658: if (! (hi_code == EQ_EXPR
2659: && TREE_INT_CST_LOW (hi_cst) - TREE_INT_CST_LOW (lo_cst) == 1
2660: && tree_int_cst_equal (integer_one_node,
2661: const_binop (MINUS_EXPR,
2662: hi_cst, lo_cst, 0))))
2663: return 0;
2664:
2665: rcode = LE_EXPR;
2666: break;
2667:
2668: case LE_EXPR:
2669: case LT_EXPR:
2670: if (hi_code == GE_EXPR)
2671: hi_cst = const_binop (MINUS_EXPR, hi_cst, integer_one_node, 0);
2672: else if (hi_code != GT_EXPR)
2673: return 0;
2674:
2675: if (lo_code == LE_EXPR)
2676: lo_cst = const_binop (PLUS_EXPR, lo_cst, integer_one_node, 0);
2677:
2678: /* We now have VAR < LO_CST || VAR > HI_CST. */
2679: rcode = GT_EXPR;
2680: break;
2681:
2682: default:
2683: return 0;
2684: }
2685: }
2686:
2687: /* When normalizing, it is possible to both increment the smaller constant
2688: and decrement the larger constant. See if they are still ordered. */
2689: if (tree_int_cst_lt (hi_cst, lo_cst))
2690: return 0;
2691:
2692: /* Fail if VAR isn't an integer. */
2693: utype = TREE_TYPE (var);
2694: if (! INTEGRAL_TYPE_P (utype))
2695: return 0;
2696:
2697: /* The range test is invalid if subtracting the two constants results
2698: in overflow. This can happen in traditional mode. */
2699: if (! int_fits_type_p (hi_cst, TREE_TYPE (var))
2700: || ! int_fits_type_p (lo_cst, TREE_TYPE (var)))
2701: return 0;
2702:
2703: if (! TREE_UNSIGNED (utype))
2704: {
2705: utype = unsigned_type (utype);
2706: var = convert (utype, var);
2707: lo_cst = convert (utype, lo_cst);
2708: hi_cst = convert (utype, hi_cst);
2709: }
2710:
2711: return fold (convert (type,
2712: build (rcode, utype,
2713: build (MINUS_EXPR, utype, var, lo_cst),
2714: const_binop (MINUS_EXPR, hi_cst, lo_cst, 0))));
2715: }
2716:
2717: /* Find ways of folding logical expressions of LHS and RHS:
2718: Try to merge two comparisons to the same innermost item.
2719: Look for range tests like "ch >= '0' && ch <= '9'".
2720: Look for combinations of simple terms on machines with expensive branches
2721: and evaluate the RHS unconditionally.
2722:
2723: For example, if we have p->a == 2 && p->b == 4 and we can make an
2724: object large enough to span both A and B, we can do this with a comparison
2725: against the object ANDed with the a mask.
2726:
2727: If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
2728: operations to do this with one comparison.
2729:
2730: We check for both normal comparisons and the BIT_AND_EXPRs made this by
2731: function and the one above.
2732:
2733: CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
2734: TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
2735:
2736: TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
2737: two operands.
2738:
2739: We return the simplified tree or 0 if no optimization is possible. */
2740:
2741: static tree
2742: fold_truthop (code, truth_type, lhs, rhs)
2743: enum tree_code code;
2744: tree truth_type, lhs, rhs;
2745: {
2746: /* If this is the "or" of two comparisons, we can do something if we
2747: the comparisons are NE_EXPR. If this is the "and", we can do something
2748: if the comparisons are EQ_EXPR. I.e.,
2749: (a->b == 2 && a->c == 4) can become (a->new == NEW).
2750:
2751: WANTED_CODE is this operation code. For single bit fields, we can
2752: convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
2753: comparison for one-bit fields. */
2754:
2755: enum tree_code wanted_code;
2756: enum tree_code lcode, rcode;
2757: tree ll_arg, lr_arg, rl_arg, rr_arg;
2758: tree ll_inner, lr_inner, rl_inner, rr_inner;
2759: int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
2760: int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
2761: int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
2762: int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
2763: int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
2764: enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
2765: enum machine_mode lnmode, rnmode;
2766: tree ll_mask, lr_mask, rl_mask, rr_mask;
2767: tree l_const, r_const;
2768: tree type, result;
2769: int first_bit, end_bit;
2770: int volatilep;
2771:
2772: /* Start by getting the comparison codes and seeing if this looks like
2773: a range test. Fail if anything is volatile. If one operand is a
2774: BIT_AND_EXPR with the constant one, treat it as if it were surrounded
2775: with a NE_EXPR. */
2776:
2777: if (TREE_SIDE_EFFECTS (lhs)
2778: || TREE_SIDE_EFFECTS (rhs))
2779: return 0;
2780:
2781: lcode = TREE_CODE (lhs);
2782: rcode = TREE_CODE (rhs);
2783:
2784: if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
2785: lcode = NE_EXPR, lhs = build (NE_EXPR, truth_type, lhs, integer_zero_node);
2786:
2787: if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
2788: rcode = NE_EXPR, rhs = build (NE_EXPR, truth_type, rhs, integer_zero_node);
2789:
2790: if (TREE_CODE_CLASS (lcode) != '<'
2791: || TREE_CODE_CLASS (rcode) != '<')
2792: return 0;
2793:
2794: code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
2795: ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
2796:
2797: ll_arg = TREE_OPERAND (lhs, 0);
2798: lr_arg = TREE_OPERAND (lhs, 1);
2799: rl_arg = TREE_OPERAND (rhs, 0);
2800: rr_arg = TREE_OPERAND (rhs, 1);
2801:
2802: if (TREE_CODE (lr_arg) == INTEGER_CST
2803: && TREE_CODE (rr_arg) == INTEGER_CST
2804: && operand_equal_p (ll_arg, rl_arg, 0))
2805: {
2806: if (tree_int_cst_lt (lr_arg, rr_arg))
2807: result = range_test (code, truth_type, lcode, rcode,
2808: ll_arg, lr_arg, rr_arg);
2809: else
2810: result = range_test (code, truth_type, rcode, lcode,
2811: ll_arg, rr_arg, lr_arg);
2812:
2813: /* If this isn't a range test, it also isn't a comparison that
2814: can be merged. However, it wins to evaluate the RHS unconditionally
2815: on machines with expensive branches. */
2816:
2817: if (result == 0 && BRANCH_COST >= 2)
2818: {
2819: if (TREE_CODE (ll_arg) != VAR_DECL
2820: && TREE_CODE (ll_arg) != PARM_DECL)
2821: {
2822: /* Avoid evaluating the variable part twice. */
2823: ll_arg = save_expr (ll_arg);
2824: lhs = build (lcode, TREE_TYPE (lhs), ll_arg, lr_arg);
2825: rhs = build (rcode, TREE_TYPE (rhs), ll_arg, rr_arg);
2826: }
2827: return build (code, truth_type, lhs, rhs);
2828: }
2829: return result;
2830: }
2831:
2832: /* If the RHS can be evaluated unconditionally and its operands are
2833: simple, it wins to evaluate the RHS unconditionally on machines
2834: with expensive branches. In this case, this isn't a comparison
2835: that can be merged. */
2836:
2837: /* @@ I'm not sure it wins on the m88110 to do this if the comparisons
2838: are with zero (tmw). */
2839:
2840: if (BRANCH_COST >= 2
2841: && INTEGRAL_TYPE_P (TREE_TYPE (rhs))
2842: && simple_operand_p (rl_arg)
2843: && simple_operand_p (rr_arg))
2844: return build (code, truth_type, lhs, rhs);
2845:
2846: /* See if the comparisons can be merged. Then get all the parameters for
2847: each side. */
2848:
2849: if ((lcode != EQ_EXPR && lcode != NE_EXPR)
2850: || (rcode != EQ_EXPR && rcode != NE_EXPR))
2851: return 0;
2852:
2853: volatilep = 0;
2854: ll_inner = decode_field_reference (ll_arg,
2855: &ll_bitsize, &ll_bitpos, &ll_mode,
2856: &ll_unsignedp, &volatilep, &ll_mask);
2857: lr_inner = decode_field_reference (lr_arg,
2858: &lr_bitsize, &lr_bitpos, &lr_mode,
2859: &lr_unsignedp, &volatilep, &lr_mask);
2860: rl_inner = decode_field_reference (rl_arg,
2861: &rl_bitsize, &rl_bitpos, &rl_mode,
2862: &rl_unsignedp, &volatilep, &rl_mask);
2863: rr_inner = decode_field_reference (rr_arg,
2864: &rr_bitsize, &rr_bitpos, &rr_mode,
2865: &rr_unsignedp, &volatilep, &rr_mask);
2866:
2867: /* It must be true that the inner operation on the lhs of each
2868: comparison must be the same if we are to be able to do anything.
2869: Then see if we have constants. If not, the same must be true for
2870: the rhs's. */
2871: if (volatilep || ll_inner == 0 || rl_inner == 0
2872: || ! operand_equal_p (ll_inner, rl_inner, 0))
2873: return 0;
2874:
2875: if (TREE_CODE (lr_arg) == INTEGER_CST
2876: && TREE_CODE (rr_arg) == INTEGER_CST)
2877: l_const = lr_arg, r_const = rr_arg;
2878: else if (lr_inner == 0 || rr_inner == 0
2879: || ! operand_equal_p (lr_inner, rr_inner, 0))
2880: return 0;
2881: else
2882: l_const = r_const = 0;
2883:
2884: /* If either comparison code is not correct for our logical operation,
2885: fail. However, we can convert a one-bit comparison against zero into
2886: the opposite comparison against that bit being set in the field. */
2887:
2888: wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
2889: if (lcode != wanted_code)
2890: {
2891: if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
2892: l_const = ll_mask;
2893: else
2894: return 0;
2895: }
2896:
2897: if (rcode != wanted_code)
2898: {
2899: if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
2900: r_const = rl_mask;
2901: else
2902: return 0;
2903: }
2904:
2905: /* See if we can find a mode that contains both fields being compared on
2906: the left. If we can't, fail. Otherwise, update all constants and masks
2907: to be relative to a field of that size. */
2908: first_bit = MIN (ll_bitpos, rl_bitpos);
2909: end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
2910: lnmode = get_best_mode (end_bit - first_bit, first_bit,
2911: TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
2912: volatilep);
2913: if (lnmode == VOIDmode)
2914: return 0;
2915:
2916: lnbitsize = GET_MODE_BITSIZE (lnmode);
2917: lnbitpos = first_bit & ~ (lnbitsize - 1);
2918: type = type_for_size (lnbitsize, 1);
2919: xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
2920:
2921: #if BYTES_BIG_ENDIAN
2922: xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
2923: xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
2924: #endif
2925:
2926: ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
2927: size_int (xll_bitpos), 0);
2928: rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
2929: size_int (xrl_bitpos), 0);
2930:
2931: /* Make sure the constants are interpreted as unsigned, so we
2932: don't have sign bits outside the range of their type. */
2933:
2934: if (l_const)
2935: {
2936: l_const = convert (unsigned_type (TREE_TYPE (l_const)), l_const);
2937: l_const = const_binop (LSHIFT_EXPR, convert (type, l_const),
2938: size_int (xll_bitpos), 0);
2939: }
2940: if (r_const)
2941: {
2942: r_const = convert (unsigned_type (TREE_TYPE (r_const)), r_const);
2943: r_const = const_binop (LSHIFT_EXPR, convert (type, r_const),
2944: size_int (xrl_bitpos), 0);
2945: }
2946:
2947: /* If the right sides are not constant, do the same for it. Also,
2948: disallow this optimization if a size or signedness mismatch occurs
2949: between the left and right sides. */
2950: if (l_const == 0)
2951: {
2952: if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
2953: || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
2954: /* Make sure the two fields on the right
2955: correspond to the left without being swapped. */
2956: || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
2957: return 0;
2958:
2959: first_bit = MIN (lr_bitpos, rr_bitpos);
2960: end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
2961: rnmode = get_best_mode (end_bit - first_bit, first_bit,
2962: TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
2963: volatilep);
2964: if (rnmode == VOIDmode)
2965: return 0;
2966:
2967: rnbitsize = GET_MODE_BITSIZE (rnmode);
2968: rnbitpos = first_bit & ~ (rnbitsize - 1);
2969: xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
2970:
2971: #if BYTES_BIG_ENDIAN
2972: xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
2973: xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
2974: #endif
2975:
2976: lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
2977: size_int (xlr_bitpos), 0);
2978: rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
2979: size_int (xrr_bitpos), 0);
2980:
2981: /* Make a mask that corresponds to both fields being compared.
2982: Do this for both items being compared. If the masks agree,
2983: we can do this by masking both and comparing the masked
2984: results. */
2985: ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
2986: lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
2987: if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
2988: {
2989: lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
2990: ll_unsignedp || rl_unsignedp);
2991: rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
2992: lr_unsignedp || rr_unsignedp);
2993: if (! all_ones_mask_p (ll_mask, lnbitsize))
2994: {
2995: lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
2996: rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
2997: }
2998: return build (wanted_code, truth_type, lhs, rhs);
2999: }
3000:
3001: /* There is still another way we can do something: If both pairs of
3002: fields being compared are adjacent, we may be able to make a wider
3003: field containing them both. */
3004: if ((ll_bitsize + ll_bitpos == rl_bitpos
3005: && lr_bitsize + lr_bitpos == rr_bitpos)
3006: || (ll_bitpos == rl_bitpos + rl_bitsize
3007: && lr_bitpos == rr_bitpos + rr_bitsize))
3008: return build (wanted_code, truth_type,
3009: make_bit_field_ref (ll_inner, type,
3010: ll_bitsize + rl_bitsize,
3011: MIN (ll_bitpos, rl_bitpos),
3012: ll_unsignedp),
3013: make_bit_field_ref (lr_inner, type,
3014: lr_bitsize + rr_bitsize,
3015: MIN (lr_bitpos, rr_bitpos),
3016: lr_unsignedp));
3017:
3018: return 0;
3019: }
3020:
3021: /* Handle the case of comparisons with constants. If there is something in
3022: common between the masks, those bits of the constants must be the same.
3023: If not, the condition is always false. Test for this to avoid generating
3024: incorrect code below. */
3025: result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
3026: if (! integer_zerop (result)
3027: && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
3028: const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
3029: {
3030: if (wanted_code == NE_EXPR)
3031: {
3032: warning ("`or' of unmatched not-equal tests is always 1");
3033: return convert (truth_type, integer_one_node);
3034: }
3035: else
3036: {
3037: warning ("`and' of mutually exclusive equal-tests is always zero");
3038: return convert (truth_type, integer_zero_node);
3039: }
3040: }
3041:
3042: /* Construct the expression we will return. First get the component
3043: reference we will make. Unless the mask is all ones the width of
3044: that field, perform the mask operation. Then compare with the
3045: merged constant. */
3046: result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
3047: ll_unsignedp || rl_unsignedp);
3048:
3049: ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
3050: if (! all_ones_mask_p (ll_mask, lnbitsize))
3051: result = build (BIT_AND_EXPR, type, result, ll_mask);
3052:
3053: return build (wanted_code, truth_type, result,
3054: const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
3055: }
3056:
3057: /* Perform constant folding and related simplification of EXPR.
3058: The related simplifications include x*1 => x, x*0 => 0, etc.,
3059: and application of the associative law.
3060: NOP_EXPR conversions may be removed freely (as long as we
3061: are careful not to change the C type of the overall expression)
3062: We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
3063: but we can constant-fold them if they have constant operands. */
3064:
3065: tree
3066: fold (expr)
3067: tree expr;
3068: {
3069: register tree t = expr;
3070: tree t1 = NULL_TREE;
3071: tree tem;
3072: tree type = TREE_TYPE (expr);
3073: register tree arg0, arg1;
3074: register enum tree_code code = TREE_CODE (t);
3075: register int kind;
3076: int invert;
3077:
3078: /* WINS will be nonzero when the switch is done
3079: if all operands are constant. */
3080:
3081: int wins = 1;
3082:
3083: /* Don't try to process an RTL_EXPR since its operands aren't trees. */
3084: if (code == RTL_EXPR)
3085: return t;
3086:
3087: /* Return right away if already constant. */
3088: if (TREE_CONSTANT (t))
3089: {
3090: if (code == CONST_DECL)
3091: return DECL_INITIAL (t);
3092: return t;
3093: }
3094:
3095: kind = TREE_CODE_CLASS (code);
3096: if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)
3097: {
3098: tree subop;
3099:
3100: /* Special case for conversion ops that can have fixed point args. */
3101: arg0 = TREE_OPERAND (t, 0);
3102:
3103: /* Don't use STRIP_NOPS, because signedness of argument type matters. */
3104: if (arg0 != 0)
3105: STRIP_TYPE_NOPS (arg0);
3106:
3107: if (arg0 != 0 && TREE_CODE (arg0) == COMPLEX_CST)
3108: subop = TREE_REALPART (arg0);
3109: else
3110: subop = arg0;
3111:
3112: if (subop != 0 && TREE_CODE (subop) != INTEGER_CST
3113: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3114: && TREE_CODE (subop) != REAL_CST
3115: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3116: )
3117: /* Note that TREE_CONSTANT isn't enough:
3118: static var addresses are constant but we can't
3119: do arithmetic on them. */
3120: wins = 0;
3121: }
3122: else if (kind == 'e' || kind == '<'
3123: || kind == '1' || kind == '2' || kind == 'r')
3124: {
3125: register int len = tree_code_length[(int) code];
3126: register int i;
3127: for (i = 0; i < len; i++)
3128: {
3129: tree op = TREE_OPERAND (t, i);
3130: tree subop;
3131:
3132: if (op == 0)
3133: continue; /* Valid for CALL_EXPR, at least. */
3134:
3135: if (kind == '<' || code == RSHIFT_EXPR)
3136: {
3137: /* Signedness matters here. Perhaps we can refine this
3138: later. */
3139: STRIP_TYPE_NOPS (op);
3140: }
3141: else
3142: {
3143: /* Strip any conversions that don't change the mode. */
3144: STRIP_NOPS (op);
3145: }
3146:
3147: if (TREE_CODE (op) == COMPLEX_CST)
3148: subop = TREE_REALPART (op);
3149: else
3150: subop = op;
3151:
3152: if (TREE_CODE (subop) != INTEGER_CST
3153: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3154: && TREE_CODE (subop) != REAL_CST
3155: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
3156: )
3157: /* Note that TREE_CONSTANT isn't enough:
3158: static var addresses are constant but we can't
3159: do arithmetic on them. */
3160: wins = 0;
3161:
3162: if (i == 0)
3163: arg0 = op;
3164: else if (i == 1)
3165: arg1 = op;
3166: }
3167: }
3168:
3169: /* If this is a commutative operation, and ARG0 is a constant, move it
3170: to ARG1 to reduce the number of tests below. */
3171: if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
3172: || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
3173: || code == BIT_AND_EXPR)
3174: && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
3175: {
3176: tem = arg0; arg0 = arg1; arg1 = tem;
3177:
3178: tem = TREE_OPERAND (t, 0); TREE_OPERAND (t, 0) = TREE_OPERAND (t, 1);
3179: TREE_OPERAND (t, 1) = tem;
3180: }
3181:
3182: /* Now WINS is set as described above,
3183: ARG0 is the first operand of EXPR,
3184: and ARG1 is the second operand (if it has more than one operand).
3185:
3186: First check for cases where an arithmetic operation is applied to a
3187: compound, conditional, or comparison operation. Push the arithmetic
3188: operation inside the compound or conditional to see if any folding
3189: can then be done. Convert comparison to conditional for this purpose.
3190: The also optimizes non-constant cases that used to be done in
3191: expand_expr.
3192:
3193: Before we do that, see if this is a BIT_AND_EXPR or a BIT_OR_EXPR,
3194: one of the operands is a comparison and the other is either a comparison
3195: or a BIT_AND_EXPR with the constant 1. In that case, the code below
3196: would make the expression more complex. Change it to a
3197: TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
3198: TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
3199:
3200: if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
3201: || code == EQ_EXPR || code == NE_EXPR)
3202: && ((TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
3203: && (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
3204: || (TREE_CODE (arg1) == BIT_AND_EXPR
3205: && integer_onep (TREE_OPERAND (arg1, 1)))))
3206: || (TREE_CODE_CLASS (TREE_CODE (arg1)) == '<'
3207: && (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
3208: || (TREE_CODE (arg0) == BIT_AND_EXPR
3209: && integer_onep (TREE_OPERAND (arg0, 1)))))))
3210: {
3211: t = fold (build (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
3212: : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
3213: : TRUTH_XOR_EXPR,
3214: type, arg0, arg1));
3215:
3216: if (code == EQ_EXPR)
3217: t = invert_truthvalue (t);
3218:
3219: return t;
3220: }
3221:
3222: if (TREE_CODE_CLASS (code) == '1')
3223: {
3224: if (TREE_CODE (arg0) == COMPOUND_EXPR)
3225: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
3226: fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
3227: else if (TREE_CODE (arg0) == COND_EXPR)
3228: {
3229: t = fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
3230: fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
3231: fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
3232:
3233: /* If this was a conversion, and all we did was to move into
3234: inside the COND_EXPR, bring it back out. Then return so we
3235: don't get into an infinite recursion loop taking the conversion
3236: out and then back in. */
3237:
3238: if ((code == NOP_EXPR || code == CONVERT_EXPR
3239: || code == NON_LVALUE_EXPR)
3240: && TREE_CODE (t) == COND_EXPR
3241: && TREE_CODE (TREE_OPERAND (t, 1)) == code
3242: && TREE_CODE (TREE_OPERAND (t, 2)) == code
3243: && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0))
3244: == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 2), 0))))
3245: t = build1 (code, type,
3246: build (COND_EXPR,
3247: TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0)),
3248: TREE_OPERAND (t, 0),
3249: TREE_OPERAND (TREE_OPERAND (t, 1), 0),
3250: TREE_OPERAND (TREE_OPERAND (t, 2), 0)));
3251: return t;
3252: }
3253: else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
3254: return fold (build (COND_EXPR, type, arg0,
3255: fold (build1 (code, type, integer_one_node)),
3256: fold (build1 (code, type, integer_zero_node))));
3257: }
3258: else if (TREE_CODE_CLASS (code) == '2'
3259: || TREE_CODE_CLASS (code) == '<')
3260: {
3261: if (TREE_CODE (arg1) == COMPOUND_EXPR)
3262: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
3263: fold (build (code, type,
3264: arg0, TREE_OPERAND (arg1, 1))));
3265: else if (TREE_CODE (arg1) == COND_EXPR
3266: || TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
3267: {
3268: tree test, true_value, false_value;
3269:
3270: if (TREE_CODE (arg1) == COND_EXPR)
3271: {
3272: test = TREE_OPERAND (arg1, 0);
3273: true_value = TREE_OPERAND (arg1, 1);
3274: false_value = TREE_OPERAND (arg1, 2);
3275: }
3276: else
3277: {
3278: test = arg1;
3279: true_value = integer_one_node;
3280: false_value = integer_zero_node;
3281: }
3282:
3283: /* If ARG0 is complex we want to make sure we only evaluate
3284: it once. Though this is only required if it is volatile, it
3285: might be more efficient even if it is not. However, if we
3286: succeed in folding one part to a constant, we do not need
3287: to make this SAVE_EXPR. Since we do this optimization
3288: primarily to see if we do end up with constant and this
3289: SAVE_EXPR interfers with later optimizations, suppressing
3290: it when we can is important. */
3291:
3292: if ((TREE_CODE (arg0) != VAR_DECL && TREE_CODE (arg0) != PARM_DECL)
3293: || TREE_SIDE_EFFECTS (arg0))
3294: {
3295: tree lhs = fold (build (code, type, arg0, true_value));
3296: tree rhs = fold (build (code, type, arg0, false_value));
3297:
3298: if (TREE_CONSTANT (lhs) || TREE_CONSTANT (rhs))
3299: return fold (build (COND_EXPR, type, test, lhs, rhs));
3300:
3301: arg0 = save_expr (arg0);
3302: }
3303:
3304: test = fold (build (COND_EXPR, type, test,
3305: fold (build (code, type, arg0, true_value)),
3306: fold (build (code, type, arg0, false_value))));
3307: if (TREE_CODE (arg0) == SAVE_EXPR)
3308: return build (COMPOUND_EXPR, type,
3309: convert (void_type_node, arg0), test);
3310: else
3311: return convert (type, test);
3312: }
3313:
3314: else if (TREE_CODE (arg0) == COMPOUND_EXPR)
3315: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
3316: fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
3317: else if (TREE_CODE (arg0) == COND_EXPR
3318: || TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
3319: {
3320: tree test, true_value, false_value;
3321:
3322: if (TREE_CODE (arg0) == COND_EXPR)
3323: {
3324: test = TREE_OPERAND (arg0, 0);
3325: true_value = TREE_OPERAND (arg0, 1);
3326: false_value = TREE_OPERAND (arg0, 2);
3327: }
3328: else
3329: {
3330: test = arg0;
3331: true_value = integer_one_node;
3332: false_value = integer_zero_node;
3333: }
3334:
3335: if ((TREE_CODE (arg1) != VAR_DECL && TREE_CODE (arg1) != PARM_DECL)
3336: || TREE_SIDE_EFFECTS (arg1))
3337: {
3338: tree lhs = fold (build (code, type, true_value, arg1));
3339: tree rhs = fold (build (code, type, false_value, arg1));
3340:
3341: if (TREE_CONSTANT (lhs) || TREE_CONSTANT (rhs))
3342: return fold (build (COND_EXPR, type, test, lhs, rhs));
3343:
3344: arg1 = save_expr (arg1);
3345: }
3346:
3347: test = fold (build (COND_EXPR, type, test,
3348: fold (build (code, type, true_value, arg1)),
3349: fold (build (code, type, false_value, arg1))));
3350: if (TREE_CODE (arg1) == SAVE_EXPR)
3351: return build (COMPOUND_EXPR, type,
3352: convert (void_type_node, arg1), test);
3353: else
3354: return convert (type, test);
3355: }
3356: }
3357: else if (TREE_CODE_CLASS (code) == '<'
3358: && TREE_CODE (arg0) == COMPOUND_EXPR)
3359: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
3360: fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
3361: else if (TREE_CODE_CLASS (code) == '<'
3362: && TREE_CODE (arg1) == COMPOUND_EXPR)
3363: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
3364: fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
3365:
3366: switch (code)
3367: {
3368: case INTEGER_CST:
3369: case REAL_CST:
3370: case STRING_CST:
3371: case COMPLEX_CST:
3372: case CONSTRUCTOR:
3373: return t;
3374:
3375: case CONST_DECL:
3376: return fold (DECL_INITIAL (t));
3377:
3378: case NOP_EXPR:
3379: case FLOAT_EXPR:
3380: case CONVERT_EXPR:
3381: case FIX_TRUNC_EXPR:
3382: /* Other kinds of FIX are not handled properly by fold_convert. */
3383:
3384: /* In addition to the cases of two conversions in a row
3385: handled below, if we are converting something to its own
3386: type via an object of identical or wider precision, neither
3387: conversion is needed. */
3388: if ((TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
3389: || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
3390: && TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == TREE_TYPE (t)
3391: && ((INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))
3392: && INTEGRAL_TYPE_P (TREE_TYPE (t)))
3393: || (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))
3394: && FLOAT_TYPE_P (TREE_TYPE (t))))
3395: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3396: >= TYPE_PRECISION (TREE_TYPE (t))))
3397: return TREE_OPERAND (TREE_OPERAND (t, 0), 0);
3398:
3399: /* Two conversions in a row are not needed unless:
3400: - the intermediate type is narrower than both initial and final, or
3401: - the intermediate type and innermost type differ in signedness,
3402: and the outermost type is wider than the intermediate, or
3403: - the initial type is a pointer type and the precisions of the
3404: intermediate and final types differ, or
3405: - the final type is a pointer type and the precisions of the
3406: initial and intermediate types differ. */
3407: if ((TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
3408: || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
3409: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3410: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
3411: ||
3412: TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3413: > TYPE_PRECISION (TREE_TYPE (t)))
3414: && ! ((TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
3415: == INTEGER_TYPE)
3416: && (TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
3417: == INTEGER_TYPE)
3418: && (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t, 0)))
3419: != TREE_UNSIGNED (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
3420: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3421: < TYPE_PRECISION (TREE_TYPE (t))))
3422: && ((TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t, 0)))
3423: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3424: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))))
3425: ==
3426: (TREE_UNSIGNED (TREE_TYPE (t))
3427: && (TYPE_PRECISION (TREE_TYPE (t))
3428: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0))))))
3429: && ! ((TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
3430: == POINTER_TYPE)
3431: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
3432: != TYPE_PRECISION (TREE_TYPE (t))))
3433: && ! (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
3434: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
3435: != TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0))))))
3436: return convert (TREE_TYPE (t), TREE_OPERAND (TREE_OPERAND (t, 0), 0));
3437:
3438: if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
3439: && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1))
3440: /* Detect assigning a bitfield. */
3441: && !(TREE_CODE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) == COMPONENT_REF
3442: && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
3443: {
3444: /* Don't leave an assignment inside a conversion
3445: unless assigning a bitfield. */
3446: tree prev = TREE_OPERAND (t, 0);
3447: TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
3448: /* First do the assignment, then return converted constant. */
3449: t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
3450: TREE_USED (t) = 1;
3451: return t;
3452: }
3453: if (!wins)
3454: {
3455: TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
3456: return t;
3457: }
3458: return fold_convert (t, arg0);
3459:
3460: #if 0 /* This loses on &"foo"[0]. */
3461: case ARRAY_REF:
3462: {
3463: int i;
3464:
3465: /* Fold an expression like: "foo"[2] */
3466: if (TREE_CODE (arg0) == STRING_CST
3467: && TREE_CODE (arg1) == INTEGER_CST
3468: && !TREE_INT_CST_HIGH (arg1)
3469: && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
3470: {
3471: t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
3472: TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
3473: force_fit_type (t, 0);
3474: }
3475: }
3476: return t;
3477: #endif /* 0 */
3478:
3479: case RANGE_EXPR:
3480: TREE_CONSTANT (t) = wins;
3481: return t;
3482:
3483: case NEGATE_EXPR:
3484: if (wins)
3485: {
3486: if (TREE_CODE (arg0) == INTEGER_CST)
3487: {
3488: HOST_WIDE_INT low, high;
3489: int overflow = neg_double (TREE_INT_CST_LOW (arg0),
3490: TREE_INT_CST_HIGH (arg0),
3491: &low, &high);
3492: t = build_int_2 (low, high);
3493: TREE_TYPE (t) = type;
3494: TREE_OVERFLOW (t)
3495: = (TREE_OVERFLOW (arg0)
3496: | force_fit_type (t, overflow));
3497: TREE_CONSTANT_OVERFLOW (t)
3498: = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
3499: }
3500: else if (TREE_CODE (arg0) == REAL_CST)
3501: t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
3502: TREE_TYPE (t) = type;
3503: }
3504: else if (TREE_CODE (arg0) == NEGATE_EXPR)
3505: return TREE_OPERAND (arg0, 0);
3506:
3507: /* Convert - (a - b) to (b - a) for non-floating-point. */
3508: else if (TREE_CODE (arg0) == MINUS_EXPR && ! FLOAT_TYPE_P (type))
3509: return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
3510: TREE_OPERAND (arg0, 0));
3511:
3512: return t;
3513:
3514: case ABS_EXPR:
3515: if (wins)
3516: {
3517: if (TREE_CODE (arg0) == INTEGER_CST)
3518: {
3519: if (! TREE_UNSIGNED (type)
3520: && TREE_INT_CST_HIGH (arg0) < 0)
3521: {
3522: HOST_WIDE_INT low, high;
3523: int overflow = neg_double (TREE_INT_CST_LOW (arg0),
3524: TREE_INT_CST_HIGH (arg0),
3525: &low, &high);
3526: t = build_int_2 (low, high);
3527: TREE_TYPE (t) = type;
3528: TREE_OVERFLOW (t)
3529: = (TREE_OVERFLOW (arg0)
3530: | force_fit_type (t, overflow));
3531: TREE_CONSTANT_OVERFLOW (t)
3532: = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg0);
3533: }
3534: }
3535: else if (TREE_CODE (arg0) == REAL_CST)
3536: {
3537: if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
3538: t = build_real (type,
3539: REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
3540: }
3541: TREE_TYPE (t) = type;
3542: }
3543: else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
3544: return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
3545: return t;
3546:
3547: case CONJ_EXPR:
3548: if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
3549: return arg0;
3550: else if (TREE_CODE (arg0) == COMPLEX_EXPR)
3551: return build (COMPLEX_EXPR, TREE_TYPE (arg0),
3552: TREE_OPERAND (arg0, 0),
3553: fold (build1 (NEGATE_EXPR,
3554: TREE_TYPE (TREE_TYPE (arg0)),
3555: TREE_OPERAND (arg0, 1))));
3556: else if (TREE_CODE (arg0) == COMPLEX_CST)
3557: return build_complex (TREE_OPERAND (arg0, 0),
3558: fold (build1 (NEGATE_EXPR,
3559: TREE_TYPE (TREE_TYPE (arg0)),
3560: TREE_OPERAND (arg0, 1))));
3561: else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
3562: return fold (build (TREE_CODE (arg0), type,
3563: fold (build1 (CONJ_EXPR, type,
3564: TREE_OPERAND (arg0, 0))),
3565: fold (build1 (CONJ_EXPR,
3566: type, TREE_OPERAND (arg0, 1)))));
3567: else if (TREE_CODE (arg0) == CONJ_EXPR)
3568: return TREE_OPERAND (arg0, 0);
3569: return t;
3570:
3571: case BIT_NOT_EXPR:
3572: if (wins)
3573: {
3574: if (TREE_CODE (arg0) == INTEGER_CST)
3575: t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
3576: ~ TREE_INT_CST_HIGH (arg0));
3577: TREE_TYPE (t) = type;
3578: force_fit_type (t, 0);
3579: TREE_OVERFLOW (t) = TREE_OVERFLOW (arg0);
3580: TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (arg0);
3581: }
3582: else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
3583: return TREE_OPERAND (arg0, 0);
3584: return t;
3585:
3586: case PLUS_EXPR:
3587: /* A + (-B) -> A - B */
3588: if (TREE_CODE (arg1) == NEGATE_EXPR)
3589: return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
3590: else if (! FLOAT_TYPE_P (type))
3591: {
3592: if (integer_zerop (arg1))
3593: return non_lvalue (convert (type, arg0));
3594:
3595: /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
3596: with a constant, and the two constants have no bits in common,
3597: we should treat this as a BIT_IOR_EXPR since this may produce more
3598: simplifications. */
3599: if (TREE_CODE (arg0) == BIT_AND_EXPR
3600: && TREE_CODE (arg1) == BIT_AND_EXPR
3601: && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
3602: && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
3603: && integer_zerop (const_binop (BIT_AND_EXPR,
3604: TREE_OPERAND (arg0, 1),
3605: TREE_OPERAND (arg1, 1), 0)))
3606: {
3607: code = BIT_IOR_EXPR;
3608: goto bit_ior;
3609: }
3610:
3611: /* (A * C) + (B * C) -> (A+B) * C. Since we are most concerned
3612: about the case where C is a constant, just try one of the
3613: four possibilities. */
3614:
3615: if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
3616: && operand_equal_p (TREE_OPERAND (arg0, 1),
3617: TREE_OPERAND (arg1, 1), 0))
3618: return fold (build (MULT_EXPR, type,
3619: fold (build (PLUS_EXPR, type,
3620: TREE_OPERAND (arg0, 0),
3621: TREE_OPERAND (arg1, 0))),
3622: TREE_OPERAND (arg0, 1)));
3623: }
3624: /* In IEEE floating point, x+0 may not equal x. */
3625: else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3626: && real_zerop (arg1))
3627: return non_lvalue (convert (type, arg0));
3628: associate:
3629: /* In most languages, can't associate operations on floats
3630: through parentheses. Rather than remember where the parentheses
3631: were, we don't associate floats at all. It shouldn't matter much. */
3632: if (FLOAT_TYPE_P (type))
3633: goto binary;
3634: /* The varsign == -1 cases happen only for addition and subtraction.
3635: It says that the arg that was split was really CON minus VAR.
3636: The rest of the code applies to all associative operations. */
3637: if (!wins)
3638: {
3639: tree var, con;
3640: int varsign;
3641:
3642: if (split_tree (arg0, code, &var, &con, &varsign))
3643: {
3644: if (varsign == -1)
3645: {
3646: /* EXPR is (CON-VAR) +- ARG1. */
3647: /* If it is + and VAR==ARG1, return just CONST. */
3648: if (code == PLUS_EXPR && operand_equal_p (var, arg1, 0))
3649: return convert (TREE_TYPE (t), con);
3650:
3651: /* If ARG0 is a constant, don't change things around;
3652: instead keep all the constant computations together. */
3653:
3654: if (TREE_CONSTANT (arg0))
3655: return t;
3656:
3657: /* Otherwise return (CON +- ARG1) - VAR. */
3658: TREE_SET_CODE (t, MINUS_EXPR);
3659: TREE_OPERAND (t, 1) = var;
3660: TREE_OPERAND (t, 0)
3661: = fold (build (code, TREE_TYPE (t), con, arg1));
3662: }
3663: else
3664: {
3665: /* EXPR is (VAR+CON) +- ARG1. */
3666: /* If it is - and VAR==ARG1, return just CONST. */
3667: if (code == MINUS_EXPR && operand_equal_p (var, arg1, 0))
3668: return convert (TREE_TYPE (t), con);
3669:
3670: /* If ARG0 is a constant, don't change things around;
3671: instead keep all the constant computations together. */
3672:
3673: if (TREE_CONSTANT (arg0))
3674: return t;
3675:
3676: /* Otherwise return VAR +- (ARG1 +- CON). */
3677: TREE_OPERAND (t, 1) = tem
3678: = fold (build (code, TREE_TYPE (t), arg1, con));
3679: TREE_OPERAND (t, 0) = var;
3680: if (integer_zerop (tem)
3681: && (code == PLUS_EXPR || code == MINUS_EXPR))
3682: return convert (type, var);
3683: /* If we have x +/- (c - d) [c an explicit integer]
3684: change it to x -/+ (d - c) since if d is relocatable
3685: then the latter can be a single immediate insn
3686: and the former cannot. */
3687: if (TREE_CODE (tem) == MINUS_EXPR
3688: && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
3689: {
3690: tree tem1 = TREE_OPERAND (tem, 1);
3691: TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
3692: TREE_OPERAND (tem, 0) = tem1;
3693: TREE_SET_CODE (t,
3694: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
3695: }
3696: }
3697: return t;
3698: }
3699:
3700: if (split_tree (arg1, code, &var, &con, &varsign))
3701: {
3702: if (TREE_CONSTANT (arg1))
3703: return t;
3704:
3705: if (varsign == -1)
3706: TREE_SET_CODE (t,
3707: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
3708:
3709: /* EXPR is ARG0 +- (CON +- VAR). */
3710: if (TREE_CODE (t) == MINUS_EXPR
3711: && operand_equal_p (var, arg0, 0))
3712: {
3713: /* If VAR and ARG0 cancel, return just CON or -CON. */
3714: if (code == PLUS_EXPR)
3715: return convert (TREE_TYPE (t), con);
3716: return fold (build1 (NEGATE_EXPR, TREE_TYPE (t),
3717: convert (TREE_TYPE (t), con)));
3718: }
3719:
3720: TREE_OPERAND (t, 0)
3721: = fold (build (code, TREE_TYPE (t), arg0, con));
3722: TREE_OPERAND (t, 1) = var;
3723: if (integer_zerop (TREE_OPERAND (t, 0))
3724: && TREE_CODE (t) == PLUS_EXPR)
3725: return convert (TREE_TYPE (t), var);
3726: return t;
3727: }
3728: }
3729: binary:
3730: #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
3731: if (TREE_CODE (arg1) == REAL_CST)
3732: return t;
3733: #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
3734: if (wins)
3735: t1 = const_binop (code, arg0, arg1, 0);
3736: if (t1 != NULL_TREE)
3737: {
3738: /* The return value should always have
3739: the same type as the original expression. */
3740: TREE_TYPE (t1) = TREE_TYPE (t);
3741: return t1;
3742: }
3743: return t;
3744:
3745: case MINUS_EXPR:
3746: if (! FLOAT_TYPE_P (type))
3747: {
3748: if (! wins && integer_zerop (arg0))
3749: return build1 (NEGATE_EXPR, type, arg1);
3750: if (integer_zerop (arg1))
3751: return non_lvalue (convert (type, arg0));
3752:
3753: /* (A * C) - (B * C) -> (A-B) * C. Since we are most concerned
3754: about the case where C is a constant, just try one of the
3755: four possibilities. */
3756:
3757: if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
3758: && operand_equal_p (TREE_OPERAND (arg0, 1),
3759: TREE_OPERAND (arg1, 1), 0))
3760: return fold (build (MULT_EXPR, type,
3761: fold (build (MINUS_EXPR, type,
3762: TREE_OPERAND (arg0, 0),
3763: TREE_OPERAND (arg1, 0))),
3764: TREE_OPERAND (arg0, 1)));
3765: }
3766: /* Convert A - (-B) to A + B. */
3767: else if (TREE_CODE (arg1) == NEGATE_EXPR)
3768: return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
3769: else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3770: {
3771: /* Except with IEEE floating point, 0-x equals -x. */
3772: if (! wins && real_zerop (arg0))
3773: return build1 (NEGATE_EXPR, type, arg1);
3774: /* Except with IEEE floating point, x-0 equals x. */
3775: if (real_zerop (arg1))
3776: return non_lvalue (convert (type, arg0));
3777:
3778: /* Fold &x - &x. This can happen from &x.foo - &x.
3779: This is unsafe for certain floats even in non-IEEE formats.
3780: In IEEE, it is unsafe because it does wrong for NaNs.
3781: Also note that operand_equal_p is always false if an operand
3782: is volatile. */
3783:
3784: if (operand_equal_p (arg0, arg1, FLOAT_TYPE_P (type)))
3785: return convert (type, integer_zero_node);
3786: }
3787: goto associate;
3788:
3789: case MULT_EXPR:
3790: if (! FLOAT_TYPE_P (type))
3791: {
3792: if (integer_zerop (arg1))
3793: return omit_one_operand (type, arg1, arg0);
3794: if (integer_onep (arg1))
3795: return non_lvalue (convert (type, arg0));
3796:
3797: /* (a * (1 << b)) is (a << b) */
3798: if (TREE_CODE (arg1) == LSHIFT_EXPR
3799: && integer_onep (TREE_OPERAND (arg1, 0)))
3800: return fold (build (LSHIFT_EXPR, type, arg0,
3801: TREE_OPERAND (arg1, 1)));
3802: if (TREE_CODE (arg0) == LSHIFT_EXPR
3803: && integer_onep (TREE_OPERAND (arg0, 0)))
3804: return fold (build (LSHIFT_EXPR, type, arg1,
3805: TREE_OPERAND (arg0, 1)));
3806: }
3807: else
3808: {
3809: /* x*0 is 0, except for IEEE floating point. */
3810: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
3811: && real_zerop (arg1))
3812: return omit_one_operand (type, arg1, arg0);
3813: /* In IEEE floating point, x*1 is not equivalent to x for snans.
3814: However, ANSI says we can drop signals,
3815: so we can do this anyway. */
3816: if (real_onep (arg1))
3817: return non_lvalue (convert (type, arg0));
3818: /* x*2 is x+x */
3819: if (! wins && real_twop (arg1))
3820: {
3821: tree arg = save_expr (arg0);
3822: return build (PLUS_EXPR, type, arg, arg);
3823: }
3824: }
3825: goto associate;
3826:
3827: case BIT_IOR_EXPR:
3828: bit_ior:
3829: if (integer_all_onesp (arg1))
3830: return omit_one_operand (type, arg1, arg0);
3831: if (integer_zerop (arg1))
3832: return non_lvalue (convert (type, arg0));
3833: t1 = distribute_bit_expr (code, type, arg0, arg1);
3834: if (t1 != NULL_TREE)
3835: return t1;
3836:
3837: /* (a << C1) | (a >> C2) if A is unsigned and C1+C2 is the size of A
3838: is a rotate of A by C1 bits. */
3839:
3840: if ((TREE_CODE (arg0) == RSHIFT_EXPR
3841: || TREE_CODE (arg0) == LSHIFT_EXPR)
3842: && (TREE_CODE (arg1) == RSHIFT_EXPR
3843: || TREE_CODE (arg1) == LSHIFT_EXPR)
3844: && TREE_CODE (arg0) != TREE_CODE (arg1)
3845: && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1,0), 0)
3846: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0)))
3847: && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
3848: && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
3849: && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
3850: && TREE_INT_CST_HIGH (TREE_OPERAND (arg1, 1)) == 0
3851: && ((TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
3852: + TREE_INT_CST_LOW (TREE_OPERAND (arg1, 1)))
3853: == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
3854: return build (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
3855: TREE_CODE (arg0) == LSHIFT_EXPR
3856: ? TREE_OPERAND (arg0, 1) : TREE_OPERAND (arg1, 1));
3857:
3858: goto associate;
3859:
3860: case BIT_XOR_EXPR:
3861: if (integer_zerop (arg1))
3862: return non_lvalue (convert (type, arg0));
3863: if (integer_all_onesp (arg1))
3864: return fold (build1 (BIT_NOT_EXPR, type, arg0));
3865: goto associate;
3866:
3867: case BIT_AND_EXPR:
3868: bit_and:
3869: if (integer_all_onesp (arg1))
3870: return non_lvalue (convert (type, arg0));
3871: if (integer_zerop (arg1))
3872: return omit_one_operand (type, arg1, arg0);
3873: t1 = distribute_bit_expr (code, type, arg0, arg1);
3874: if (t1 != NULL_TREE)
3875: return t1;
3876: /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
3877: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
3878: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
3879: {
3880: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
3881: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
3882: && (~TREE_INT_CST_LOW (arg0)
3883: & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
3884: return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
3885: }
3886: if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
3887: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
3888: {
3889: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
3890: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
3891: && (~TREE_INT_CST_LOW (arg1)
3892: & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
3893: return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
3894: }
3895: goto associate;
3896:
3897: case BIT_ANDTC_EXPR:
3898: if (integer_all_onesp (arg0))
3899: return non_lvalue (convert (type, arg1));
3900: if (integer_zerop (arg0))
3901: return omit_one_operand (type, arg0, arg1);
3902: if (TREE_CODE (arg1) == INTEGER_CST)
3903: {
3904: arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
3905: code = BIT_AND_EXPR;
3906: goto bit_and;
3907: }
3908: goto binary;
3909:
3910: case TRUNC_DIV_EXPR:
3911: case ROUND_DIV_EXPR:
3912: case FLOOR_DIV_EXPR:
3913: case CEIL_DIV_EXPR:
3914: case EXACT_DIV_EXPR:
3915: case RDIV_EXPR:
3916: if (integer_onep (arg1))
3917: return non_lvalue (convert (type, arg0));
3918: if (integer_zerop (arg1))
3919: return t;
3920:
3921: /* Look for ((a * C1) / C3) or (((a * C1) + C2) / C3),
3922: where C1 % C3 == 0 or C3 % C1 == 0. We can simplify these
3923: expressions, which often appear in the offsets or sizes of
3924: objects with a varying size. Only deal with positive divisors
3925: and multiplicands. If C2 is negative, we must have C2 % C3 == 0.
3926:
3927: Look for NOPs and SAVE_EXPRs inside. */
3928:
3929: if (TREE_CODE (arg1) == INTEGER_CST
3930: && tree_int_cst_lt (integer_zero_node, arg1))
3931: {
3932: int have_save_expr = 0;
3933: tree c2 = integer_zero_node;
3934: tree xarg0 = arg0;
3935:
3936: if (TREE_CODE (xarg0) == SAVE_EXPR)
3937: have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
3938:
3939: STRIP_NOPS (xarg0);
3940:
3941: if (TREE_CODE (xarg0) == PLUS_EXPR
3942: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
3943: c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
3944: else if (TREE_CODE (xarg0) == MINUS_EXPR
3945: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
3946: /* If we are doing this computation unsigned, the negate
3947: is incorrect. */
3948: && ! TREE_UNSIGNED (type))
3949: {
3950: c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
3951: xarg0 = TREE_OPERAND (xarg0, 0);
3952: }
3953:
3954: if (TREE_CODE (xarg0) == SAVE_EXPR)
3955: have_save_expr = 1, xarg0 = TREE_OPERAND (xarg0, 0);
3956:
3957: STRIP_NOPS (xarg0);
3958:
3959: if (TREE_CODE (xarg0) == MULT_EXPR
3960: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
3961: && tree_int_cst_lt (integer_zero_node, TREE_OPERAND (xarg0, 1))
3962: && (integer_zerop (const_binop (TRUNC_MOD_EXPR,
3963: TREE_OPERAND (xarg0, 1), arg1, 1))
3964: || integer_zerop (const_binop (TRUNC_MOD_EXPR, arg1,
3965: TREE_OPERAND (xarg0, 1), 1)))
3966: && (tree_int_cst_lt (integer_zero_node, c2)
3967: || integer_zerop (const_binop (TRUNC_MOD_EXPR, c2,
3968: arg1, 1))))
3969: {
3970: tree outer_div = integer_one_node;
3971: tree c1 = TREE_OPERAND (xarg0, 1);
3972: tree c3 = arg1;
3973:
3974: /* If C3 > C1, set them equal and do a divide by
3975: C3/C1 at the end of the operation. */
3976: if (tree_int_cst_lt (c1, c3))
3977: outer_div = const_binop (code, c3, c1, 0), c3 = c1;
3978:
3979: /* The result is A * (C1/C3) + (C2/C3). */
3980: t = fold (build (PLUS_EXPR, type,
3981: fold (build (MULT_EXPR, type,
3982: TREE_OPERAND (xarg0, 0),
3983: const_binop (code, c1, c3, 1))),
3984: const_binop (code, c2, c3, 1)));
3985:
3986: if (! integer_onep (outer_div))
3987: t = fold (build (code, type, t, outer_div));
3988:
3989: if (have_save_expr)
3990: t = save_expr (t);
3991:
3992: return t;
3993: }
3994: }
3995:
3996: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
3997: #ifndef REAL_INFINITY
3998: if (TREE_CODE (arg1) == REAL_CST
3999: && real_zerop (arg1))
4000: return t;
4001: #endif
4002: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
4003:
4004: goto binary;
4005:
4006: case CEIL_MOD_EXPR:
4007: case FLOOR_MOD_EXPR:
4008: case ROUND_MOD_EXPR:
4009: case TRUNC_MOD_EXPR:
4010: if (integer_onep (arg1))
4011: return omit_one_operand (type, integer_zero_node, arg0);
4012: if (integer_zerop (arg1))
4013: return t;
4014:
4015: /* Look for ((a * C1) % C3) or (((a * C1) + C2) % C3),
4016: where C1 % C3 == 0. Handle similarly to the division case,
4017: but don't bother with SAVE_EXPRs. */
4018:
4019: if (TREE_CODE (arg1) == INTEGER_CST
4020: && ! integer_zerop (arg1))
4021: {
4022: tree c2 = integer_zero_node;
4023: tree xarg0 = arg0;
4024:
4025: if (TREE_CODE (xarg0) == PLUS_EXPR
4026: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST)
4027: c2 = TREE_OPERAND (xarg0, 1), xarg0 = TREE_OPERAND (xarg0, 0);
4028: else if (TREE_CODE (xarg0) == MINUS_EXPR
4029: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4030: && ! TREE_UNSIGNED (type))
4031: {
4032: c2 = fold (build1 (NEGATE_EXPR, type, TREE_OPERAND (xarg0, 1)));
4033: xarg0 = TREE_OPERAND (xarg0, 0);
4034: }
4035:
4036: STRIP_NOPS (xarg0);
4037:
4038: if (TREE_CODE (xarg0) == MULT_EXPR
4039: && TREE_CODE (TREE_OPERAND (xarg0, 1)) == INTEGER_CST
4040: && integer_zerop (const_binop (TRUNC_MOD_EXPR,
4041: TREE_OPERAND (xarg0, 1),
4042: arg1, 1))
4043: && tree_int_cst_lt (integer_zero_node, c2))
4044: /* The result is (C2%C3). */
4045: return omit_one_operand (type, const_binop (code, c2, arg1, 1),
4046: TREE_OPERAND (xarg0, 0));
4047: }
4048:
4049: goto binary;
4050:
4051: case LSHIFT_EXPR:
4052: case RSHIFT_EXPR:
4053: case LROTATE_EXPR:
4054: case RROTATE_EXPR:
4055: if (integer_zerop (arg1))
4056: return non_lvalue (convert (type, arg0));
4057: /* Since negative shift count is not well-defined,
4058: don't try to compute it in the compiler. */
4059: if (tree_int_cst_lt (arg1, integer_zero_node))
4060: return t;
4061: goto binary;
4062:
4063: case MIN_EXPR:
4064: if (operand_equal_p (arg0, arg1, 0))
4065: return arg0;
4066: if (INTEGRAL_TYPE_P (type)
4067: && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
4068: return omit_one_operand (type, arg1, arg0);
4069: goto associate;
4070:
4071: case MAX_EXPR:
4072: if (operand_equal_p (arg0, arg1, 0))
4073: return arg0;
4074: if (INTEGRAL_TYPE_P (type)
4075: && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
4076: return omit_one_operand (type, arg1, arg0);
4077: goto associate;
4078:
4079: case TRUTH_NOT_EXPR:
4080: /* Note that the operand of this must be an int
4081: and its values must be 0 or 1.
4082: ("true" is a fixed value perhaps depending on the language,
4083: but we don't handle values other than 1 correctly yet.) */
4084: return invert_truthvalue (arg0);
4085:
4086: case TRUTH_ANDIF_EXPR:
4087: /* Note that the operands of this must be ints
4088: and their values must be 0 or 1.
4089: ("true" is a fixed value perhaps depending on the language.) */
4090: /* If first arg is constant zero, return it. */
4091: if (integer_zerop (arg0))
4092: return arg0;
4093: case TRUTH_AND_EXPR:
4094: /* If either arg is constant true, drop it. */
4095: if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
4096: return non_lvalue (arg1);
4097: if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
4098: return non_lvalue (arg0);
4099: /* If second arg is constant zero, result is zero, but first arg
4100: must be evaluated. */
4101: if (integer_zerop (arg1))
4102: return omit_one_operand (type, arg1, arg0);
4103:
4104: truth_andor:
4105: /* Check for the possibility of merging component references. If our
4106: lhs is another similar operation, try to merge its rhs with our
4107: rhs. Then try to merge our lhs and rhs. */
4108: if (optimize)
4109: {
4110: if (TREE_CODE (arg0) == code)
4111: {
4112: tem = fold_truthop (code, type,
4113: TREE_OPERAND (arg0, 1), arg1);
4114: if (tem)
4115: return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
4116: }
4117:
4118: tem = fold_truthop (code, type, arg0, arg1);
4119: if (tem)
4120: return tem;
4121: }
4122: return t;
4123:
4124: case TRUTH_ORIF_EXPR:
4125: /* Note that the operands of this must be ints
4126: and their values must be 0 or true.
4127: ("true" is a fixed value perhaps depending on the language.) */
4128: /* If first arg is constant true, return it. */
4129: if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
4130: return arg0;
4131: case TRUTH_OR_EXPR:
4132: /* If either arg is constant zero, drop it. */
4133: if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
4134: return non_lvalue (arg1);
4135: if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
4136: return non_lvalue (arg0);
4137: /* If second arg is constant true, result is true, but we must
4138: evaluate first arg. */
4139: if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
4140: return omit_one_operand (type, arg1, arg0);
4141: goto truth_andor;
4142:
4143: case TRUTH_XOR_EXPR:
4144: /* If either arg is constant zero, drop it. */
4145: if (integer_zerop (arg0))
4146: return non_lvalue (arg1);
4147: if (integer_zerop (arg1))
4148: return non_lvalue (arg0);
4149: /* If either arg is constant true, this is a logical inversion. */
4150: if (integer_onep (arg0))
4151: return non_lvalue (invert_truthvalue (arg1));
4152: if (integer_onep (arg1))
4153: return non_lvalue (invert_truthvalue (arg0));
4154: return t;
4155:
4156: case EQ_EXPR:
4157: case NE_EXPR:
4158: case LT_EXPR:
4159: case GT_EXPR:
4160: case LE_EXPR:
4161: case GE_EXPR:
4162: /* If one arg is a constant integer, put it last. */
4163: if (TREE_CODE (arg0) == INTEGER_CST
4164: && TREE_CODE (arg1) != INTEGER_CST)
4165: {
4166: TREE_OPERAND (t, 0) = arg1;
4167: TREE_OPERAND (t, 1) = arg0;
4168: arg0 = TREE_OPERAND (t, 0);
4169: arg1 = TREE_OPERAND (t, 1);
4170: code = swap_tree_comparison (code);
4171: TREE_SET_CODE (t, code);
4172: }
4173:
4174: /* Convert foo++ == CONST into ++foo == CONST + INCR.
4175: First, see if one arg is constant; find the constant arg
4176: and the other one. */
4177: {
4178: tree constop = 0, varop;
4179: tree *constoploc;
4180:
4181: if (TREE_CONSTANT (arg1))
4182: constoploc = &TREE_OPERAND (t, 1), constop = arg1, varop = arg0;
4183: if (TREE_CONSTANT (arg0))
4184: constoploc = &TREE_OPERAND (t, 0), constop = arg0, varop = arg1;
4185:
4186: if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
4187: {
4188: /* This optimization is invalid for ordered comparisons
4189: if CONST+INCR overflows or if foo+incr might overflow.
4190: This optimization is invalid for floating point due to rounding.
4191: For pointer types we assume overflow doesn't happen. */
4192: if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
4193: || (! FLOAT_TYPE_P (TREE_TYPE (varop))
4194: && (code == EQ_EXPR || code == NE_EXPR)))
4195: {
4196: tree newconst
4197: = fold (build (PLUS_EXPR, TREE_TYPE (varop),
4198: constop, TREE_OPERAND (varop, 1)));
4199: TREE_SET_CODE (varop, PREINCREMENT_EXPR);
4200: *constoploc = newconst;
4201: return t;
4202: }
4203: }
4204: else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
4205: {
4206: if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
4207: || (! FLOAT_TYPE_P (TREE_TYPE (varop))
4208: && (code == EQ_EXPR || code == NE_EXPR)))
4209: {
4210: tree newconst
4211: = fold (build (MINUS_EXPR, TREE_TYPE (varop),
4212: constop, TREE_OPERAND (varop, 1)));
4213: TREE_SET_CODE (varop, PREDECREMENT_EXPR);
4214: *constoploc = newconst;
4215: return t;
4216: }
4217: }
4218: }
4219:
4220: /* Change X >= CST to X > (CST - 1) if CST is positive. */
4221: if (TREE_CODE (arg1) == INTEGER_CST
4222: && TREE_CODE (arg0) != INTEGER_CST
4223: && ! tree_int_cst_lt (arg1, integer_one_node))
4224: {
4225: switch (TREE_CODE (t))
4226: {
4227: case GE_EXPR:
4228: code = GT_EXPR;
4229: TREE_SET_CODE (t, code);
4230: arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
4231: TREE_OPERAND (t, 1) = arg1;
4232: break;
4233:
4234: case LT_EXPR:
4235: code = LE_EXPR;
4236: TREE_SET_CODE (t, code);
4237: arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
4238: TREE_OPERAND (t, 1) = arg1;
4239: }
4240: }
4241:
4242: /* If this is an EQ or NE comparison with zero and ARG0 is
4243: (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
4244: two operations, but the latter can be done in one less insn
4245: one machine that have only two-operand insns or on which a
4246: constant cannot be the first operand. */
4247: if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
4248: && TREE_CODE (arg0) == BIT_AND_EXPR)
4249: {
4250: if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
4251: && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
4252: return
4253: fold (build (code, type,
4254: build (BIT_AND_EXPR, TREE_TYPE (arg0),
4255: build (RSHIFT_EXPR,
4256: TREE_TYPE (TREE_OPERAND (arg0, 0)),
4257: TREE_OPERAND (arg0, 1),
4258: TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
4259: convert (TREE_TYPE (arg0),
4260: integer_one_node)),
4261: arg1));
4262: else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
4263: && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
4264: return
4265: fold (build (code, type,
4266: build (BIT_AND_EXPR, TREE_TYPE (arg0),
4267: build (RSHIFT_EXPR,
4268: TREE_TYPE (TREE_OPERAND (arg0, 1)),
4269: TREE_OPERAND (arg0, 0),
4270: TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
4271: convert (TREE_TYPE (arg0),
4272: integer_one_node)),
4273: arg1));
4274: }
4275:
4276: /* If this is an NE or EQ comparison of zero against the result of a
4277: signed MOD operation whose second operand is a power of 2, make
4278: the MOD operation unsigned since it is simpler and equivalent. */
4279: if ((code == NE_EXPR || code == EQ_EXPR)
4280: && integer_zerop (arg1)
4281: && ! TREE_UNSIGNED (TREE_TYPE (arg0))
4282: && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
4283: || TREE_CODE (arg0) == CEIL_MOD_EXPR
4284: || TREE_CODE (arg0) == FLOOR_MOD_EXPR
4285: || TREE_CODE (arg0) == ROUND_MOD_EXPR)
4286: && integer_pow2p (TREE_OPERAND (arg0, 1)))
4287: {
4288: tree newtype = unsigned_type (TREE_TYPE (arg0));
4289: tree newmod = build (TREE_CODE (arg0), newtype,
4290: convert (newtype, TREE_OPERAND (arg0, 0)),
4291: convert (newtype, TREE_OPERAND (arg0, 1)));
4292:
4293: return build (code, type, newmod, convert (newtype, arg1));
4294: }
4295:
4296: /* If this is an NE comparison of zero with an AND of one, remove the
4297: comparison since the AND will give the correct value. */
4298: if (code == NE_EXPR && integer_zerop (arg1)
4299: && TREE_CODE (arg0) == BIT_AND_EXPR
4300: && integer_onep (TREE_OPERAND (arg0, 1)))
4301: return convert (type, arg0);
4302:
4303: /* If we have (A & C) == C where C is a power of 2, convert this into
4304: (A & C) != 0. Similarly for NE_EXPR. */
4305: if ((code == EQ_EXPR || code == NE_EXPR)
4306: && TREE_CODE (arg0) == BIT_AND_EXPR
4307: && integer_pow2p (TREE_OPERAND (arg0, 1))
4308: && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
4309: return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
4310: arg0, integer_zero_node);
4311:
4312: /* Simplify comparison of something with itself. (For IEEE
4313: floating-point, we can only do some of these simplifications.) */
4314: if (operand_equal_p (arg0, arg1, 0))
4315: {
4316: switch (code)
4317: {
4318: case EQ_EXPR:
4319: case GE_EXPR:
4320: case LE_EXPR:
4321: if (INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
4322: {
4323: t = build_int_2 (1, 0);
4324: TREE_TYPE (t) = type;
4325: return t;
4326: }
4327: code = EQ_EXPR;
4328: TREE_SET_CODE (t, code);
4329: break;
4330:
4331: case NE_EXPR:
4332: /* For NE, we can only do this simplification if integer. */
4333: if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
4334: break;
4335: /* ... fall through ... */
4336: case GT_EXPR:
4337: case LT_EXPR:
4338: t = build_int_2 (0, 0);
4339: TREE_TYPE (t) = type;
4340: return t;
4341: }
4342: }
4343:
4344: /* An unsigned comparison against 0 can be simplified. */
4345: if (integer_zerop (arg1)
4346: && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
4347: || TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE)
4348: && TREE_UNSIGNED (TREE_TYPE (arg1)))
4349: {
4350: switch (TREE_CODE (t))
4351: {
4352: case GT_EXPR:
4353: code = NE_EXPR;
4354: TREE_SET_CODE (t, NE_EXPR);
4355: break;
4356: case LE_EXPR:
4357: code = EQ_EXPR;
4358: TREE_SET_CODE (t, EQ_EXPR);
4359: break;
4360: case GE_EXPR:
4361: return omit_one_operand (type,
4362: convert (type, integer_one_node),
4363: arg0);
4364: case LT_EXPR:
4365: return omit_one_operand (type,
4366: convert (type, integer_zero_node),
4367: arg0);
4368: }
4369: }
4370:
4371: /* If we are comparing an expression that just has comparisons
4372: of two integer values, arithmetic expressions of those comparisons,
4373: and constants, we can simplify it. There are only three cases
4374: to check: the two values can either be equal, the first can be
4375: greater, or the second can be greater. Fold the expression for
4376: those three values. Since each value must be 0 or 1, we have
4377: eight possibilities, each of which corresponds to the constant 0
4378: or 1 or one of the six possible comparisons.
4379:
4380: This handles common cases like (a > b) == 0 but also handles
4381: expressions like ((x > y) - (y > x)) > 0, which supposedly
4382: occur in macroized code. */
4383:
4384: if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
4385: {
4386: tree cval1 = 0, cval2 = 0;
4387: int save_p = 0;
4388:
4389: if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
4390: /* Don't handle degenerate cases here; they should already
4391: have been handled anyway. */
4392: && cval1 != 0 && cval2 != 0
4393: && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
4394: && TREE_TYPE (cval1) == TREE_TYPE (cval2)
4395: && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
4396: && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
4397: TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
4398: {
4399: tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
4400: tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
4401:
4402: /* We can't just pass T to eval_subst in case cval1 or cval2
4403: was the same as ARG1. */
4404:
4405: tree high_result
4406: = fold (build (code, type,
4407: eval_subst (arg0, cval1, maxval, cval2, minval),
4408: arg1));
4409: tree equal_result
4410: = fold (build (code, type,
4411: eval_subst (arg0, cval1, maxval, cval2, maxval),
4412: arg1));
4413: tree low_result
4414: = fold (build (code, type,
4415: eval_subst (arg0, cval1, minval, cval2, maxval),
4416: arg1));
4417:
4418: /* All three of these results should be 0 or 1. Confirm they
4419: are. Then use those values to select the proper code
4420: to use. */
4421:
4422: if ((integer_zerop (high_result)
4423: || integer_onep (high_result))
4424: && (integer_zerop (equal_result)
4425: || integer_onep (equal_result))
4426: && (integer_zerop (low_result)
4427: || integer_onep (low_result)))
4428: {
4429: /* Make a 3-bit mask with the high-order bit being the
4430: value for `>', the next for '=', and the low for '<'. */
4431: switch ((integer_onep (high_result) * 4)
4432: + (integer_onep (equal_result) * 2)
4433: + integer_onep (low_result))
4434: {
4435: case 0:
4436: /* Always false. */
4437: return omit_one_operand (type, integer_zero_node, arg0);
4438: case 1:
4439: code = LT_EXPR;
4440: break;
4441: case 2:
4442: code = EQ_EXPR;
4443: break;
4444: case 3:
4445: code = LE_EXPR;
4446: break;
4447: case 4:
4448: code = GT_EXPR;
4449: break;
4450: case 5:
4451: code = NE_EXPR;
4452: break;
4453: case 6:
4454: code = GE_EXPR;
4455: break;
4456: case 7:
4457: /* Always true. */
4458: return omit_one_operand (type, integer_one_node, arg0);
4459: }
4460:
4461: t = build (code, type, cval1, cval2);
4462: if (save_p)
4463: return save_expr (t);
4464: else
4465: return fold (t);
4466: }
4467: }
4468: }
4469:
4470: /* If this is a comparison of a field, we may be able to simplify it. */
4471: if ((TREE_CODE (arg0) == COMPONENT_REF
4472: || TREE_CODE (arg0) == BIT_FIELD_REF)
4473: && (code == EQ_EXPR || code == NE_EXPR)
4474: /* Handle the constant case even without -O
4475: to make sure the warnings are given. */
4476: && (optimize || TREE_CODE (arg1) == INTEGER_CST))
4477: {
4478: t1 = optimize_bit_field_compare (code, type, arg0, arg1);
4479: return t1 ? t1 : t;
4480: }
4481:
4482: /* From here on, the only cases we handle are when the result is
4483: known to be a constant.
4484:
4485: To compute GT, swap the arguments and do LT.
4486: To compute GE, do LT and invert the result.
4487: To compute LE, swap the arguments, do LT and invert the result.
4488: To compute NE, do EQ and invert the result.
4489:
4490: Therefore, the code below must handle only EQ and LT. */
4491:
4492: if (code == LE_EXPR || code == GT_EXPR)
4493: {
4494: tem = arg0, arg0 = arg1, arg1 = tem;
4495: code = swap_tree_comparison (code);
4496: }
4497:
4498: /* Note that it is safe to invert for real values here because we
4499: will check below in the one case that it matters. */
4500:
4501: invert = 0;
4502: if (code == NE_EXPR || code == GE_EXPR)
4503: {
4504: invert = 1;
4505: code = invert_tree_comparison (code);
4506: }
4507:
4508: /* Compute a result for LT or EQ if args permit;
4509: otherwise return T. */
4510: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
4511: {
4512: if (code == EQ_EXPR)
4513: t1 = build_int_2 ((TREE_INT_CST_LOW (arg0)
4514: == TREE_INT_CST_LOW (arg1))
4515: && (TREE_INT_CST_HIGH (arg0)
4516: == TREE_INT_CST_HIGH (arg1)),
4517: 0);
4518: else
4519: t1 = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
4520: ? INT_CST_LT_UNSIGNED (arg0, arg1)
4521: : INT_CST_LT (arg0, arg1)),
4522: 0);
4523: }
4524:
4525: /* Assume a nonexplicit constant cannot equal an explicit one,
4526: since such code would be undefined anyway.
4527: Exception: on sysvr4, using #pragma weak,
4528: a label can come out as 0. */
4529: else if (TREE_CODE (arg1) == INTEGER_CST
4530: && !integer_zerop (arg1)
4531: && TREE_CONSTANT (arg0)
4532: && TREE_CODE (arg0) == ADDR_EXPR
4533: && code == EQ_EXPR)
4534: t1 = build_int_2 (0, 0);
4535:
4536: /* Two real constants can be compared explicitly. */
4537: else if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
4538: {
4539: /* If either operand is a NaN, the result is false with two
4540: exceptions: First, an NE_EXPR is true on NaNs, but that case
4541: is already handled correctly since we will be inverting the
4542: result for NE_EXPR. Second, if we had inverted a LE_EXPR
4543: or a GE_EXPR into a LT_EXPR, we must return true so that it
4544: will be inverted into false. */
4545:
4546: if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
4547: || REAL_VALUE_ISNAN (TREE_REAL_CST (arg1)))
4548: t1 = build_int_2 (invert && code == LT_EXPR, 0);
4549:
4550: else if (code == EQ_EXPR)
4551: t1 = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
4552: TREE_REAL_CST (arg1)),
4553: 0);
4554: else
4555: t1 = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
4556: TREE_REAL_CST (arg1)),
4557: 0);
4558: }
4559:
4560: if (t1 == NULL_TREE)
4561: return t;
4562:
4563: if (invert)
4564: TREE_INT_CST_LOW (t1) ^= 1;
4565:
4566: TREE_TYPE (t1) = type;
4567: return t1;
4568:
4569: case COND_EXPR:
4570: /* Pedantic ANSI C says that a conditional expression is never an lvalue,
4571: so all simple results must be passed through pedantic_non_lvalue. */
4572: if (TREE_CODE (arg0) == INTEGER_CST)
4573: return pedantic_non_lvalue
4574: (TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1)));
4575: else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
4576: return pedantic_non_lvalue (omit_one_operand (type, arg1, arg0));
4577:
4578: /* If the second operand is zero, invert the comparison and swap
4579: the second and third operands. Likewise if the second operand
4580: is constant and the third is not or if the third operand is
4581: equivalent to the first operand of the comparison. */
4582:
4583: if (integer_zerop (arg1)
4584: || (TREE_CONSTANT (arg1) && ! TREE_CONSTANT (TREE_OPERAND (t, 2)))
4585: || (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4586: && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
4587: TREE_OPERAND (t, 2),
4588: TREE_OPERAND (arg0, 1))))
4589: {
4590: /* See if this can be inverted. If it can't, possibly because
4591: it was a floating-point inequality comparison, don't do
4592: anything. */
4593: tem = invert_truthvalue (arg0);
4594:
4595: if (TREE_CODE (tem) != TRUTH_NOT_EXPR)
4596: {
4597: arg0 = TREE_OPERAND (t, 0) = tem;
4598: TREE_OPERAND (t, 1) = TREE_OPERAND (t, 2);
4599: TREE_OPERAND (t, 2) = arg1;
4600: arg1 = TREE_OPERAND (t, 1);
4601: }
4602: }
4603:
4604: /* If we have A op B ? A : C, we may be able to convert this to a
4605: simpler expression, depending on the operation and the values
4606: of B and C. IEEE floating point prevents this though,
4607: because A or B might be -0.0 or a NaN. */
4608:
4609: if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<'
4610: && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
4611: || ! FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
4612: && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
4613: arg1, TREE_OPERAND (arg0, 1)))
4614: {
4615: tree arg2 = TREE_OPERAND (t, 2);
4616: enum tree_code comp_code = TREE_CODE (arg0);
4617:
4618: /* If we have A op 0 ? A : -A, this is A, -A, abs (A), or abs (-A),
4619: depending on the comparison operation. */
4620: if (integer_zerop (TREE_OPERAND (arg0, 1))
4621: && TREE_CODE (arg2) == NEGATE_EXPR
4622: && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4623: switch (comp_code)
4624: {
4625: case EQ_EXPR:
4626: return pedantic_non_lvalue
4627: (fold (build1 (NEGATE_EXPR, type, arg1)));
4628: case NE_EXPR:
4629: return pedantic_non_lvalue (convert (type, arg1));
4630: case GE_EXPR:
4631: case GT_EXPR:
4632: return pedantic_non_lvalue
4633: (fold (build1 (ABS_EXPR, type, arg1)));
4634: case LE_EXPR:
4635: case LT_EXPR:
4636: return pedantic_non_lvalue
4637: (fold (build1 (NEGATE_EXPR, type,
4638: fold (build1 (ABS_EXPR, type, arg1)))));
4639: }
4640:
4641: /* If this is A != 0 ? A : 0, this is simply A. For ==, it is
4642: always zero. */
4643:
4644: if (integer_zerop (TREE_OPERAND (arg0, 1)) && integer_zerop (arg2))
4645: {
4646: if (comp_code == NE_EXPR)
4647: return pedantic_non_lvalue (convert (type, arg1));
4648: else if (comp_code == EQ_EXPR)
4649: return pedantic_non_lvalue (convert (type, integer_zero_node));
4650: }
4651:
4652: /* If this is A op B ? A : B, this is either A, B, min (A, B),
4653: or max (A, B), depending on the operation. */
4654:
4655: if (operand_equal_for_comparison_p (TREE_OPERAND (arg0, 1),
4656: arg2, TREE_OPERAND (arg0, 0)))
4657: switch (comp_code)
4658: {
4659: case EQ_EXPR:
4660: return pedantic_non_lvalue (convert (type, arg2));
4661: case NE_EXPR:
4662: return pedantic_non_lvalue (convert (type, arg1));
4663: case LE_EXPR:
4664: case LT_EXPR:
4665: return pedantic_non_lvalue
4666: (fold (build (MIN_EXPR, type, arg1, arg2)));
4667: case GE_EXPR:
4668: case GT_EXPR:
4669: return pedantic_non_lvalue
4670: (fold (build (MAX_EXPR, type, arg1, arg2)));
4671: }
4672:
4673: /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4674: we might still be able to simplify this. For example,
4675: if C1 is one less or one more than C2, this might have started
4676: out as a MIN or MAX and been transformed by this function.
4677: Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
4678:
4679: if (INTEGRAL_TYPE_P (type)
4680: && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
4681: && TREE_CODE (arg2) == INTEGER_CST)
4682: switch (comp_code)
4683: {
4684: case EQ_EXPR:
4685: /* We can replace A with C1 in this case. */
4686: arg1 = TREE_OPERAND (t, 1)
4687: = convert (type, TREE_OPERAND (arg0, 1));
4688: break;
4689:
4690: case LT_EXPR:
4691: /* If C1 is C2 + 1, this is min(A, C2). */
4692: if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
4693: && operand_equal_p (TREE_OPERAND (arg0, 1),
4694: const_binop (PLUS_EXPR, arg2,
4695: integer_one_node, 0), 1))
4696: return pedantic_non_lvalue
4697: (fold (build (MIN_EXPR, type, arg1, arg2)));
4698: break;
4699:
4700: case LE_EXPR:
4701: /* If C1 is C2 - 1, this is min(A, C2). */
4702: if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
4703: && operand_equal_p (TREE_OPERAND (arg0, 1),
4704: const_binop (MINUS_EXPR, arg2,
4705: integer_one_node, 0), 1))
4706: return pedantic_non_lvalue
4707: (fold (build (MIN_EXPR, type, arg1, arg2)));
4708: break;
4709:
4710: case GT_EXPR:
4711: /* If C1 is C2 - 1, this is max(A, C2). */
4712: if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type), 1)
4713: && operand_equal_p (TREE_OPERAND (arg0, 1),
4714: const_binop (MINUS_EXPR, arg2,
4715: integer_one_node, 0), 1))
4716: return pedantic_non_lvalue
4717: (fold (build (MAX_EXPR, type, arg1, arg2)));
4718: break;
4719:
4720: case GE_EXPR:
4721: /* If C1 is C2 + 1, this is max(A, C2). */
4722: if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type), 1)
4723: && operand_equal_p (TREE_OPERAND (arg0, 1),
4724: const_binop (PLUS_EXPR, arg2,
4725: integer_one_node, 0), 1))
4726: return pedantic_non_lvalue
4727: (fold (build (MAX_EXPR, type, arg1, arg2)));
4728: break;
4729: }
4730: }
4731:
4732: /* Convert A ? 1 : 0 to simply A. */
4733: if (integer_onep (TREE_OPERAND (t, 1))
4734: && integer_zerop (TREE_OPERAND (t, 2))
4735: /* If we try to convert TREE_OPERAND (t, 0) to our type, the
4736: call to fold will try to move the conversion inside
4737: a COND, which will recurse. In that case, the COND_EXPR
4738: is probably the best choice, so leave it alone. */
4739: && type == TREE_TYPE (arg0))
4740: return pedantic_non_lvalue (arg0);
4741:
4742:
4743: /* Look for expressions of the form A & 2 ? 2 : 0. The result of this
4744: operation is simply A & 2. */
4745:
4746: if (integer_zerop (TREE_OPERAND (t, 2))
4747: && TREE_CODE (arg0) == NE_EXPR
4748: && integer_zerop (TREE_OPERAND (arg0, 1))
4749: && integer_pow2p (arg1)
4750: && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
4751: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
4752: arg1, 1))
4753: return pedantic_non_lvalue (convert (type, TREE_OPERAND (arg0, 0)));
4754:
4755: return t;
4756:
4757: case COMPOUND_EXPR:
4758: /* When pedantic, a compound expression can be neither an lvalue
4759: nor an integer constant expression. */
4760: if (TREE_SIDE_EFFECTS (arg0) || pedantic)
4761: return t;
4762: /* Don't let (0, 0) be null pointer constant. */
4763: if (integer_zerop (arg1))
4764: return non_lvalue (arg1);
4765: return arg1;
4766:
4767: case COMPLEX_EXPR:
4768: if (wins)
4769: return build_complex (arg0, arg1);
4770: return t;
4771:
4772: case REALPART_EXPR:
4773: if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
4774: return t;
4775: else if (TREE_CODE (arg0) == COMPLEX_EXPR)
4776: return omit_one_operand (type, TREE_OPERAND (arg0, 0),
4777: TREE_OPERAND (arg0, 1));
4778: else if (TREE_CODE (arg0) == COMPLEX_CST)
4779: return TREE_REALPART (arg0);
4780: else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
4781: return fold (build (TREE_CODE (arg0), type,
4782: fold (build1 (REALPART_EXPR, type,
4783: TREE_OPERAND (arg0, 0))),
4784: fold (build1 (REALPART_EXPR,
4785: type, TREE_OPERAND (arg0, 1)))));
4786: return t;
4787:
4788: case IMAGPART_EXPR:
4789: if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
4790: return convert (type, integer_zero_node);
4791: else if (TREE_CODE (arg0) == COMPLEX_EXPR)
4792: return omit_one_operand (type, TREE_OPERAND (arg0, 1),
4793: TREE_OPERAND (arg0, 0));
4794: else if (TREE_CODE (arg0) == COMPLEX_CST)
4795: return TREE_IMAGPART (arg0);
4796: else if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
4797: return fold (build (TREE_CODE (arg0), type,
4798: fold (build1 (IMAGPART_EXPR, type,
4799: TREE_OPERAND (arg0, 0))),
4800: fold (build1 (IMAGPART_EXPR, type,
4801: TREE_OPERAND (arg0, 1)))));
4802: return t;
4803:
4804: default:
4805: return t;
4806: } /* switch (code) */
4807: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.