![[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 [GCC 2.x] / gcc|
Return to fold-const.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Fold a constant sub-tree into a single node for C-compiler
2: Copyright (C) 1987, 1988, 1992 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 arbitary 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: void lshift_double ();
49: void rshift_double ();
50: void lrotate_double ();
51: void rrotate_double ();
52: static tree const_binop ();
53:
54: /* To do constant folding on INTEGER_CST nodes requires 64-bit arithmetic.
55: We do that by representing the 64-bit integer as 8 shorts,
56: with only 8 bits stored in each short, as a positive number. */
57:
58: /* Unpack a 64-bit integer into 8 shorts.
59: LOW and HI are the integer, as two `int' pieces.
60: SHORTS points to the array of shorts. */
61:
62: static void
63: encode (shorts, low, hi)
64: short *shorts;
65: int low, hi;
66: {
67: shorts[0] = low & 0xff;
68: shorts[1] = (low >> 8) & 0xff;
69: shorts[2] = (low >> 16) & 0xff;
70: shorts[3] = (low >> 24) & 0xff;
71: shorts[4] = hi & 0xff;
72: shorts[5] = (hi >> 8) & 0xff;
73: shorts[6] = (hi >> 16) & 0xff;
74: shorts[7] = (hi >> 24) & 0xff;
75: }
76:
77: /* Pack an array of 8 shorts into a 64-bit integer.
78: SHORTS points to the array of shorts.
79: The integer is stored into *LOW and *HI as two `int' pieces. */
80:
81: static void
82: decode (shorts, low, hi)
83: short *shorts;
84: int *low, *hi;
85: {
86: /* The casts in the following statement should not be
87: needed, but they get around bugs in some C compilers. */
88: *low = (((long)shorts[3] << 24) | ((long)shorts[2] << 16)
89: | ((long)shorts[1] << 8) | (long)shorts[0]);
90: *hi = (((long)shorts[7] << 24) | ((long)shorts[6] << 16)
91: | ((long)shorts[5] << 8) | (long)shorts[4]);
92: }
93:
94: /* Make the integer constant T valid for its type
95: by setting to 0 or 1 all the bits in the constant
96: that don't belong in the type. */
97:
98: static void
99: force_fit_type (t)
100: tree t;
101: {
102: register int prec = TYPE_PRECISION (TREE_TYPE (t));
103:
104: if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
105: prec = POINTER_SIZE;
106:
107: /* First clear all bits that are beyond the type's precision. */
108:
109: if (prec == 2 * HOST_BITS_PER_INT)
110: ;
111: else if (prec > HOST_BITS_PER_INT)
112: {
113: TREE_INT_CST_HIGH (t)
114: &= ~((-1) << (prec - HOST_BITS_PER_INT));
115: }
116: else
117: {
118: TREE_INT_CST_HIGH (t) = 0;
119: if (prec < HOST_BITS_PER_INT)
120: TREE_INT_CST_LOW (t)
121: &= ~((-1) << prec);
122: }
123:
124: /* If it's a signed type and value's sign bit is set, extend the sign. */
125:
126: if (! TREE_UNSIGNED (TREE_TYPE (t))
127: && prec != 2 * HOST_BITS_PER_INT
128: && (prec > HOST_BITS_PER_INT
129: ? TREE_INT_CST_HIGH (t) & (1 << (prec - HOST_BITS_PER_INT - 1))
130: : TREE_INT_CST_LOW (t) & (1 << (prec - 1))))
131: {
132: /* Value is negative:
133: set to 1 all the bits that are outside this type's precision. */
134: if (prec > HOST_BITS_PER_INT)
135: {
136: TREE_INT_CST_HIGH (t)
137: |= ((-1) << (prec - HOST_BITS_PER_INT));
138: }
139: else
140: {
141: TREE_INT_CST_HIGH (t) = -1;
142: if (prec < HOST_BITS_PER_INT)
143: TREE_INT_CST_LOW (t)
144: |= ((-1) << prec);
145: }
146: }
147: }
148:
149: /* Add two 64-bit integers with 64-bit result.
150: Each argument is given as two `int' pieces.
151: One argument is L1 and H1; the other, L2 and H2.
152: The value is stored as two `int' pieces in *LV and *HV.
153: We use the 8-shorts representation internally. */
154:
155: void
156: add_double (l1, h1, l2, h2, lv, hv)
157: int l1, h1, l2, h2;
158: int *lv, *hv;
159: {
160: short arg1[8];
161: short arg2[8];
162: register int carry = 0;
163: register int i;
164:
165: encode (arg1, l1, h1);
166: encode (arg2, l2, h2);
167:
168: for (i = 0; i < 8; i++)
169: {
170: carry += arg1[i] + arg2[i];
171: arg1[i] = carry & 0xff;
172: carry >>= 8;
173: }
174:
175: decode (arg1, lv, hv);
176: }
177:
178: /* Negate a 64-bit integers with 64-bit result.
179: The argument is given as two `int' pieces in L1 and H1.
180: The value is stored as two `int' pieces in *LV and *HV.
181: We use the 8-shorts representation internally. */
182:
183: void
184: neg_double (l1, h1, lv, hv)
185: int l1, h1;
186: int *lv, *hv;
187: {
188: if (l1 == 0)
189: {
190: *lv = 0;
191: *hv = - h1;
192: }
193: else
194: {
195: *lv = - l1;
196: *hv = ~ h1;
197: }
198: }
199:
200: /* Multiply two 64-bit integers with 64-bit result.
201: Each argument is given as two `int' pieces.
202: One argument is L1 and H1; the other, L2 and H2.
203: The value is stored as two `int' pieces in *LV and *HV.
204: We use the 8-shorts representation internally. */
205:
206: void
207: mul_double (l1, h1, l2, h2, lv, hv)
208: int l1, h1, l2, h2;
209: int *lv, *hv;
210: {
211: short arg1[8];
212: short arg2[8];
213: short prod[16];
214: register int carry = 0;
215: register int i, j, k;
216:
217: /* These two cases are used extensively, arising from pointer
218: combinations. */
219: if (h2 == 0)
220: {
221: if (l2 == 2)
222: {
223: unsigned temp = l1 + l1;
224: *hv = h1 * 2 + (temp < l1);
225: *lv = temp;
226: return;
227: }
228: if (l2 == 4)
229: {
230: unsigned temp = l1 + l1;
231: h1 = h1 * 4 + ((temp < l1) << 1);
232: l1 = temp;
233: temp += temp;
234: h1 += (temp < l1);
235: *lv = temp;
236: *hv = h1;
237: return;
238: }
239: if (l2 == 8)
240: {
241: unsigned temp = l1 + l1;
242: h1 = h1 * 8 + ((temp < l1) << 2);
243: l1 = temp;
244: temp += temp;
245: h1 += (temp < l1) << 1;
246: l1 = temp;
247: temp += temp;
248: h1 += (temp < l1);
249: *lv = temp;
250: *hv = h1;
251: return;
252: }
253: }
254:
255: encode (arg1, l1, h1);
256: encode (arg2, l2, h2);
257:
258: bzero (prod, sizeof prod);
259:
260: for (i = 0; i < 8; i++)
261: for (j = 0; j < 8; j++)
262: {
263: k = i + j;
264: carry = arg1[i] * arg2[j];
265: while (carry)
266: {
267: carry += prod[k];
268: prod[k] = carry & 0xff;
269: carry >>= 8;
270: k++;
271: }
272: }
273:
274: decode (prod, lv, hv); /* @@decode ignores prod[8] -> prod[15] */
275: }
276:
277: /* Shift the 64-bit integer in L1, H1 left by COUNT places
278: keeping only PREC bits of result.
279: Shift right if COUNT is negative.
280: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
281: Store the value as two `int' pieces in *LV and *HV. */
282:
283: void
284: lshift_double (l1, h1, count, prec, lv, hv, arith)
285: int l1, h1, count, prec;
286: int *lv, *hv;
287: int arith;
288: {
289: short arg1[8];
290: register int i;
291: register int carry;
292:
293: if (count < 0)
294: {
295: rshift_double (l1, h1, - count, prec, lv, hv, arith);
296: return;
297: }
298:
299: encode (arg1, l1, h1);
300:
301: if (count > prec)
302: count = prec;
303:
304: while (count > 0)
305: {
306: carry = 0;
307: for (i = 0; i < 8; i++)
308: {
309: carry += arg1[i] << 1;
310: arg1[i] = carry & 0xff;
311: carry >>= 8;
312: }
313: count--;
314: }
315:
316: decode (arg1, lv, hv);
317: }
318:
319: /* Shift the 64-bit integer in L1, H1 right by COUNT places
320: keeping only PREC bits of result. COUNT must be positive.
321: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
322: Store the value as two `int' pieces in *LV and *HV. */
323:
324: void
325: rshift_double (l1, h1, count, prec, lv, hv, arith)
326: int l1, h1, count, prec;
327: int *lv, *hv;
328: int arith;
329: {
330: short arg1[8];
331: register int i;
332: register int carry;
333:
334: encode (arg1, l1, h1);
335:
336: if (count > prec)
337: count = prec;
338:
339: while (count > 0)
340: {
341: carry = arith && arg1[7] >> 7;
342: for (i = 7; i >= 0; i--)
343: {
344: carry <<= 8;
345: carry += arg1[i];
346: arg1[i] = (carry >> 1) & 0xff;
347: }
348: count--;
349: }
350:
351: decode (arg1, lv, hv);
352: }
353:
354: /* Rotate the 64-bit integer in L1, H1 left by COUNT places
355: keeping only PREC bits of result.
356: Rotate right if COUNT is negative.
357: Store the value as two `int' pieces in *LV and *HV. */
358:
359: void
360: lrotate_double (l1, h1, count, prec, lv, hv)
361: int l1, h1, count, prec;
362: int *lv, *hv;
363: {
364: short arg1[8];
365: register int i;
366: register int carry;
367:
368: if (count < 0)
369: {
370: rrotate_double (l1, h1, - count, prec, lv, hv);
371: return;
372: }
373:
374: encode (arg1, l1, h1);
375:
376: if (count > prec)
377: count = prec;
378:
379: carry = arg1[7] >> 7;
380: while (count > 0)
381: {
382: for (i = 0; i < 8; i++)
383: {
384: carry += arg1[i] << 1;
385: arg1[i] = carry & 0xff;
386: carry >>= 8;
387: }
388: count--;
389: }
390:
391: decode (arg1, lv, hv);
392: }
393:
394: /* Rotate the 64-bit integer in L1, H1 left by COUNT places
395: keeping only PREC bits of result. COUNT must be positive.
396: Store the value as two `int' pieces in *LV and *HV. */
397:
398: void
399: rrotate_double (l1, h1, count, prec, lv, hv)
400: int l1, h1, count, prec;
401: int *lv, *hv;
402: {
403: short arg1[8];
404: register int i;
405: register int carry;
406:
407: encode (arg1, l1, h1);
408:
409: if (count > prec)
410: count = prec;
411:
412: carry = arg1[0] & 1;
413: while (count > 0)
414: {
415: for (i = 7; i >= 0; i--)
416: {
417: carry <<= 8;
418: carry += arg1[i];
419: arg1[i] = (carry >> 1) & 0xff;
420: }
421: count--;
422: }
423:
424: decode (arg1, lv, hv);
425: }
426:
427: /* Divide 64 bit integer LNUM, HNUM by 64 bit integer LDEN, HDEN
428: for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
429: CODE is a tree code for a kind of division, one of
430: TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
431: or EXACT_DIV_EXPR
432: It controls how the quotient is rounded to a integer.
433: UNS nonzero says do unsigned division. */
434:
435: static void
436: div_and_round_double (code, uns,
437: lnum_orig, hnum_orig, lden_orig, hden_orig,
438: lquo, hquo, lrem, hrem)
439: enum tree_code code;
440: int uns;
441: int lnum_orig, hnum_orig; /* num == numerator == dividend */
442: int lden_orig, hden_orig; /* den == denominator == divisor */
443: int *lquo, *hquo, *lrem, *hrem;
444: {
445: int quo_neg = 0;
446: short num[9], den[8], quo[8]; /* extra element for scaling. */
447: register int i, j, work;
448: register int carry = 0;
449: unsigned int lnum = lnum_orig;
450: int hnum = hnum_orig;
451: unsigned int lden = lden_orig;
452: int hden = hden_orig;
453:
454: if ((hden == 0) && (lden == 0))
455: abort ();
456:
457: /* calculate quotient sign and convert operands to unsigned. */
458: if (!uns)
459: {
460: if (hden < 0)
461: {
462: quo_neg = ~ quo_neg;
463: neg_double (lden, hden, &lden, &hden);
464: }
465: if (hnum < 0)
466: {
467: quo_neg = ~ quo_neg;
468: neg_double (lnum, hnum, &lnum, &hnum);
469: }
470: }
471:
472: if (hnum == 0 && hden == 0)
473: { /* single precision */
474: *hquo = *hrem = 0;
475: *lquo = lnum / lden; /* rounds toward zero since positive args */
476: goto finish_up;
477: }
478:
479: if (hnum == 0)
480: { /* trivial case: dividend < divisor */
481: /* hden != 0 already checked. */
482: *hquo = *lquo = 0;
483: *hrem = hnum;
484: *lrem = lnum;
485: goto finish_up;
486: }
487:
488: bzero (quo, sizeof quo);
489:
490: bzero (num, sizeof num); /* to zero 9th element */
491: bzero (den, sizeof den);
492:
493: encode (num, lnum, hnum);
494: encode (den, lden, hden);
495:
496: /* This code requires more than just hden == 0.
497: We also have to require that we don't need more than three bytes
498: to hold CARRY. If we ever did need four bytes to hold it, we
499: would lose part of it when computing WORK on the next round. */
500: if (hden == 0 && ((lden << 8) >> 8) == lden)
501: { /* simpler algorithm */
502: /* hnum != 0 already checked. */
503: for (i = 7; i >= 0; i--)
504: {
505: work = num[i] + (carry << 8);
506: quo[i] = work / lden;
507: carry = work % lden;
508: }
509: }
510: else { /* full double precision,
511: with thanks to Don Knuth's
512: "Semi-Numericial Algorithms". */
513: #define BASE 256
514: int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
515:
516: /* Find the highest non-zero divisor digit. */
517: for (i = 7; ; i--)
518: if (den[i] != 0) {
519: den_hi_sig = i;
520: break;
521: }
522: for (i = 7; ; i--)
523: if (num[i] != 0) {
524: num_hi_sig = i;
525: break;
526: }
527: quo_hi_sig = num_hi_sig - den_hi_sig + 1;
528:
529: /* Insure that the first digit of the divisor is at least BASE/2.
530: This is required by the quotient digit estimation algorithm. */
531:
532: scale = BASE / (den[den_hi_sig] + 1);
533: if (scale > 1) { /* scale divisor and dividend */
534: carry = 0;
535: for (i = 0; i <= 8; i++) {
536: work = (num[i] * scale) + carry;
537: num[i] = work & 0xff;
538: carry = work >> 8;
539: if (num[i] != 0) num_hi_sig = i;
540: }
541: carry = 0;
542: for (i = 0; i <= 7; i++) {
543: work = (den[i] * scale) + carry;
544: den[i] = work & 0xff;
545: carry = work >> 8;
546: if (den[i] != 0) den_hi_sig = i;
547: }
548: }
549:
550: /* Main loop */
551: for (i = quo_hi_sig; i > 0; i--) {
552: /* quess the next quotient digit, quo_est, by dividing the first
553: two remaining dividend digits by the high order quotient digit.
554: quo_est is never low and is at most 2 high. */
555:
556: int num_hi; /* index of highest remaining dividend digit */
557:
558: num_hi = i + den_hi_sig;
559:
560: work = (num[num_hi] * BASE) + (num_hi > 0 ? num[num_hi - 1] : 0);
561: if (num[num_hi] != den[den_hi_sig]) {
562: quo_est = work / den[den_hi_sig];
563: }
564: else {
565: quo_est = BASE - 1;
566: }
567:
568: /* refine quo_est so it's usually correct, and at most one high. */
569: while ((den[den_hi_sig - 1] * quo_est)
570: > (((work - (quo_est * den[den_hi_sig])) * BASE)
571: + ((num_hi - 1) > 0 ? num[num_hi - 2] : 0)))
572: quo_est--;
573:
574: /* Try QUO_EST as the quotient digit, by multiplying the
575: divisor by QUO_EST and subtracting from the remaining dividend.
576: Keep in mind that QUO_EST is the I - 1st digit. */
577:
578: carry = 0;
579:
580: for (j = 0; j <= den_hi_sig; j++)
581: {
582: int digit;
583:
584: work = num[i + j - 1] - (quo_est * den[j]) + carry;
585: digit = work & 0xff;
586: carry = work >> 8;
587: if (digit < 0)
588: {
589: digit += BASE;
590: carry--;
591: }
592: num[i + j - 1] = digit;
593: }
594:
595: /* if quo_est was high by one, then num[i] went negative and
596: we need to correct things. */
597:
598: if (num[num_hi] < 0)
599: {
600: quo_est--;
601: carry = 0; /* add divisor back in */
602: for (j = 0; j <= den_hi_sig; j++)
603: {
604: work = num[i + j - 1] + den[j] + carry;
605: if (work > BASE)
606: {
607: work -= BASE;
608: carry = 1;
609: }
610: else
611: {
612: carry = 0;
613: }
614: num[i + j - 1] = work;
615: }
616: num [num_hi] += carry;
617: }
618:
619: /* store the quotient digit. */
620: quo[i - 1] = quo_est;
621: }
622: }
623:
624: decode (quo, lquo, hquo);
625:
626: finish_up:
627: /* if result is negative, make it so. */
628: if (quo_neg)
629: neg_double (*lquo, *hquo, lquo, hquo);
630:
631: /* compute trial remainder: rem = num - (quo * den) */
632: mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
633: neg_double (*lrem, *hrem, lrem, hrem);
634: add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
635:
636: switch (code)
637: {
638: case TRUNC_DIV_EXPR:
639: case TRUNC_MOD_EXPR: /* round toward zero */
640: case EXACT_DIV_EXPR: /* for this one, it shouldn't matter */
641: return;
642:
643: case FLOOR_DIV_EXPR:
644: case FLOOR_MOD_EXPR: /* round toward negative infinity */
645: if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
646: {
647: /* quo = quo - 1; */
648: add_double (*lquo, *hquo, -1, -1, lquo, hquo);
649: }
650: else return;
651: break;
652:
653: case CEIL_DIV_EXPR:
654: case CEIL_MOD_EXPR: /* round toward positive infinity */
655: if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
656: {
657: add_double (*lquo, *hquo, 1, 0, lquo, hquo);
658: }
659: else return;
660: break;
661:
662: case ROUND_DIV_EXPR:
663: case ROUND_MOD_EXPR: /* round to closest integer */
664: {
665: int labs_rem = *lrem, habs_rem = *hrem;
666: int labs_den = lden, habs_den = hden, ltwice, htwice;
667:
668: /* get absolute values */
669: if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
670: if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
671:
672: /* if (2 * abs (lrem) >= abs (lden)) */
673: mul_double (2, 0, labs_rem, habs_rem, <wice, &htwice);
674: if (((unsigned) habs_den < (unsigned) htwice)
675: || (((unsigned) habs_den == (unsigned) htwice)
676: && ((unsigned) labs_den < (unsigned) ltwice)))
677: {
678: if (*hquo < 0)
679: /* quo = quo - 1; */
680: add_double (*lquo, *hquo, -1, -1, lquo, hquo);
681: else
682: /* quo = quo + 1; */
683: add_double (*lquo, *hquo, 1, 0, lquo, hquo);
684: }
685: else return;
686: }
687: break;
688:
689: default:
690: abort ();
691: }
692:
693: /* compute true remainder: rem = num - (quo * den) */
694: mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
695: neg_double (*lrem, *hrem, lrem, hrem);
696: add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
697: }
698:
699: #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
700:
701: /* Check for infinity in an IEEE double precision number. */
702:
703: int
704: target_isinf (x)
705: REAL_VALUE_TYPE x;
706: {
707: /* The IEEE 64-bit double format. */
708: union {
709: REAL_VALUE_TYPE d;
710: struct {
711: unsigned sign : 1;
712: unsigned exponent : 11;
713: unsigned mantissa1 : 20;
714: unsigned mantissa2;
715: } little_endian;
716: struct {
717: unsigned mantissa2;
718: unsigned mantissa1 : 20;
719: unsigned exponent : 11;
720: unsigned sign : 1;
721: } big_endian;
722: } u;
723:
724: u.d = dconstm1;
725: if (u.big_endian.sign == 1)
726: {
727: u.d = x;
728: return (u.big_endian.exponent == 2047
729: && u.big_endian.mantissa1 == 0
730: && u.big_endian.mantissa2 == 0);
731: }
732: else
733: {
734: u.d = x;
735: return (u.little_endian.exponent == 2047
736: && u.little_endian.mantissa1 == 0
737: && u.little_endian.mantissa2 == 0);
738: }
739: }
740:
741: /* Check for minus zero in an IEEE double precision number. */
742:
743: int
744: target_minus_zero (x)
745: REAL_VALUE_TYPE x;
746: {
747: REAL_VALUE_TYPE d1, d2;
748:
749: d1 = REAL_VALUE_NEGATE (x);
750: d2 = dconst0;
751:
752: return !bcmp (&d1, &d2, sizeof (d1));
753: }
754: #else /* Target not IEEE */
755:
756: /* Let's assume other float formats don't have infinity.
757: (This can be overridden by redefining REAL_VALUE_ISINF.) */
758:
759: target_isinf (x)
760: REAL_VALUE_TYPE x;
761: {
762: return 0;
763: }
764:
765: /* Let's assume other float formats don't have minus zero.
766: (This can be overridden by redefining REAL_VALUE_MINUS_ZERO.) */
767:
768: target_minus_zero (x)
769: REAL_VALUE_TYPE x;
770: {
771: return 0;
772: }
773: #endif /* Target not IEEE */
774:
775: /* Split a tree IN into a constant and a variable part
776: that could be combined with CODE to make IN.
777: CODE must be a commutative arithmetic operation.
778: Store the constant part into *CONP and the variable in &VARP.
779: Return 1 if this was done; zero means the tree IN did not decompose
780: this way.
781:
782: If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
783: Therefore, we must tell the caller whether the variable part
784: was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
785: The value stored is the coefficient for the variable term.
786: The constant term we return should always be added;
787: we negate it if necessary. */
788:
789: static int
790: split_tree (in, code, varp, conp, varsignp)
791: tree in;
792: enum tree_code code;
793: tree *varp, *conp;
794: int *varsignp;
795: {
796: register tree outtype = TREE_TYPE (in);
797: *varp = 0;
798: *conp = 0;
799:
800: /* Strip any conversions that don't change the machine mode. */
801: while ((TREE_CODE (in) == NOP_EXPR
802: || TREE_CODE (in) == CONVERT_EXPR)
803: && (TYPE_MODE (TREE_TYPE (in))
804: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
805: in = TREE_OPERAND (in, 0);
806:
807: if (TREE_CODE (in) == code
808: || (TREE_CODE (TREE_TYPE (in)) != REAL_TYPE
809: /* We can associate addition and subtraction together
810: (even though the C standard doesn't say so)
811: for integers because the value is not affected.
812: For reals, the value might be affected, so we can't. */
813: &&
814: ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
815: || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
816: {
817: enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
818: if (code == INTEGER_CST)
819: {
820: *conp = TREE_OPERAND (in, 0);
821: *varp = TREE_OPERAND (in, 1);
822: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
823: && TREE_TYPE (*varp) != outtype)
824: *varp = convert (outtype, *varp);
825: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
826: return 1;
827: }
828: if (TREE_CONSTANT (TREE_OPERAND (in, 1)))
829: {
830: *conp = TREE_OPERAND (in, 1);
831: *varp = TREE_OPERAND (in, 0);
832: *varsignp = 1;
833: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
834: && TREE_TYPE (*varp) != outtype)
835: *varp = convert (outtype, *varp);
836: if (TREE_CODE (in) == MINUS_EXPR)
837: {
838: /* If operation is subtraction and constant is second,
839: must negate it to get an additive constant.
840: And this cannot be done unless it is a manifest constant.
841: It could also be the address of a static variable.
842: We cannot negate that, so give up. */
843: if (TREE_CODE (*conp) == INTEGER_CST)
844: /* Subtracting from integer_zero_node loses for long long. */
845: *conp = fold (build1 (NEGATE_EXPR, TREE_TYPE (*conp), *conp));
846: else
847: return 0;
848: }
849: return 1;
850: }
851: if (TREE_CONSTANT (TREE_OPERAND (in, 0)))
852: {
853: *conp = TREE_OPERAND (in, 0);
854: *varp = TREE_OPERAND (in, 1);
855: if (TYPE_MODE (TREE_TYPE (*varp)) != TYPE_MODE (outtype)
856: && TREE_TYPE (*varp) != outtype)
857: *varp = convert (outtype, *varp);
858: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
859: return 1;
860: }
861: }
862: return 0;
863: }
864:
865: /* Combine two constants NUM and ARG2 under operation CODE
866: to produce a new constant.
867: We assume ARG1 and ARG2 have the same data type,
868: or at least are the same kind of constant and the same machine mode. */
869:
870: /* Handle floating overflow for `const_binop'. */
871: static jmp_buf const_binop_error;
872:
873: static tree
874: const_binop (code, arg1, arg2)
875: enum tree_code code;
876: register tree arg1, arg2;
877: {
878: if (TREE_CODE (arg1) == INTEGER_CST)
879: {
880: register int int1l = TREE_INT_CST_LOW (arg1);
881: register int int1h = TREE_INT_CST_HIGH (arg1);
882: int int2l = TREE_INT_CST_LOW (arg2);
883: int int2h = TREE_INT_CST_HIGH (arg2);
884: int low, hi;
885: int garbagel, garbageh;
886: register tree t;
887: int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
888:
889: switch (code)
890: {
891: case BIT_IOR_EXPR:
892: t = build_int_2 (int1l | int2l, int1h | int2h);
893: break;
894:
895: case BIT_XOR_EXPR:
896: t = build_int_2 (int1l ^ int2l, int1h ^ int2h);
897: break;
898:
899: case BIT_AND_EXPR:
900: t = build_int_2 (int1l & int2l, int1h & int2h);
901: break;
902:
903: case BIT_ANDTC_EXPR:
904: t = build_int_2 (int1l & ~int2l, int1h & ~int2h);
905: break;
906:
907: case RSHIFT_EXPR:
908: int2l = - int2l;
909: case LSHIFT_EXPR:
910: lshift_double (int1l, int1h, int2l,
911: TYPE_PRECISION (TREE_TYPE (arg1)),
912: &low, &hi,
913: !uns);
914: t = build_int_2 (low, hi);
915: break;
916:
917: case RROTATE_EXPR:
918: int2l = - int2l;
919: case LROTATE_EXPR:
920: lrotate_double (int1l, int1h, int2l,
921: TYPE_PRECISION (TREE_TYPE (arg1)),
922: &low, &hi);
923: t = build_int_2 (low, hi);
924: break;
925:
926: case PLUS_EXPR:
927: if (int1h == 0)
928: {
929: int2l += int1l;
930: if ((unsigned) int2l < int1l)
931: int2h += 1;
932: t = build_int_2 (int2l, int2h);
933: break;
934: }
935: if (int2h == 0)
936: {
937: int1l += int2l;
938: if ((unsigned) int1l < int2l)
939: int1h += 1;
940: t = build_int_2 (int1l, int1h);
941: break;
942: }
943: add_double (int1l, int1h, int2l, int2h, &low, &hi);
944: t = build_int_2 (low, hi);
945: break;
946:
947: case MINUS_EXPR:
948: if (int2h == 0 && int2l == 0)
949: {
950: t = build_int_2 (int1l, int1h);
951: break;
952: }
953: neg_double (int2l, int2h, &int2l, &int2h);
954: add_double (int1l, int1h, int2l, int2h, &low, &hi);
955: t = build_int_2 (low, hi);
956: break;
957:
958: case MULT_EXPR:
959: /* Optimize simple cases. */
960: if (int1h == 0)
961: {
962: unsigned temp;
963:
964: switch (int1l)
965: {
966: case 0:
967: t = build_int_2 (0, 0);
968: goto got_it;
969: case 1:
970: t = build_int_2 (int2l, int2h);
971: goto got_it;
972: case 2:
973: temp = int2l + int2l;
974: int2h = int2h * 2 + (temp < int2l);
975: t = build_int_2 (temp, int2h);
976: goto got_it;
977: case 3:
978: temp = int2l + int2l + int2l;
979: int2h = int2h * 3 + (temp < int2l);
980: t = build_int_2 (temp, int2h);
981: goto got_it;
982: case 4:
983: temp = int2l + int2l;
984: int2h = int2h * 4 + ((temp < int2l) << 1);
985: int2l = temp;
986: temp += temp;
987: int2h += (temp < int2l);
988: t = build_int_2 (temp, int2h);
989: goto got_it;
990: case 8:
991: temp = int2l + int2l;
992: int2h = int2h * 8 + ((temp < int2l) << 2);
993: int2l = temp;
994: temp += temp;
995: int2h += (temp < int2l) << 1;
996: int2l = temp;
997: temp += temp;
998: int2h += (temp < int2l);
999: t = build_int_2 (temp, int2h);
1000: goto got_it;
1001: default:
1002: break;
1003: }
1004: }
1005:
1006: if (int2h == 0)
1007: {
1008: if (int2l == 0)
1009: {
1010: t = build_int_2 (0, 0);
1011: break;
1012: }
1013: if (int2l == 1)
1014: {
1015: t = build_int_2 (int1l, int1h);
1016: break;
1017: }
1018: }
1019:
1020: mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1021: t = build_int_2 (low, hi);
1022: break;
1023:
1024: case TRUNC_DIV_EXPR:
1025: case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1026: case EXACT_DIV_EXPR:
1027: /* This is a shortcut for a common special case.
1028: It reduces the number of tree nodes generated
1029: and saves time. */
1030: if (int2h == 0 && int2l > 0
1031: && TREE_TYPE (arg1) == sizetype
1032: && int1h == 0 && int1l >= 0)
1033: {
1034: if (code == CEIL_DIV_EXPR)
1035: int1l += int2l-1;
1036: return size_int (int1l / int2l);
1037: }
1038: case ROUND_DIV_EXPR:
1039: if (int2h == 0 && int2l == 1)
1040: {
1041: t = build_int_2 (int1l, int1h);
1042: break;
1043: }
1044: if (int1l == int2l && int1h == int2h)
1045: {
1046: if ((int1l | int1h) == 0)
1047: abort ();
1048: t = build_int_2 (1, 0);
1049: break;
1050: }
1051: div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1052: &low, &hi, &garbagel, &garbageh);
1053: t = build_int_2 (low, hi);
1054: break;
1055:
1056: case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR:
1057: case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1058: div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1059: &garbagel, &garbageh, &low, &hi);
1060: t = build_int_2 (low, hi);
1061: break;
1062:
1063: case MIN_EXPR:
1064: case MAX_EXPR:
1065: if (uns)
1066: {
1067: low = (((unsigned) int1h < (unsigned) int2h)
1068: || (((unsigned) int1h == (unsigned) int2h)
1069: && ((unsigned) int1l < (unsigned) int2l)));
1070: }
1071: else
1072: {
1073: low = ((int1h < int2h)
1074: || ((int1h == int2h)
1075: && ((unsigned) int1l < (unsigned) int2l)));
1076: }
1077: if (low == (code == MIN_EXPR))
1078: t = build_int_2 (int1l, int1h);
1079: else
1080: t = build_int_2 (int2l, int2h);
1081: break;
1082:
1083: default:
1084: abort ();
1085: }
1086: got_it:
1087: TREE_TYPE (t) = TREE_TYPE (arg1);
1088: force_fit_type (t);
1089: return t;
1090: }
1091: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1092: if (TREE_CODE (arg1) == REAL_CST)
1093: {
1094: register REAL_VALUE_TYPE d1;
1095: register REAL_VALUE_TYPE d2;
1096: register REAL_VALUE_TYPE value;
1097:
1098: d1 = TREE_REAL_CST (arg1);
1099: d2 = TREE_REAL_CST (arg2);
1100: if (setjmp (const_binop_error))
1101: {
1102: warning ("floating overflow in constant folding");
1103: return build (code, TREE_TYPE (arg1), arg1, arg2);
1104: }
1105: set_float_handler (const_binop_error);
1106:
1107: #ifdef REAL_ARITHMETIC
1108: REAL_ARITHMETIC (value, code, d1, d2);
1109: #else
1110: switch (code)
1111: {
1112: case PLUS_EXPR:
1113: value = d1 + d2;
1114: break;
1115:
1116: case MINUS_EXPR:
1117: value = d1 - d2;
1118: break;
1119:
1120: case MULT_EXPR:
1121: value = d1 * d2;
1122: break;
1123:
1124: case RDIV_EXPR:
1125: #ifndef REAL_INFINITY
1126: if (d2 == 0)
1127: abort ();
1128: #endif
1129:
1130: value = d1 / d2;
1131: break;
1132:
1133: case MIN_EXPR:
1134: value = MIN (d1, d2);
1135: break;
1136:
1137: case MAX_EXPR:
1138: value = MAX (d1, d2);
1139: break;
1140:
1141: default:
1142: abort ();
1143: }
1144: #endif /* no REAL_ARITHMETIC */
1145: set_float_handler (0);
1146: value = REAL_VALUE_TRUNCATE (TYPE_MODE (TREE_TYPE (arg1)), value);
1147: return build_real (TREE_TYPE (arg1), value);
1148: }
1149: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1150: if (TREE_CODE (arg1) == COMPLEX_CST)
1151: {
1152: register tree r1 = TREE_REALPART (arg1);
1153: register tree i1 = TREE_IMAGPART (arg1);
1154: register tree r2 = TREE_REALPART (arg2);
1155: register tree i2 = TREE_IMAGPART (arg2);
1156: register tree t;
1157:
1158: switch (code)
1159: {
1160: case PLUS_EXPR:
1161: t = build_complex (const_binop (PLUS_EXPR, r1, r2),
1162: const_binop (PLUS_EXPR, i1, i2));
1163: break;
1164:
1165: case MINUS_EXPR:
1166: t = build_complex (const_binop (MINUS_EXPR, r1, r2),
1167: const_binop (MINUS_EXPR, i1, i2));
1168: break;
1169:
1170: case MULT_EXPR:
1171: t = build_complex (const_binop (MINUS_EXPR,
1172: const_binop (MULT_EXPR, r1, r2),
1173: const_binop (MULT_EXPR, i1, i2)),
1174: const_binop (PLUS_EXPR,
1175: const_binop (MULT_EXPR, r1, i2),
1176: const_binop (MULT_EXPR, i1, r2)));
1177: break;
1178:
1179: case RDIV_EXPR:
1180: {
1181: register tree magsquared
1182: = const_binop (PLUS_EXPR,
1183: const_binop (MULT_EXPR, r2, r2),
1184: const_binop (MULT_EXPR, i2, i2));
1185: t = build_complex (const_binop (RDIV_EXPR,
1186: const_binop (PLUS_EXPR,
1187: const_binop (MULT_EXPR, r1, r2),
1188: const_binop (MULT_EXPR, i1, i2)),
1189: magsquared),
1190: const_binop (RDIV_EXPR,
1191: const_binop (MINUS_EXPR,
1192: const_binop (MULT_EXPR, i1, r2),
1193: const_binop (MULT_EXPR, r1, i2)),
1194: magsquared));
1195: }
1196: break;
1197:
1198: default:
1199: abort ();
1200: }
1201: TREE_TYPE (t) = TREE_TYPE (arg1);
1202: return t;
1203: }
1204: return 0;
1205: }
1206:
1207: /* Return an INTEGER_CST with value V and type from `sizetype'. */
1208:
1209: tree
1210: size_int (number)
1211: unsigned int number;
1212: {
1213: register tree t;
1214: /* Type-size nodes already made for small sizes. */
1215: static tree size_table[2*HOST_BITS_PER_INT+1];
1216:
1217: if (number >= 0 && number < 2*HOST_BITS_PER_INT+1 && size_table[number] != 0)
1218: return size_table[number];
1219: if (number >= 0 && number < 2*HOST_BITS_PER_INT+1)
1220: {
1221: int temp = allocation_temporary_p ();
1222:
1223: push_obstacks_nochange ();
1224: /* Make this a permanent node. */
1225: if (temp)
1226: end_temporary_allocation ();
1227: t = build_int_2 (number, 0);
1228: TREE_TYPE (t) = sizetype;
1229: size_table[number] = t;
1230: pop_obstacks ();
1231: }
1232: else
1233: {
1234: t = build_int_2 (number, 0);
1235: TREE_TYPE (t) = sizetype;
1236: }
1237: return t;
1238: }
1239:
1240: /* Combine operands OP1 and OP2 with arithmetic operation CODE.
1241: CODE is a tree code. Data type is taken from `sizetype',
1242: If the operands are constant, so is the result. */
1243:
1244: tree
1245: size_binop (code, arg0, arg1)
1246: enum tree_code code;
1247: tree arg0, arg1;
1248: {
1249: /* Handle the special case of two integer constants faster. */
1250: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1251: {
1252: /* And some specific cases even faster than that. */
1253: if (code == PLUS_EXPR
1254: && TREE_INT_CST_LOW (arg0) == 0
1255: && TREE_INT_CST_HIGH (arg0) == 0)
1256: return arg1;
1257: if (code == MINUS_EXPR
1258: && TREE_INT_CST_LOW (arg1) == 0
1259: && TREE_INT_CST_HIGH (arg1) == 0)
1260: return arg0;
1261: if (code == MULT_EXPR
1262: && TREE_INT_CST_LOW (arg0) == 1
1263: && TREE_INT_CST_HIGH (arg0) == 0)
1264: return arg1;
1265: /* Handle general case of two integer constants. */
1266: return const_binop (code, arg0, arg1);
1267: }
1268:
1269: if (arg0 == error_mark_node || arg1 == error_mark_node)
1270: return error_mark_node;
1271:
1272: return fold (build (code, sizetype, arg0, arg1));
1273: }
1274:
1275: /* Given T, a tree representing type conversion of ARG1, a constant,
1276: return a constant tree representing the result of conversion. */
1277:
1278: static tree
1279: fold_convert (t, arg1)
1280: register tree t;
1281: register tree arg1;
1282: {
1283: register tree type = TREE_TYPE (t);
1284:
1285: if (TREE_CODE (type) == POINTER_TYPE
1286: || TREE_CODE (type) == INTEGER_TYPE
1287: || TREE_CODE (type) == ENUMERAL_TYPE)
1288: {
1289: if (TREE_CODE (arg1) == INTEGER_CST)
1290: {
1291: /* Given an integer constant, make new constant with new type,
1292: appropriately sign-extended or truncated. */
1293: t = build_int_2 (TREE_INT_CST_LOW (arg1),
1294: TREE_INT_CST_HIGH (arg1));
1295: TREE_TYPE (t) = type;
1296: force_fit_type (t);
1297: }
1298: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1299: else if (TREE_CODE (arg1) == REAL_CST)
1300: {
1301: if (REAL_VALUES_LESS (real_value_from_int_cst (TYPE_MAX_VALUE (type)),
1302: TREE_REAL_CST (arg1))
1303: || REAL_VALUES_LESS (TREE_REAL_CST (arg1),
1304: real_value_from_int_cst (TYPE_MIN_VALUE (type))))
1305: {
1306: warning ("real constant out of range for integer conversion");
1307: return t;
1308: }
1309: #ifndef REAL_ARITHMETIC
1310: {
1311: REAL_VALUE_TYPE d;
1312: int low, high;
1313: int half_word = 1 << (HOST_BITS_PER_INT / 2);
1314:
1315: d = TREE_REAL_CST (arg1);
1316: if (d < 0)
1317: d = -d;
1318:
1319: high = (int) (d / half_word / half_word);
1320: d -= (REAL_VALUE_TYPE) high * half_word * half_word;
1321: low = (unsigned) d;
1322: if (TREE_REAL_CST (arg1) < 0)
1323: neg_double (low, high, &low, &high);
1324: t = build_int_2 (low, high);
1325: }
1326: #else
1327: {
1328: int low, high;
1329: REAL_VALUE_TO_INT (low, high, TREE_REAL_CST (arg1));
1330: t = build_int_2 (low, high);
1331: }
1332: #endif
1333: TREE_TYPE (t) = type;
1334: force_fit_type (t);
1335: }
1336: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1337: TREE_TYPE (t) = type;
1338: }
1339: else if (TREE_CODE (type) == REAL_TYPE)
1340: {
1341: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1342: if (TREE_CODE (arg1) == INTEGER_CST)
1343: return build_real_from_int_cst (type, arg1);
1344: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1345: if (TREE_CODE (arg1) == REAL_CST)
1346: return build_real (type, REAL_VALUE_TRUNCATE (TYPE_MODE (type),
1347: TREE_REAL_CST (arg1)));
1348: }
1349: TREE_CONSTANT (t) = 1;
1350: return t;
1351: }
1352:
1353: /* Return an expr equal to X but certainly not valid as an lvalue. */
1354:
1355: tree
1356: non_lvalue (x)
1357: tree x;
1358: {
1359: tree result;
1360:
1361: /* These things are certainly not lvalues. */
1362: if (TREE_CODE (x) == NON_LVALUE_EXPR
1363: || TREE_CODE (x) == INTEGER_CST
1364: || TREE_CODE (x) == REAL_CST
1365: || TREE_CODE (x) == STRING_CST
1366: || TREE_CODE (x) == ADDR_EXPR)
1367: return x;
1368:
1369: result = build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
1370: TREE_CONSTANT (result) = TREE_CONSTANT (x);
1371: return result;
1372: }
1373:
1374: /* Return nonzero if two operands are necessarily equal.
1375: If ONLY_CONST is non-zero, only return non-zero for constants. */
1376:
1377: int
1378: operand_equal_p (arg0, arg1, only_const)
1379: tree arg0, arg1;
1380: int only_const;
1381: {
1382: /* If both types don't have the same signedness, then we can't consider
1383: them equal. We must check this before the STRIP_NOPS calls
1384: because they may change the signedness of the arguments. */
1385: if (TREE_UNSIGNED (TREE_TYPE (arg0)) != TREE_UNSIGNED (TREE_TYPE (arg1)))
1386: return 0;
1387:
1388: STRIP_NOPS (arg0);
1389: STRIP_NOPS (arg1);
1390:
1391: /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1392: We don't care about side effects in that case because the SAVE_EXPR
1393: takes care of that for us. */
1394: if (TREE_CODE (arg0) == SAVE_EXPR && arg0 == arg1)
1395: return ! only_const;
1396:
1397: if (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1))
1398: return 0;
1399:
1400: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1401: && TREE_CODE (arg0) == ADDR_EXPR
1402: && TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0))
1403: return 1;
1404:
1405: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1406: && TREE_CODE (arg0) == INTEGER_CST
1407: && TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
1408: && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1))
1409: return 1;
1410:
1411: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1412: && TREE_CODE (arg0) == REAL_CST
1413: && REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), TREE_REAL_CST (arg1)))
1414: return 1;
1415:
1416: if (only_const)
1417: return 0;
1418:
1419: if (arg0 == arg1)
1420: return 1;
1421:
1422: if (TREE_CODE (arg0) != TREE_CODE (arg1))
1423: return 0;
1424: /* This is needed for conversions and for COMPONENT_REF.
1425: Might as well play it safe and always test this. */
1426: if (TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
1427: return 0;
1428:
1429: switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
1430: {
1431: case '1':
1432: /* Two conversions are equal only if signedness and modes match. */
1433: if ((TREE_CODE (arg0) == NOP_EXPR || TREE_CODE (arg0) == CONVERT_EXPR)
1434: && (TREE_UNSIGNED (TREE_TYPE (arg0))
1435: != TREE_UNSIGNED (TREE_TYPE (arg1))))
1436: return 0;
1437:
1438: return operand_equal_p (TREE_OPERAND (arg0, 0),
1439: TREE_OPERAND (arg1, 0), 0);
1440:
1441: case '<':
1442: case '2':
1443: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1444: TREE_OPERAND (arg1, 0), 0)
1445: && operand_equal_p (TREE_OPERAND (arg0, 1),
1446: TREE_OPERAND (arg1, 1), 0));
1447:
1448: case 'r':
1449: switch (TREE_CODE (arg0))
1450: {
1451: case INDIRECT_REF:
1452: return operand_equal_p (TREE_OPERAND (arg0, 0),
1453: TREE_OPERAND (arg1, 0), 0);
1454:
1455: case COMPONENT_REF:
1456: case ARRAY_REF:
1457: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1458: TREE_OPERAND (arg1, 0), 0)
1459: && operand_equal_p (TREE_OPERAND (arg0, 1),
1460: TREE_OPERAND (arg1, 1), 0));
1461:
1462: case BIT_FIELD_REF:
1463: return (operand_equal_p (TREE_OPERAND (arg0, 0),
1464: TREE_OPERAND (arg1, 0), 0)
1465: && operand_equal_p (TREE_OPERAND (arg0, 1),
1466: TREE_OPERAND (arg1, 1), 0)
1467: && operand_equal_p (TREE_OPERAND (arg0, 2),
1468: TREE_OPERAND (arg1, 2), 0));
1469: }
1470: break;
1471: }
1472:
1473: return 0;
1474: }
1475:
1476: /* Return nonzero if comparing COMP1 with COMP2
1477: gives the same result as comparing OP1 with OP2.
1478: When in doubt, return 0. */
1479:
1480: static int
1481: comparison_equiv_p (comp1, comp2, op1, op2)
1482: tree comp1, comp2, op1, op2;
1483: {
1484: int unsignedp1, unsignedp2;
1485: tree primop1, primop2;
1486: int correct_width;
1487:
1488: if (operand_equal_p (comp1, op1, 0)
1489: && operand_equal_p (comp2, op2, 0))
1490: return 1;
1491:
1492: if (TREE_CODE (TREE_TYPE (op1)) != INTEGER_TYPE)
1493: return 0;
1494:
1495: if (TREE_TYPE (op1) != TREE_TYPE (op2))
1496: return 0;
1497:
1498: if (TREE_TYPE (comp1) != TREE_TYPE (comp2))
1499: return 0;
1500:
1501: /* Duplicate what shorten_compare does to the comparison operands,
1502: and see if that gives the actual comparison operands, COMP1 and COMP2. */
1503:
1504: /* Throw away any conversions to wider types
1505: already present in the operands. */
1506: primop1 = get_narrower (op1, &unsignedp1);
1507: primop2 = get_narrower (op2, &unsignedp2);
1508:
1509: correct_width = TYPE_PRECISION (TREE_TYPE (op2));
1510: if (unsignedp1 == unsignedp2
1511: && TYPE_PRECISION (TREE_TYPE (primop1)) < correct_width
1512: && TYPE_PRECISION (TREE_TYPE (primop2)) < correct_width)
1513: {
1514: tree type = TREE_TYPE (comp1);
1515:
1516: /* Make sure shorter operand is extended the right way
1517: to match the longer operand. */
1518: primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1519: primop1);
1520: primop2 = convert (signed_or_unsigned_type (unsignedp2, TREE_TYPE (primop2)),
1521: primop2);
1522:
1523: primop1 = convert (type, primop1);
1524: primop2 = convert (type, primop2);
1525:
1526: if (operand_equal_p (comp1, primop1, 0)
1527: && operand_equal_p (comp2, primop2, 0))
1528: return 1;
1529: }
1530:
1531: return 0;
1532: }
1533:
1534: /* Return a tree for the case when the result of an expression is RESULT
1535: converted to TYPE and OMITTED was previously an operand of the expression
1536: but is now not needed (e.g., we folded OMITTED * 0).
1537:
1538: If OMITTED has side effects, we must evaluate it. Otherwise, just do
1539: the conversion of RESULT to TYPE. */
1540:
1541: static tree
1542: omit_one_operand (type, result, omitted)
1543: tree type, result, omitted;
1544: {
1545: tree t = convert (type, result);
1546:
1547: if (TREE_SIDE_EFFECTS (omitted))
1548: return build (COMPOUND_EXPR, type, omitted, t);
1549:
1550: return t;
1551: }
1552:
1553: /* Return a simplified tree node for the truth-negation of ARG
1554: (perhaps by altering ARG). It is known that ARG is an operation that
1555: returns a truth value (0 or 1). */
1556:
1557: tree
1558: invert_truthvalue (arg)
1559: tree arg;
1560: {
1561: tree type = TREE_TYPE (arg);
1562:
1563: /* For floating-point comparisons, it isn't safe to invert the condition.
1564: So just enclose a TRUTH_NOT_EXPR around what we have. */
1565: if (TREE_CODE (type) == REAL_TYPE
1566: && TREE_CODE_CLASS (TREE_CODE (arg)) == '<')
1567: return build1 (TRUTH_NOT_EXPR, type, arg);
1568:
1569: switch (TREE_CODE (arg))
1570: {
1571: case NE_EXPR:
1572: TREE_SET_CODE (arg, EQ_EXPR);
1573: return arg;
1574:
1575: case EQ_EXPR:
1576: TREE_SET_CODE (arg, NE_EXPR);
1577: return arg;
1578:
1579: case GE_EXPR:
1580: TREE_SET_CODE (arg, LT_EXPR);
1581: return arg;
1582:
1583: case GT_EXPR:
1584: TREE_SET_CODE (arg, LE_EXPR);
1585: return arg;
1586:
1587: case LE_EXPR:
1588: TREE_SET_CODE (arg, GT_EXPR);
1589: return arg;
1590:
1591: case LT_EXPR:
1592: TREE_SET_CODE (arg, GE_EXPR);
1593: return arg;
1594:
1595: case INTEGER_CST:
1596: return convert (type, build_int_2 (TREE_INT_CST_LOW (arg) == 0
1597: && TREE_INT_CST_HIGH (arg) == 0, 0));
1598:
1599: case TRUTH_AND_EXPR:
1600: return build (TRUTH_OR_EXPR, type,
1601: invert_truthvalue (TREE_OPERAND (arg, 0)),
1602: invert_truthvalue (TREE_OPERAND (arg, 1)));
1603:
1604: case TRUTH_OR_EXPR:
1605: return build (TRUTH_AND_EXPR, type,
1606: invert_truthvalue (TREE_OPERAND (arg, 0)),
1607: invert_truthvalue (TREE_OPERAND (arg, 1)));
1608:
1609: case TRUTH_ANDIF_EXPR:
1610: return build (TRUTH_ORIF_EXPR, type,
1611: invert_truthvalue (TREE_OPERAND (arg, 0)),
1612: invert_truthvalue (TREE_OPERAND (arg, 1)));
1613:
1614: case TRUTH_ORIF_EXPR:
1615: return build (TRUTH_ANDIF_EXPR, type,
1616: invert_truthvalue (TREE_OPERAND (arg, 0)),
1617: invert_truthvalue (TREE_OPERAND (arg, 1)));
1618:
1619: case TRUTH_NOT_EXPR:
1620: return TREE_OPERAND (arg, 0);
1621:
1622: case COND_EXPR:
1623: return build (COND_EXPR, type, TREE_OPERAND (arg, 0),
1624: invert_truthvalue (TREE_OPERAND (arg, 1)),
1625: invert_truthvalue (TREE_OPERAND (arg, 2)));
1626:
1627: case NON_LVALUE_EXPR:
1628: return invert_truthvalue (TREE_OPERAND (arg, 0));
1629:
1630: case NOP_EXPR:
1631: case CONVERT_EXPR:
1632: case FLOAT_EXPR:
1633: return build1 (TREE_CODE (arg), type,
1634: invert_truthvalue (TREE_OPERAND (arg, 0)));
1635:
1636: case BIT_AND_EXPR:
1637: if (! integer_onep (TREE_OPERAND (arg, 1)))
1638: abort ();
1639: return build (EQ_EXPR, type, arg, convert (type, integer_zero_node));
1640: }
1641:
1642: abort ();
1643: }
1644:
1645: /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
1646: operands are another bit-wise operation with a common input. If so,
1647: distribute the bit operations to save an operation and possibly two if
1648: constants are involved. For example, convert
1649: (A | B) & (A | C) into A | (B & C)
1650: Further simplification will occur if B and C are constants.
1651:
1652: If this optimization cannot be done, 0 will be returned. */
1653:
1654: static tree
1655: distribute_bit_expr (code, type, arg0, arg1)
1656: enum tree_code code;
1657: tree type;
1658: tree arg0, arg1;
1659: {
1660: tree common;
1661: tree left, right;
1662:
1663: if (TREE_CODE (arg0) != TREE_CODE (arg1)
1664: || TREE_CODE (arg0) == code
1665: || (TREE_CODE (arg0) != BIT_AND_EXPR
1666: && TREE_CODE (arg0) != BIT_IOR_EXPR))
1667: return 0;
1668:
1669: if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
1670: {
1671: common = TREE_OPERAND (arg0, 0);
1672: left = TREE_OPERAND (arg0, 1);
1673: right = TREE_OPERAND (arg1, 1);
1674: }
1675: else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
1676: {
1677: common = TREE_OPERAND (arg0, 0);
1678: left = TREE_OPERAND (arg0, 1);
1679: right = TREE_OPERAND (arg1, 0);
1680: }
1681: else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
1682: {
1683: common = TREE_OPERAND (arg0, 1);
1684: left = TREE_OPERAND (arg0, 0);
1685: right = TREE_OPERAND (arg1, 1);
1686: }
1687: else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
1688: {
1689: common = TREE_OPERAND (arg0, 1);
1690: left = TREE_OPERAND (arg0, 0);
1691: right = TREE_OPERAND (arg1, 0);
1692: }
1693: else
1694: return 0;
1695:
1696: return fold (build (TREE_CODE (arg0), type, common,
1697: fold (build (code, type, left, right))));
1698: }
1699:
1700: /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
1701: starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
1702:
1703: static tree
1704: make_bit_field_ref (inner, type, bitsize, bitpos, unsignedp)
1705: tree inner;
1706: tree type;
1707: int bitsize, bitpos;
1708: int unsignedp;
1709: {
1710: tree result = build (BIT_FIELD_REF, type, inner,
1711: size_int (bitsize), size_int (bitpos));
1712:
1713: TREE_UNSIGNED (result) = unsignedp;
1714:
1715: return result;
1716: }
1717:
1718: /* Optimize a bit-field compare.
1719:
1720: There are two cases: First is a compare against a constant and the
1721: second is a comparison of two items where the fields are at the same
1722: bit position relative to the start of a chunk (byte, halfword, word)
1723: large enough to contain it. In these cases we can avoid the shift
1724: implicit in bitfield extractions.
1725:
1726: For constants, we emit a compare of the shifted constant with the
1727: BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
1728: compared. For two fields at the same position, we do the ANDs with the
1729: similar mask and compare the result of the ANDs.
1730:
1731: CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
1732: COMPARE_TYPE is the type of the comparison, and LHS and RHS
1733: are the left and right operands of the comparison, respectively.
1734:
1735: If the optimization described above can be done, we return the resuling
1736: tree. Otherwise we return zero. */
1737:
1738: static tree
1739: optimize_bit_field_compare (code, compare_type, lhs, rhs)
1740: enum tree_code code;
1741: tree compare_type;
1742: tree lhs, rhs;
1743: {
1744: int lbitpos, lbitsize, rbitpos, rbitsize;
1745: int lnbitpos, lnbitsize, rnbitpos, rnbitsize;
1746: tree type = TREE_TYPE (lhs);
1747: tree signed_type, unsigned_type;
1748: int const_p = TREE_CODE (rhs) == INTEGER_CST;
1749: enum machine_mode lmode, rmode, lnmode, rnmode;
1750: int lunsignedp, runsignedp;
1751: int lvolatilep = 0, rvolatilep = 0;
1752: tree linner, rinner;
1753: tree mask;
1754:
1755: /* Get all the information about the extractions being done. If the bit size
1756: if the same as the size of the underlying object, we aren't doing an
1757: extraction at all and so can do nothing. */
1758: linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &lmode,
1759: &lunsignedp, &lvolatilep);
1760: if (lbitsize == GET_MODE_BITSIZE (lmode))
1761: return 0;
1762:
1763: if (!const_p)
1764: {
1765: /* If this is not a constant, we can only do something if bit positions,
1766: sizes, and signedness are the same. */
1767: rinner = get_inner_reference (rhs, &rbitsize, &rbitpos,
1768: &rmode, &runsignedp, &rvolatilep);
1769:
1770: if (lbitpos != rbitpos || lbitsize != rbitsize
1771: || lunsignedp != runsignedp)
1772: return 0;
1773: }
1774:
1775: /* See if we can find a mode to refer to this field. We should be able to,
1776: but fail if we can't. */
1777: lnmode = get_best_mode (lbitsize, lbitpos,
1778: TYPE_ALIGN (TREE_TYPE (linner)), word_mode,
1779: lvolatilep);
1780: if (lnmode == VOIDmode)
1781: return 0;
1782:
1783: /* Set signed and unsigned types of the precision of this mode for the
1784: shifts below. */
1785: signed_type = type_for_mode (lnmode, 0);
1786: unsigned_type = type_for_mode (lnmode, 1);
1787:
1788: if (! const_p)
1789: {
1790: rnmode = get_best_mode (rbitsize, rbitpos,
1791: TYPE_ALIGN (TREE_TYPE (rinner)), word_mode,
1792: rvolatilep);
1793: if (rnmode == VOIDmode)
1794: return 0;
1795: }
1796:
1797: /* Compute the bit position and size for the new reference and our offset
1798: within it. If the new reference is the same size as the original, we
1799: won't optimize anything, so return zero. */
1800: lnbitsize = GET_MODE_BITSIZE (lnmode);
1801: lnbitpos = lbitpos & ~ (lnbitsize - 1);
1802: lbitpos -= lnbitpos;
1803: if (lnbitsize == lbitsize)
1804: return 0;
1805:
1806: if (! const_p)
1807: {
1808: rnbitsize = GET_MODE_BITSIZE (rnmode);
1809: rnbitpos = rbitpos & ~ (rnbitsize - 1);
1810: rbitpos -= rnbitpos;
1811: if (rnbitsize == rbitsize)
1812: return 0;
1813: }
1814:
1815: #if BYTES_BIG_ENDIAN
1816: lbitpos = lnbitsize - lbitsize - lbitpos;
1817: rbitpos = rnbitsize - rbitsize - rbitpos;
1818: #endif
1819:
1820: /* Make the mask to be used against the extracted field. */
1821: mask = convert (unsigned_type, build_int_2 (~0, ~0));
1822: mask = const_binop (LSHIFT_EXPR, mask, size_int (lnbitsize - lbitsize));
1823: mask = const_binop (RSHIFT_EXPR, mask,
1824: size_int (lnbitsize - lbitsize - lbitpos));
1825:
1826: if (! const_p)
1827: /* If not comparing with constant, just rework the comparison
1828: and return. */
1829: return build (code, compare_type,
1830: build (BIT_AND_EXPR, type,
1831: make_bit_field_ref (linner, type,
1832: lnbitsize, lnbitpos, lunsignedp),
1833: mask),
1834: build (BIT_AND_EXPR, type,
1835: make_bit_field_ref (rinner, type,
1836: rnbitsize, rnbitpos, runsignedp),
1837: mask));
1838:
1839: /* Otherwise, we are handling the constant case. See if the constant is too
1840: big for the field. Warn and return a tree of for 0 (false) if so. We do
1841: this not only for its own sake, but to avoid having to test for this
1842: error case below. If we didn't, we might generate wrong code.
1843:
1844: For unsigned fields, the constant shifted right by the field length should
1845: be all zero. For signed fields, the high-order bits should agree with
1846: the sign bit. */
1847:
1848: if (lunsignedp)
1849: {
1850: if (! integer_zerop (const_binop (RSHIFT_EXPR,
1851: convert (unsigned_type, rhs),
1852: size_int (lbitsize))))
1853: {
1854: warning ("comparison is always %s due to width of bitfield",
1855: code == NE_EXPR ? "one" : "zero");
1856: return convert (compare_type,
1857: (code == NE_EXPR
1858: ? integer_one_node : integer_zero_node));
1859: }
1860: }
1861: else
1862: {
1863: tree tem = const_binop (RSHIFT_EXPR, convert (signed_type, rhs),
1864: size_int (lbitsize - 1));
1865: if (! integer_zerop (tem) && ! integer_all_onesp (tem))
1866: {
1867: warning ("comparison is always %s due to width of bitfield",
1868: code == NE_EXPR ? "one" : "zero");
1869: return convert (compare_type,
1870: (code == NE_EXPR
1871: ? integer_one_node : integer_zero_node));
1872: }
1873: }
1874:
1875: /* Single-bit compares should always be against zero. */
1876: if (lbitsize == 1 && ! integer_zerop (rhs))
1877: {
1878: code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
1879: rhs = convert (type, integer_zero_node);
1880: }
1881:
1882: /* Make a new bitfield reference, shift the constant over the
1883: appropriate number of bits and mask it with the computed mask
1884: (in case this was a signed field). If we changed it, make a new one. */
1885: lhs = make_bit_field_ref (linner, TREE_TYPE (lhs), lnbitsize, lnbitpos,
1886: lunsignedp);
1887:
1888: rhs = fold (build1 (NOP_EXPR, type,
1889: const_binop (BIT_AND_EXPR,
1890: const_binop (LSHIFT_EXPR,
1891: convert (unsigned_type, rhs),
1892: size_int (lbitpos)), mask)));
1893:
1894: return build (code, compare_type,
1895: build (BIT_AND_EXPR, type, lhs, mask),
1896: rhs);
1897: }
1898:
1899: /* Subroutine for the following routine: decode a field reference.
1900:
1901: If EXP is a comparison reference, we return the innermost reference.
1902:
1903: *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
1904: set to the starting bit number.
1905:
1906: If the innermost field can be completely contained in a mode-sized
1907: unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
1908:
1909: *PVOLATILEP is set to 1 if the any expression encountered is volatile;
1910: otherwise it is not changed.
1911:
1912: *PUNSIGNEDP is set to the signedness of the field.
1913:
1914: *PMASK is set to the mask used. This is either contained in a
1915: BIT_AND_EXPR or derived from the width of the field.
1916:
1917: Return 0 if this is not a component reference or is one that we can't
1918: do anything with. */
1919:
1920: static tree
1921: decode_field_reference (exp, pbitsize, pbitpos, pmode, punsignedp,
1922: pvolatilep, pmask)
1923: tree exp;
1924: int *pbitsize, *pbitpos;
1925: enum machine_mode *pmode;
1926: int *punsignedp, *pvolatilep;
1927: tree *pmask;
1928: {
1929: tree mask = 0;
1930: tree inner;
1931:
1932: STRIP_NOPS (exp);
1933:
1934: if (TREE_CODE (exp) == BIT_AND_EXPR)
1935: {
1936: mask = TREE_OPERAND (exp, 1);
1937: exp = TREE_OPERAND (exp, 0);
1938: STRIP_NOPS (exp); STRIP_NOPS (mask);
1939: if (TREE_CODE (mask) != INTEGER_CST)
1940: return 0;
1941: }
1942:
1943: if (TREE_CODE (exp) != COMPONENT_REF && TREE_CODE (exp) != ARRAY_REF
1944: && TREE_CODE (exp) != BIT_FIELD_REF)
1945: return 0;
1946:
1947: inner = get_inner_reference (exp, pbitsize, pbitpos, pmode,
1948: punsignedp, pvolatilep);
1949:
1950: if (mask == 0)
1951: {
1952: tree unsigned_type = type_for_size (*pbitsize, 1);
1953: int precision = TYPE_PRECISION (unsigned_type);
1954:
1955: mask = convert (unsigned_type, build_int_2 (~0, ~0));
1956: mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
1957: mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
1958: }
1959:
1960: *pmask = mask;
1961: return inner;
1962: }
1963:
1964: /* Return non-zero if MASK respresents a mask of SIZE ones in the low-order
1965: bit positions. */
1966:
1967: static int
1968: all_ones_mask_p (mask, size)
1969: tree mask;
1970: int size;
1971: {
1972: tree type = TREE_TYPE (mask);
1973: int precision = TYPE_PRECISION (type);
1974:
1975: return
1976: operand_equal_p (mask,
1977: const_binop (RSHIFT_EXPR,
1978: const_binop (LSHIFT_EXPR,
1979: convert (signed_type (type),
1980: build_int_2 (~0, ~0)),
1981: size_int (precision - size)),
1982: size_int (precision - size)), 0);
1983: }
1984:
1985: /* Try to merge two comparisons to the same innermost item.
1986:
1987: For example, if we have p->a == 2 && p->b == 4 and we can make an
1988: object large enough to span both A and B, we can do this with a comparison
1989: against the object ANDed with the a mask.
1990:
1991: If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
1992: operations to do this with one comparison.
1993:
1994: We check for both normal comparisons and the BIT_AND_EXPRs made this by
1995: function and the one above.
1996:
1997: CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
1998: TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
1999:
2000: TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
2001: two operands.
2002:
2003: We return the simplified tree or 0 if no optimization is possible. */
2004:
2005: static tree
2006: merge_component_references (code, truth_type, lhs, rhs)
2007: enum tree_code code;
2008: tree truth_type, lhs, rhs;
2009: {
2010: /* If this is the "or" of two comparisons, we can do something if we
2011: the comparisons are NE_EXPR. If this is the "and", we can do something
2012: if the comparisons are EQ_EXPR. I.e.,
2013: (a->b == 2 && a->c == 4) can become (a->new == NEW).
2014:
2015: WANTED_CODE is this operation code. For single bit fields, we can
2016: convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
2017: comparison for one-bit fields. */
2018:
2019: enum tree_code wanted_code
2020: = (code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR) ? EQ_EXPR : NE_EXPR;
2021: enum tree_code lcode, rcode;
2022: tree ll_inner, lr_inner, rl_inner, rr_inner;
2023: int ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
2024: int rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
2025: int xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
2026: int lnbitsize, lnbitpos, rnbitsize, rnbitpos;
2027: int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
2028: enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
2029: enum machine_mode lnmode, rnmode;
2030: tree ll_mask, lr_mask, rl_mask, rr_mask;
2031: tree l_const = 0, r_const = 0;
2032: tree type, result;
2033: int first_bit, end_bit;
2034: int volatilep = 0;
2035:
2036: /* Start by getting the comparison codes and seeing if we may be able
2037: to do something. Then get all the parameters for each side. Fail
2038: if anything is volatile. */
2039:
2040: lcode = TREE_CODE (lhs);
2041: rcode = TREE_CODE (rhs);
2042: if ((lcode != EQ_EXPR && lcode != NE_EXPR)
2043: || (rcode != EQ_EXPR && rcode != NE_EXPR)
2044: || TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
2045: return 0;
2046:
2047: ll_inner = decode_field_reference (TREE_OPERAND (lhs, 0),
2048: &ll_bitsize, &ll_bitpos, &ll_mode,
2049: &ll_unsignedp, &volatilep, &ll_mask);
2050: lr_inner = decode_field_reference (TREE_OPERAND (lhs, 1),
2051: &lr_bitsize, &lr_bitpos, &lr_mode,
2052: &lr_unsignedp, &volatilep, &lr_mask);
2053: rl_inner = decode_field_reference (TREE_OPERAND (rhs, 0),
2054: &rl_bitsize, &rl_bitpos, &rl_mode,
2055: &rl_unsignedp, &volatilep, &rl_mask);
2056: rr_inner = decode_field_reference (TREE_OPERAND (rhs, 1),
2057: &rr_bitsize, &rr_bitpos, &rr_mode,
2058: &rr_unsignedp, &volatilep, &rr_mask);
2059:
2060: /* It must be true that the inner operation on the lhs of each
2061: comparison must be the same if we are to be able to do anything.
2062: Then see if we have constants. If not, the same must be true for
2063: the rhs's. */
2064: if (volatilep || ll_inner == 0 || rl_inner == 0
2065: || ! operand_equal_p (ll_inner, rl_inner, 0))
2066: return 0;
2067:
2068: if (TREE_CODE (TREE_OPERAND (lhs, 1)) == INTEGER_CST
2069: && TREE_CODE (TREE_OPERAND (rhs, 1)) == INTEGER_CST)
2070: l_const = TREE_OPERAND (lhs, 1), r_const = TREE_OPERAND (rhs, 1);
2071: else if (lr_inner == 0 || rr_inner == 0
2072: || ! operand_equal_p (lr_inner, rr_inner, 0))
2073: return 0;
2074:
2075: /* If either comparison code is not correct for our logical operation,
2076: fail. However, we can convert a one-bit comparison against zero into
2077: the opposite comparison against that bit being set in the field. */
2078: if (lcode != wanted_code)
2079: {
2080: if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
2081: l_const = ll_mask;
2082: else
2083: return 0;
2084: }
2085:
2086: if (rcode != wanted_code)
2087: {
2088: if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
2089: r_const = rl_mask;
2090: else
2091: return 0;
2092: }
2093:
2094: /* See if we can find a mode that contains both fields being compared on
2095: the left. If we can't, fail. Otherwise, update all constants and masks
2096: to be relative to a field of that size. */
2097: first_bit = MIN (ll_bitpos, rl_bitpos);
2098: end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
2099: lnmode = get_best_mode (end_bit - first_bit, first_bit,
2100: TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
2101: volatilep);
2102: if (lnmode == VOIDmode)
2103: return 0;
2104:
2105: lnbitsize = GET_MODE_BITSIZE (lnmode);
2106: lnbitpos = first_bit & ~ (lnbitsize - 1);
2107: type = type_for_size (lnbitsize, 1);
2108: xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
2109:
2110: #if BYTES_BIG_ENDIAN
2111: xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
2112: xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
2113: #endif
2114:
2115: ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
2116: size_int (xll_bitpos));
2117: rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
2118: size_int (xrl_bitpos));
2119:
2120: /* Make sure the constants are interpreted as unsigned, so we
2121: don't have sign bits outside the range of their type. */
2122:
2123: if (l_const)
2124: {
2125: l_const = convert (unsigned_type (TREE_TYPE (l_const)), l_const);
2126: l_const = const_binop (LSHIFT_EXPR, convert (type, l_const),
2127: size_int (xll_bitpos));
2128: }
2129: if (r_const)
2130: {
2131: r_const = convert (unsigned_type (TREE_TYPE (r_const)), r_const);
2132: r_const = const_binop (LSHIFT_EXPR, convert (type, r_const),
2133: size_int (xrl_bitpos));
2134: }
2135:
2136: /* If the right sides are not constant, do the same for it. Also,
2137: disallow this optimization if a size or signedness mismatch occurs
2138: between the left and right sides. */
2139: if (l_const == 0)
2140: {
2141: if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
2142: || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp)
2143: return 0;
2144:
2145: first_bit = MIN (lr_bitpos, rr_bitpos);
2146: end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
2147: rnmode = get_best_mode (end_bit - first_bit, first_bit,
2148: TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
2149: volatilep);
2150: if (rnmode == VOIDmode)
2151: return 0;
2152:
2153: rnbitsize = GET_MODE_BITSIZE (rnmode);
2154: rnbitpos = first_bit & ~ (rnbitsize - 1);
2155: xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
2156:
2157: #if BYTES_BIG_ENDIAN
2158: xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
2159: xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
2160: #endif
2161:
2162: lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
2163: size_int (xlr_bitpos));
2164: rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
2165: size_int (xrr_bitpos));
2166:
2167: /* Make a mask that corresponds to both fields being compared.
2168: Do this for both items being compared. If the masks agree,
2169: we can do this by masking both and comparing the masked
2170: results. */
2171: ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
2172: lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
2173: if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
2174: {
2175: lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
2176: ll_unsignedp || rl_unsignedp);
2177: rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
2178: lr_unsignedp || rr_unsignedp);
2179: if (! all_ones_mask_p (ll_mask, lnbitsize))
2180: {
2181: lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
2182: rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
2183: }
2184: return build (wanted_code, truth_type, lhs, rhs);
2185: }
2186:
2187: /* There is still another way we can do something: If both pairs of
2188: fields being compared are adjacent, we may be able to make a wider
2189: field containing them both. */
2190: if ((ll_bitsize + ll_bitpos == rl_bitpos
2191: && lr_bitsize + lr_bitpos == rr_bitpos)
2192: || (ll_bitpos == rl_bitpos + rl_bitsize
2193: && lr_bitpos == rr_bitpos + rr_bitsize))
2194: return build (wanted_code, truth_type,
2195: make_bit_field_ref (ll_inner, type,
2196: ll_bitsize + rl_bitsize,
2197: MIN (ll_bitpos, rl_bitpos),
2198: ll_unsignedp),
2199: make_bit_field_ref (lr_inner, type,
2200: lr_bitsize + rr_bitsize,
2201: MIN (lr_bitpos, rr_bitpos),
2202: lr_unsignedp));
2203:
2204: return 0;
2205: }
2206:
2207: /* Handle the case of comparisons with constants. If there is something in
2208: common between the masks, those bits of the constants must be the same.
2209: If not, the condition is always false. Test for this to avoid generating
2210: incorrect code below. */
2211: result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
2212: if (! integer_zerop (result)
2213: && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
2214: const_binop (BIT_AND_EXPR, result, r_const)) != 1)
2215: {
2216: if (wanted_code == NE_EXPR)
2217: {
2218: warning ("`or' of unmatched not-equal tests is always 1");
2219: return convert (truth_type, integer_one_node);
2220: }
2221: else
2222: {
2223: warning ("`and' of mutually exclusive equal-tests is always zero");
2224: return convert (truth_type, integer_zero_node);
2225: }
2226: }
2227:
2228: /* Construct the expression we will return. First get the component
2229: reference we will make. Unless the mask is all ones the width of
2230: that field, perform the mask operation. Then compare with the
2231: merged constant. */
2232: result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
2233: ll_unsignedp || rl_unsignedp);
2234:
2235: ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
2236: if (! all_ones_mask_p (ll_mask, lnbitsize))
2237: result = build (BIT_AND_EXPR, type, result, ll_mask);
2238:
2239: return build (wanted_code, truth_type, result,
2240: const_binop (BIT_IOR_EXPR, l_const, r_const));
2241: }
2242:
2243: /* Perform constant folding and related simplification of EXPR.
2244: The related simplifications include x*1 => x, x*0 => 0, etc.,
2245: and application of the associative law.
2246: NOP_EXPR conversions may be removed freely (as long as we
2247: are careful not to change the C type of the overall expression)
2248: We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
2249: but we can constant-fold them if they have constant operands. */
2250:
2251: tree
2252: fold (expr)
2253: tree expr;
2254: {
2255: register tree t = expr;
2256: tree t1 = NULL_TREE;
2257: tree type = TREE_TYPE (expr);
2258: register tree arg0, arg1;
2259: register enum tree_code code = TREE_CODE (t);
2260: register int kind;
2261:
2262: /* WINS will be nonzero when the switch is done
2263: if all operands are constant. */
2264:
2265: int wins = 1;
2266:
2267: /* Return right away if already constant. */
2268: if (TREE_CONSTANT (t))
2269: {
2270: if (code == CONST_DECL)
2271: return DECL_INITIAL (t);
2272: return t;
2273: }
2274:
2275: kind = TREE_CODE_CLASS (code);
2276: if (kind == 'e' || kind == '<' || kind == '1' || kind == '2' || kind == 'r')
2277: {
2278: register int len = tree_code_length[(int) code];
2279: register int i;
2280: for (i = 0; i < len; i++)
2281: {
2282: tree op = TREE_OPERAND (t, i);
2283:
2284: if (op == 0)
2285: continue; /* Valid for CALL_EXPR, at least. */
2286:
2287: /* Strip any conversions that don't change the mode. */
2288: STRIP_NOPS (op);
2289:
2290: if (TREE_CODE (op) != INTEGER_CST
2291: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2292: && TREE_CODE (op) != REAL_CST
2293: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2294: )
2295: /* Note that TREE_CONSTANT isn't enough:
2296: static var addresses are constant but we can't
2297: do arithmetic on them. */
2298: wins = 0;
2299:
2300: if (i == 0)
2301: arg0 = op;
2302: else if (i == 1)
2303: arg1 = op;
2304: }
2305: }
2306:
2307: /* If this is a commutative operation, and ARG0 is a constant, move it
2308: to ARG1 to reduce the number of tests below. */
2309: if ((code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
2310: || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
2311: || code == BIT_AND_EXPR)
2312: && (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST))
2313: {
2314: tree tem = arg0;
2315: arg0 = arg1; arg1 = tem;
2316:
2317: TREE_OPERAND (t, 0) = arg0;
2318: TREE_OPERAND (t, 1) = arg1;
2319: }
2320:
2321: /* Now WINS is set as described above,
2322: ARG0 is the first operand of EXPR,
2323: and ARG1 is the second operand (if it has more than one operand).
2324:
2325: First check for cases where an arithmetic operation is applied to a
2326: compound, conditional, or comparison operation. Push the arithmetic
2327: operation inside the compound or conditional to see if any folding
2328: can then be done. Convert comparison to conditional for this purpose.
2329: The also optimizes non-constant cases that used to be done in
2330: expand_expr. */
2331: if (TREE_CODE_CLASS (code) == '1')
2332: {
2333: if (TREE_CODE (arg0) == COMPOUND_EXPR)
2334: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
2335: fold (build1 (code, type, TREE_OPERAND (arg0, 1))));
2336: else if (TREE_CODE (arg0) == COND_EXPR)
2337: return fold (build (COND_EXPR, type, TREE_OPERAND (arg0, 0),
2338: fold (build1 (code, type, TREE_OPERAND (arg0, 1))),
2339: fold (build1 (code, type, TREE_OPERAND (arg0, 2)))));
2340: else if (TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
2341: return fold (build (COND_EXPR, type, arg0,
2342: fold (build1 (code, type, integer_one_node)),
2343: fold (build1 (code, type, integer_zero_node))));
2344: }
2345: else if (TREE_CODE_CLASS (code) == '2')
2346: {
2347: if (TREE_CODE (arg1) == COMPOUND_EXPR)
2348: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
2349: fold (build (code, type, arg0, TREE_OPERAND (arg1, 1))));
2350: else if (TREE_CODE (arg1) == COND_EXPR
2351: || TREE_CODE_CLASS (TREE_CODE (arg1)) == '<')
2352: {
2353: tree test, true_value, false_value;
2354:
2355: if (TREE_CODE (arg1) == COND_EXPR)
2356: {
2357: test = TREE_OPERAND (arg1, 0);
2358: true_value = TREE_OPERAND (arg1, 1);
2359: false_value = TREE_OPERAND (arg1, 2);
2360: }
2361: else
2362: {
2363: test = arg1;
2364: true_value = integer_one_node;
2365: false_value = integer_zero_node;
2366: }
2367:
2368: if (TREE_CODE (arg0) != VAR_DECL && TREE_CODE (arg0) != PARM_DECL)
2369: arg0 = save_expr (arg0);
2370: test = fold (build (COND_EXPR, type, test,
2371: fold (build (code, type, arg0, true_value)),
2372: fold (build (code, type, arg0, false_value))));
2373: if (TREE_CODE (arg0) == SAVE_EXPR)
2374: return build (COMPOUND_EXPR, type,
2375: convert (void_type_node, arg0), test);
2376: else
2377: return convert (type, test);
2378: }
2379:
2380: else if (TREE_CODE (arg0) == COMPOUND_EXPR)
2381: return build (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
2382: fold (build (code, type, TREE_OPERAND (arg0, 1), arg1)));
2383: else if (TREE_CODE (arg0) == COND_EXPR
2384: || TREE_CODE_CLASS (TREE_CODE (arg0)) == '<')
2385: {
2386: tree test, true_value, false_value;
2387:
2388: if (TREE_CODE (arg0) == COND_EXPR)
2389: {
2390: test = TREE_OPERAND (arg0, 0);
2391: true_value = TREE_OPERAND (arg0, 1);
2392: false_value = TREE_OPERAND (arg0, 2);
2393: }
2394: else
2395: {
2396: test = arg0;
2397: true_value = integer_one_node;
2398: false_value = integer_zero_node;
2399: }
2400:
2401: if (TREE_CODE (arg1) != VAR_DECL && TREE_CODE (arg1) != PARM_DECL)
2402: arg1 = save_expr (arg1);
2403: test = fold (build (COND_EXPR, type, test,
2404: fold (build (code, type, true_value, arg1)),
2405: fold (build (code, type, false_value, arg1))));
2406: if (TREE_CODE (arg1) == SAVE_EXPR)
2407: return build (COMPOUND_EXPR, type,
2408: convert (void_type_node, arg1), test);
2409: else
2410: return convert (type, test);
2411: }
2412: }
2413:
2414: switch (code)
2415: {
2416: case INTEGER_CST:
2417: case REAL_CST:
2418: case STRING_CST:
2419: case COMPLEX_CST:
2420: case CONSTRUCTOR:
2421: return t;
2422:
2423: case CONST_DECL:
2424: return fold (DECL_INITIAL (t));
2425:
2426: case NOP_EXPR:
2427: case FLOAT_EXPR:
2428: case CONVERT_EXPR:
2429: case FIX_TRUNC_EXPR:
2430: /* Other kinds of FIX are not handled properly by fold_convert. */
2431: /* Two conversions in a row are not needed unless:
2432: - the intermediate type is narrower than both initial and final, or
2433: - the initial type is a pointer type and the precisions of the
2434: intermediate and final types differ, or
2435: - the final type is a pointer type and the precisions of the
2436: initial and intermediate types differ. */
2437: if ((TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
2438: || TREE_CODE (TREE_OPERAND (t, 0)) == CONVERT_EXPR)
2439: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
2440: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
2441: ||
2442: TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
2443: > TYPE_PRECISION (TREE_TYPE (t)))
2444: && ((TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t, 0)))
2445: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
2446: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))))
2447: ==
2448: (TREE_UNSIGNED (TREE_TYPE (t))
2449: && (TYPE_PRECISION (TREE_TYPE (t))
2450: > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0))))))
2451: && ! ((TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
2452: == POINTER_TYPE)
2453: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0)))
2454: != TYPE_PRECISION (TREE_TYPE (t))))
2455: && ! (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE
2456: && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
2457: != TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t, 0))))))
2458: return convert (TREE_TYPE (t), TREE_OPERAND (TREE_OPERAND (t, 0), 0));
2459:
2460: if (TREE_CODE (TREE_OPERAND (t, 0)) == MODIFY_EXPR
2461: && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t, 0), 1)))
2462: {
2463: /* Don't leave an assignment inside a conversion. */
2464: tree prev = TREE_OPERAND (t, 0);
2465: TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
2466: /* First do the assignment, then return converted constant. */
2467: t = build (COMPOUND_EXPR, TREE_TYPE (t), prev, fold (t));
2468: TREE_USED (t) = 1;
2469: return t;
2470: }
2471: if (!wins)
2472: {
2473: TREE_CONSTANT (t) = TREE_CONSTANT (arg0);
2474: return t;
2475: }
2476: return fold_convert (t, arg0);
2477:
2478: #if 0 /* This loses on &"foo"[0]. */
2479: case ARRAY_REF:
2480: {
2481: int i;
2482:
2483: /* Fold an expression like: "foo"[2] */
2484: if (TREE_CODE (arg0) == STRING_CST
2485: && TREE_CODE (arg1) == INTEGER_CST
2486: && !TREE_INT_CST_HIGH (arg1)
2487: && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
2488: {
2489: t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
2490: TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
2491: force_fit_type (t);
2492: }
2493: }
2494: return t;
2495: #endif /* 0 */
2496:
2497: case RANGE_EXPR:
2498: TREE_CONSTANT (t) = wins;
2499: return t;
2500:
2501: case NEGATE_EXPR:
2502: if (wins)
2503: {
2504: if (TREE_CODE (arg0) == INTEGER_CST)
2505: {
2506: if (TREE_INT_CST_LOW (arg0) == 0)
2507: t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
2508: else
2509: t = build_int_2 (- TREE_INT_CST_LOW (arg0),
2510: ~ TREE_INT_CST_HIGH (arg0));
2511: TREE_TYPE (t) = type;
2512: force_fit_type (t);
2513: }
2514: else if (TREE_CODE (arg0) == REAL_CST)
2515: t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
2516: TREE_TYPE (t) = type;
2517: }
2518: else if (TREE_CODE (arg0) == NEGATE_EXPR)
2519: return TREE_OPERAND (arg0, 0);
2520:
2521: /* Convert - (a - b) to (b - a) for non-floating-point. */
2522: else if (TREE_CODE (arg0) == MINUS_EXPR && TREE_CODE (type) != REAL_TYPE)
2523: return build (MINUS_EXPR, type, TREE_OPERAND (arg0, 1),
2524: TREE_OPERAND (arg0, 0));
2525:
2526: return t;
2527:
2528: case ABS_EXPR:
2529: if (wins)
2530: {
2531: if (TREE_CODE (arg0) == INTEGER_CST)
2532: {
2533: if (! TREE_UNSIGNED (type)
2534: && TREE_INT_CST_HIGH (arg0) < 0)
2535: {
2536: if (TREE_INT_CST_LOW (arg0) == 0)
2537: t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
2538: else
2539: t = build_int_2 (- TREE_INT_CST_LOW (arg0),
2540: ~ TREE_INT_CST_HIGH (arg0));
2541: }
2542: }
2543: else if (TREE_CODE (arg0) == REAL_CST)
2544: {
2545: if (REAL_VALUES_LESS (TREE_REAL_CST (arg0), dconst0))
2546: t = build_real (type,
2547: REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
2548: }
2549: TREE_TYPE (t) = type;
2550: }
2551: else if (TREE_CODE (arg0) == ABS_EXPR || TREE_CODE (arg0) == NEGATE_EXPR)
2552: return build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
2553: return t;
2554:
2555: case BIT_NOT_EXPR:
2556: if (wins)
2557: {
2558: if (TREE_CODE (arg0) == INTEGER_CST)
2559: t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
2560: ~ TREE_INT_CST_HIGH (arg0));
2561: TREE_TYPE (t) = type;
2562: force_fit_type (t);
2563: }
2564: else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
2565: return TREE_OPERAND (arg0, 0);
2566: return t;
2567:
2568: case PLUS_EXPR:
2569: /* A + (-B) -> A - B */
2570: if (TREE_CODE (arg1) == NEGATE_EXPR)
2571: return fold (build (MINUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
2572: else if (TREE_CODE (type) != REAL_TYPE)
2573: {
2574: if (integer_zerop (arg1))
2575: return non_lvalue (convert (type, arg0));
2576:
2577: /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
2578: with a constant, and the two constants have no bits in common,
2579: we should treat this as a BIT_IOR_EXPR since this may produce more
2580: simplifications. */
2581: if (TREE_CODE (arg0) == BIT_AND_EXPR
2582: && TREE_CODE (arg1) == BIT_AND_EXPR
2583: && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
2584: && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
2585: && integer_zerop (const_binop (BIT_AND_EXPR,
2586: TREE_OPERAND (arg0, 1),
2587: TREE_OPERAND (arg1, 1))))
2588: {
2589: code = BIT_IOR_EXPR;
2590: goto bit_ior;
2591: }
2592: }
2593: /* In IEEE floating point, x+0 may not equal x. */
2594: else if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
2595: && real_zerop (arg1))
2596: return non_lvalue (convert (type, arg0));
2597: associate:
2598: /* In most languages, can't associate operations on floats
2599: through parentheses. Rather than remember where the parentheses
2600: were, we don't associate floats at all. It shouldn't matter much. */
2601: if (TREE_CODE (type) == REAL_TYPE)
2602: goto binary;
2603: /* The varsign == -1 cases happen only for addition and subtraction.
2604: It says that the arg that was split was really CON minus VAR.
2605: The rest of the code applies to all associative operations. */
2606: if (!wins)
2607: {
2608: tree var, con, tem;
2609: int varsign;
2610:
2611: if (split_tree (arg0, code, &var, &con, &varsign))
2612: {
2613: if (varsign == -1)
2614: {
2615: /* EXPR is (CON-VAR) +- ARG1. */
2616: /* If it is + and VAR==ARG1, return just CONST. */
2617: if (code == PLUS_EXPR && operand_equal_p (var, arg1, 0))
2618: return convert (TREE_TYPE (t), con);
2619:
2620: /* Otherwise return (CON +- ARG1) - VAR. */
2621: TREE_SET_CODE (t, MINUS_EXPR);
2622: TREE_OPERAND (t, 1) = var;
2623: TREE_OPERAND (t, 0)
2624: = fold (build (code, TREE_TYPE (t), con, arg1));
2625: }
2626: else
2627: {
2628: /* EXPR is (VAR+CON) +- ARG1. */
2629: /* If it is - and VAR==ARG1, return just CONST. */
2630: if (code == MINUS_EXPR && operand_equal_p (var, arg1, 0))
2631: return convert (TREE_TYPE (t), con);
2632:
2633: /* Otherwise return VAR +- (ARG1 +- CON). */
2634: TREE_OPERAND (t, 1) = tem
2635: = fold (build (code, TREE_TYPE (t), arg1, con));
2636: TREE_OPERAND (t, 0) = var;
2637: if (integer_zerop (tem)
2638: && (code == PLUS_EXPR || code == MINUS_EXPR))
2639: return convert (type, var);
2640: /* If we have x +/- (c - d) [c an explicit integer]
2641: change it to x -/+ (d - c) since if d is relocatable
2642: then the latter can be a single immediate insn
2643: and the former cannot. */
2644: if (TREE_CODE (tem) == MINUS_EXPR
2645: && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
2646: {
2647: tree tem1 = TREE_OPERAND (tem, 1);
2648: TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
2649: TREE_OPERAND (tem, 0) = tem1;
2650: TREE_SET_CODE (t,
2651: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
2652: }
2653: }
2654: return t;
2655: }
2656:
2657: if (split_tree (arg1, code, &var, &con, &varsign))
2658: {
2659: /* EXPR is ARG0 +- (CON +- VAR). */
2660: if (varsign == -1)
2661: TREE_SET_CODE (t,
2662: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
2663: if (TREE_CODE (t) == MINUS_EXPR
2664: && operand_equal_p (var, arg0, 0))
2665: {
2666: /* If VAR and ARG0 cancel, return just CON or -CON. */
2667: if (code == PLUS_EXPR)
2668: return convert (TREE_TYPE (t), con);
2669: return fold (build1 (NEGATE_EXPR, TREE_TYPE (t),
2670: convert (TREE_TYPE (t), con)));
2671: }
2672: TREE_OPERAND (t, 0)
2673: = fold (build (code, TREE_TYPE (t), arg0, con));
2674: TREE_OPERAND (t, 1) = var;
2675: if (integer_zerop (TREE_OPERAND (t, 0))
2676: && TREE_CODE (t) == PLUS_EXPR)
2677: return convert (TREE_TYPE (t), var);
2678: return t;
2679: }
2680: }
2681: binary:
2682: #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
2683: if (TREE_CODE (arg1) == REAL_CST)
2684: return t;
2685: #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
2686: if (wins)
2687: t1 = const_binop (code, arg0, arg1);
2688: if (t1 != NULL_TREE)
2689: {
2690: /* The return value should always have
2691: the same type as the original expression. */
2692: TREE_TYPE (t1) = TREE_TYPE (t);
2693: return t1;
2694: }
2695: return t;
2696:
2697: case MINUS_EXPR:
2698: if (TREE_CODE (type) != REAL_TYPE)
2699: {
2700: if (! wins && integer_zerop (arg0))
2701: return build1 (NEGATE_EXPR, type, arg1);
2702: if (integer_zerop (arg1))
2703: return non_lvalue (convert (type, arg0));
2704: }
2705: /* Convert A - (-B) to A + B. */
2706: else if (TREE_CODE (arg1) == NEGATE_EXPR)
2707: return fold (build (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0)));
2708: else
2709: {
2710: if (! wins && real_zerop (arg0))
2711: return build1 (NEGATE_EXPR, type, arg1);
2712: /* In IEEE floating point, x-0 may not equal x. */
2713: if (real_zerop (arg1) && TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
2714: return non_lvalue (convert (type, arg0));
2715: }
2716: /* Fold &x - &x. This can happen from &x.foo - &x.
2717: Note that can't be done for certain floats even in non-IEEE formats.
2718: Also note that operand_equal_p is always false is an operand
2719: is volatile. */
2720:
2721: if (operand_equal_p (arg0, arg1,
2722: TREE_CODE (type) == REAL_TYPE))
2723: return convert (type, integer_zero_node);
2724: goto associate;
2725:
2726: case MULT_EXPR:
2727: if (TREE_CODE (type) != REAL_TYPE)
2728: {
2729: if (integer_zerop (arg1))
2730: return omit_one_operand (type, arg1, arg0);
2731: if (integer_onep (arg1))
2732: return non_lvalue (convert (type, arg0));
2733:
2734: /* (a * (1 << b)) is (a << b) */
2735: if (TREE_CODE (arg1) == LSHIFT_EXPR
2736: && integer_onep (TREE_OPERAND (arg1, 0)))
2737: return fold (build (LSHIFT_EXPR, type, arg0,
2738: TREE_OPERAND (arg1, 1)));
2739: if (TREE_CODE (arg0) == LSHIFT_EXPR
2740: && integer_onep (TREE_OPERAND (arg0, 0)))
2741: return fold (build (LSHIFT_EXPR, type, arg1,
2742: TREE_OPERAND (arg0, 1)));
2743: }
2744: /* In IEEE floating point, these optimizations are not correct. */
2745: else
2746: {
2747: if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
2748: && real_zerop (arg1))
2749: return omit_one_operand (type, arg1, arg0);
2750: /* In IEEE floating point, x*1 is not equivalent to x for nans.
2751: However, ANSI says we can drop signals,
2752: so we can do this anyway. */
2753: if (real_onep (arg1))
2754: return non_lvalue (convert (type, arg0));
2755: /* x*2 is x+x */
2756: if (! wins && real_twop (arg1))
2757: {
2758: tree arg = save_expr (arg0);
2759: return build (PLUS_EXPR, type, arg, arg);
2760: }
2761: }
2762: goto associate;
2763:
2764: case BIT_IOR_EXPR:
2765: bit_ior:
2766: if (integer_all_onesp (arg1))
2767: return omit_one_operand (type, arg1, arg0);
2768: if (integer_zerop (arg1))
2769: return non_lvalue (convert (type, arg0));
2770: t1 = distribute_bit_expr (code, type, arg0, arg1);
2771: if (t1 != NULL_TREE)
2772: return t1;
2773: goto associate;
2774:
2775: case BIT_XOR_EXPR:
2776: if (integer_zerop (arg1))
2777: return non_lvalue (convert (type, arg0));
2778: if (integer_all_onesp (arg1))
2779: return fold (build1 (BIT_NOT_EXPR, type, arg0));
2780: goto associate;
2781:
2782: case BIT_AND_EXPR:
2783: bit_and:
2784: if (integer_all_onesp (arg1))
2785: return non_lvalue (convert (type, arg0));
2786: if (integer_zerop (arg1))
2787: return omit_one_operand (type, arg1, arg0);
2788: t1 = distribute_bit_expr (code, type, arg0, arg1);
2789: if (t1 != NULL_TREE)
2790: return t1;
2791: /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
2792: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
2793: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
2794: {
2795: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
2796: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
2797: && (~TREE_INT_CST_LOW (arg0) & ((1 << prec) - 1)) == 0)
2798: return build1 (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
2799: }
2800: if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
2801: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
2802: {
2803: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
2804: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
2805: && (~TREE_INT_CST_LOW (arg1) & ((1 << prec) - 1)) == 0)
2806: return build1 (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
2807: }
2808: goto associate;
2809:
2810: case BIT_ANDTC_EXPR:
2811: if (integer_all_onesp (arg0))
2812: return non_lvalue (convert (type, arg1));
2813: if (integer_zerop (arg0))
2814: return omit_one_operand (type, arg0, arg1);
2815: if (TREE_CODE (arg1) == INTEGER_CST)
2816: {
2817: arg1 = fold (build1 (BIT_NOT_EXPR, type, arg1));
2818: code = BIT_AND_EXPR;
2819: goto bit_and;
2820: }
2821: goto binary;
2822:
2823: case TRUNC_DIV_EXPR:
2824: case ROUND_DIV_EXPR:
2825: case FLOOR_DIV_EXPR:
2826: case CEIL_DIV_EXPR:
2827: case EXACT_DIV_EXPR:
2828: case RDIV_EXPR:
2829: if (integer_onep (arg1))
2830: return non_lvalue (convert (type, arg0));
2831: if (integer_zerop (arg1))
2832: return t;
2833: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2834: #ifndef REAL_INFINITY
2835: if (TREE_CODE (arg1) == REAL_CST
2836: && real_zerop (arg1))
2837: return t;
2838: #endif
2839: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2840:
2841: goto binary;
2842:
2843: case CEIL_MOD_EXPR:
2844: case FLOOR_MOD_EXPR:
2845: case ROUND_MOD_EXPR:
2846: case TRUNC_MOD_EXPR:
2847: if (integer_onep (arg1))
2848: return omit_one_operand (type, integer_zero_node, arg0);
2849: if (integer_zerop (arg1))
2850: return t;
2851: goto binary;
2852:
2853: case LSHIFT_EXPR:
2854: case RSHIFT_EXPR:
2855: case LROTATE_EXPR:
2856: case RROTATE_EXPR:
2857: if (integer_zerop (arg1))
2858: return non_lvalue (convert (type, arg0));
2859: /* Since negative shift count is not well-defined,
2860: don't try to compute it in the compiler. */
2861: if (tree_int_cst_lt (arg1, integer_zero_node))
2862: return t;
2863: goto binary;
2864:
2865: case MIN_EXPR:
2866: if (operand_equal_p (arg0, arg1, 0))
2867: return arg0;
2868: if (TREE_CODE (type) == INTEGER_TYPE
2869: && operand_equal_p (arg1, TYPE_MIN_VALUE (type), 1))
2870: return omit_one_operand (type, arg1, arg0);
2871: goto associate;
2872:
2873: case MAX_EXPR:
2874: if (operand_equal_p (arg0, arg1, 0))
2875: return arg0;
2876: if (TREE_CODE (type) == INTEGER_TYPE
2877: && operand_equal_p (arg1, TYPE_MAX_VALUE (type), 1))
2878: return omit_one_operand (type, arg1, arg0);
2879: goto associate;
2880:
2881: case TRUTH_NOT_EXPR:
2882: /* Note that the operand of this must be an int
2883: and its values must be 0 or 1.
2884: ("true" is a fixed value perhaps depending on the language,
2885: but we don't handle values other than 1 correctly yet.) */
2886: return invert_truthvalue (arg0);
2887:
2888: case TRUTH_ANDIF_EXPR:
2889: /* Note that the operands of this must be ints
2890: and their values must be 0 or 1.
2891: ("true" is a fixed value perhaps depending on the language.) */
2892: /* If first arg is constant zero, return it. */
2893: if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
2894: return arg0;
2895: case TRUTH_AND_EXPR:
2896: /* If either arg is constant true, drop it. */
2897: if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
2898: return non_lvalue (arg1);
2899: if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
2900: return non_lvalue (arg0);
2901: /* Both known to be zero => return zero. */
2902: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2903: return arg0;
2904:
2905: truth_andor:
2906: /* Check for the possibility of merging component references. If our
2907: lhs is another similar operation, try to merge its rhs with our
2908: rhs. Then try to merge our lhs and rhs. */
2909: if (optimize)
2910: {
2911: tree tem;
2912:
2913: if (TREE_CODE (arg0) == code)
2914: {
2915: tem = merge_component_references (code, type,
2916: TREE_OPERAND (arg0, 1), arg1);
2917: if (tem)
2918: return fold (build (code, type, TREE_OPERAND (arg0, 0), tem));
2919: }
2920:
2921: tem = merge_component_references (code, type, arg0, arg1);
2922: if (tem)
2923: return tem;
2924: }
2925: return t;
2926:
2927: case TRUTH_ORIF_EXPR:
2928: /* Note that the operands of this must be ints
2929: and their values must be 0 or true.
2930: ("true" is a fixed value perhaps depending on the language.) */
2931: /* If first arg is constant true, return it. */
2932: if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
2933: return arg0;
2934: case TRUTH_OR_EXPR:
2935: /* If either arg is constant zero, drop it. */
2936: if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
2937: return non_lvalue (arg1);
2938: if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
2939: return non_lvalue (arg0);
2940: /* Both known to be true => return true. */
2941: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2942: return arg0;
2943: goto truth_andor;
2944:
2945: case EQ_EXPR:
2946: case NE_EXPR:
2947: case LT_EXPR:
2948: case GT_EXPR:
2949: case LE_EXPR:
2950: case GE_EXPR:
2951: /* If one arg is a constant integer, put it last. */
2952: if (TREE_CODE (arg0) == INTEGER_CST
2953: && TREE_CODE (arg1) != INTEGER_CST)
2954: {
2955: TREE_OPERAND (t, 0) = arg1;
2956: TREE_OPERAND (t, 1) = arg0;
2957: arg0 = TREE_OPERAND (t, 0);
2958: arg1 = TREE_OPERAND (t, 1);
2959: switch (code)
2960: {
2961: case GT_EXPR:
2962: code = LT_EXPR;
2963: break;
2964: case GE_EXPR:
2965: code = LE_EXPR;
2966: break;
2967: case LT_EXPR:
2968: code = GT_EXPR;
2969: break;
2970: case LE_EXPR:
2971: code = GE_EXPR;
2972: break;
2973: }
2974: TREE_SET_CODE (t, code);
2975: }
2976:
2977: /* Convert foo++ == CONST into ++foo == CONST + INCR.
2978: First, see if one arg is constant; find the constant arg
2979: and the other one. */
2980: {
2981: tree constop = 0, varop;
2982: tree *constoploc;
2983:
2984: if (TREE_CONSTANT (arg1))
2985: constoploc = &TREE_OPERAND (t, 1), constop = arg1, varop = arg0;
2986: if (TREE_CONSTANT (arg0))
2987: constoploc = &TREE_OPERAND (t, 0), constop = arg0, varop = arg1;
2988:
2989: if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
2990: {
2991: tree newconst
2992: = fold (build (PLUS_EXPR, TREE_TYPE (varop),
2993: constop, TREE_OPERAND (varop, 1)));
2994: /* This optimization is invalid for ordered comparisons
2995: if CONST+INCR overflows or if foo+incr might overflow.
2996: For pointer types we assume overflow doesn't happen. */
2997: if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
2998: || code == EQ_EXPR || code == NE_EXPR)
2999: {
3000: /* This optimization is invalid for floating point
3001: if adding one to the constant does not change it. */
3002: if (TREE_CODE (TREE_TYPE (newconst)) != REAL_TYPE
3003: || !REAL_VALUES_EQUAL (TREE_REAL_CST (newconst),
3004: TREE_REAL_CST (constop)))
3005: {
3006: TREE_SET_CODE (varop, PREINCREMENT_EXPR);
3007: *constoploc = newconst;
3008: return t;
3009: }
3010: }
3011: }
3012: else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
3013: {
3014: tree newconst
3015: = fold (build (MINUS_EXPR, TREE_TYPE (varop),
3016: constop, TREE_OPERAND (varop, 1)));
3017: if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
3018: || code == EQ_EXPR || code == NE_EXPR)
3019: {
3020: if (TREE_CODE (TREE_TYPE (newconst)) != REAL_TYPE
3021: || !REAL_VALUES_EQUAL (TREE_REAL_CST (newconst),
3022: TREE_REAL_CST (constop)))
3023: {
3024: TREE_SET_CODE (varop, PREDECREMENT_EXPR);
3025: *constoploc = newconst;
3026: return t;
3027: }
3028: }
3029: }
3030: }
3031:
3032: /* Change X >= CST to X > (CST - 1) if CST is positive. */
3033: if (TREE_CODE (arg1) == INTEGER_CST
3034: && TREE_CODE (arg0) != INTEGER_CST
3035: && ! tree_int_cst_lt (arg1, integer_one_node))
3036: {
3037: switch (TREE_CODE (t))
3038: {
3039: case GE_EXPR:
3040: code = GT_EXPR;
3041: TREE_SET_CODE (t, code);
3042: arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
3043: TREE_OPERAND (t, 1) = arg1;
3044: break;
3045:
3046: case LT_EXPR:
3047: code = LE_EXPR;
3048: TREE_SET_CODE (t, code);
3049: arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
3050: TREE_OPERAND (t, 1) = arg1;
3051: }
3052: }
3053:
3054: /* If we are comparing the result of a comparison to a constant,
3055: we can often simplify this, since the comparison result is known to
3056: be either 0 or 1. We can ignore conversions if the LHS is a
3057: comparison. */
3058:
3059: if (TREE_CODE (arg1) == INTEGER_CST)
3060: {
3061: tree comparison = arg0;
3062:
3063: while (TREE_CODE (comparison) == NOP_EXPR
3064: || TREE_CODE (comparison) == CONVERT_EXPR)
3065: comparison = TREE_OPERAND (comparison, 0);
3066:
3067: if (TREE_CODE_CLASS (TREE_CODE (comparison)) == '<'
3068: || TREE_CODE (comparison) == TRUTH_ANDIF_EXPR
3069: || TREE_CODE (comparison) == TRUTH_ORIF_EXPR
3070: || TREE_CODE (comparison) == TRUTH_AND_EXPR
3071: || TREE_CODE (comparison) == TRUTH_OR_EXPR
3072: || TREE_CODE (comparison) == TRUTH_NOT_EXPR)
3073: {
3074: /* We do different things depending on whether the
3075: constant being compared against is < 0, == 0, == 1, or > 1.
3076: Each of those cases, in order, corresponds to one
3077: character in a string. The value of the character is
3078: the result to return. A '0' or '1' means return always true
3079: or always false, respectively; 'c' means return the result
3080: of the comparison, and 'i' means return the result of the
3081: inverted comparison. */
3082:
3083: char *actions, action;
3084:
3085: switch (code)
3086: {
3087: case EQ_EXPR:
3088: actions = "0ic0";
3089: break;
3090: case NE_EXPR:
3091: actions = "1ci1";
3092: break;
3093: case LE_EXPR:
3094: actions = "0i11";
3095: break;
3096: case LT_EXPR:
3097: actions = "00i1";
3098: break;
3099: case GE_EXPR:
3100: actions = "11c0";
3101: break;
3102: case GT_EXPR:
3103: actions = "1c00";
3104: break;
3105: }
3106:
3107: if (tree_int_cst_lt (arg1, integer_zero_node))
3108: action = actions[0];
3109: else if (integer_zerop (arg1))
3110: action = actions[1];
3111: else if (integer_onep (arg1))
3112: action = actions[2];
3113: else
3114: action = actions[3];
3115:
3116: switch (action)
3117: {
3118: case '0':
3119: return omit_one_operand (type, integer_zero_node,
3120: comparison);
3121:
3122: case '1':
3123: return omit_one_operand (type, integer_one_node, comparison);
3124:
3125: case 'c':
3126: return convert (type, comparison);
3127:
3128: case 'i':
3129: return convert (type, invert_truthvalue (comparison));
3130:
3131: default:
3132: abort ();
3133: }
3134: }
3135: }
3136:
3137: /* If this is an EQ or NE comparison with zero and ARG0 is
3138: (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
3139: two operations, but the latter can be done in one less insn
3140: one machine that have only two-operand insns or on which a
3141: constant cannot be the first operand. */
3142: if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
3143: && TREE_CODE (arg0) == BIT_AND_EXPR)
3144: {
3145: if (TREE_CODE (TREE_OPERAND (arg0, 0)) == LSHIFT_EXPR
3146: && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 0), 0)))
3147: return
3148: fold (build (code, type,
3149: build (BIT_AND_EXPR, TREE_TYPE (arg0),
3150: build (RSHIFT_EXPR,
3151: TREE_TYPE (TREE_OPERAND (arg0, 0)),
3152: TREE_OPERAND (arg0, 1),
3153: TREE_OPERAND (TREE_OPERAND (arg0, 0), 1)),
3154: convert (TREE_TYPE (arg0),
3155: integer_one_node)),
3156: arg1));
3157: else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
3158: && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
3159: return
3160: fold (build (code, type,
3161: build (BIT_AND_EXPR, TREE_TYPE (arg0),
3162: build (RSHIFT_EXPR,
3163: TREE_TYPE (TREE_OPERAND (arg0, 1)),
3164: TREE_OPERAND (arg0, 0),
3165: TREE_OPERAND (TREE_OPERAND (arg0, 1), 1)),
3166: convert (TREE_TYPE (arg0),
3167: integer_one_node)),
3168: arg1));
3169: }
3170:
3171: /* If this is an NE comparison of zero with an AND of one, remove the
3172: comparison since the AND will give the correct value. */
3173: if (code == NE_EXPR && integer_zerop (arg1)
3174: && TREE_CODE (arg0) == BIT_AND_EXPR
3175: && integer_onep (TREE_OPERAND (arg0, 1)))
3176: return convert (type, arg0);
3177:
3178: /* If we have (A & C) == C where C is a power of 2, convert this into
3179: (A & C) != 0. Similarly for NE_EXPR. */
3180: if ((code == EQ_EXPR || code == NE_EXPR)
3181: && TREE_CODE (arg0) == BIT_AND_EXPR
3182: && integer_pow2p (TREE_OPERAND (arg0, 1))
3183: && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
3184: return build (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
3185: arg0, integer_zero_node);
3186:
3187: /* Simplify comparison of an integer with itself.
3188: (This may not be safe with IEEE floats if they are nans.) */
3189: if (operand_equal_p (arg0, arg1, 0)
3190: && TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE)
3191: {
3192: switch (code)
3193: {
3194: case EQ_EXPR:
3195: case GE_EXPR:
3196: case LE_EXPR:
3197: t = build_int_2 (1, 0);
3198: TREE_TYPE (t) = type;
3199: return t;
3200: case NE_EXPR:
3201: case GT_EXPR:
3202: case LT_EXPR:
3203: t = build_int_2 (0, 0);
3204: TREE_TYPE (t) = type;
3205: return t;
3206: }
3207: }
3208:
3209: /* An unsigned comparison against 0 can be simplified. */
3210: if (integer_zerop (arg1)
3211: && (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
3212: || TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE)
3213: && TREE_UNSIGNED (TREE_TYPE (arg1)))
3214: {
3215: switch (TREE_CODE (t))
3216: {
3217: case GT_EXPR:
3218: TREE_SET_CODE (t, NE_EXPR);
3219: break;
3220: case LE_EXPR:
3221: TREE_SET_CODE (t, EQ_EXPR);
3222: break;
3223: case GE_EXPR:
3224: return omit_one_operand (integer_type_node,
3225: integer_one_node, arg0);
3226: case LT_EXPR:
3227: return omit_one_operand (integer_type_node,
3228: integer_zero_node, arg0);
3229: }
3230: }
3231:
3232: /* To compute GT, swap the arguments and do LT.
3233: To compute GE, do LT and invert the result.
3234: To compute LE, swap the arguments, do LT and invert the result.
3235: To compute NE, do EQ and invert the result. */
3236: if (code == LE_EXPR || code == GT_EXPR)
3237: {
3238: register tree temp = arg0;
3239: arg0 = arg1;
3240: arg1 = temp;
3241: }
3242:
3243: /* Compute a result for LT or EQ if args permit;
3244: otherwise return T. */
3245: if (TREE_CODE (arg0) == INTEGER_CST
3246: && TREE_CODE (arg1) == INTEGER_CST)
3247: {
3248: if (code == EQ_EXPR || code == NE_EXPR)
3249: t = build_int_2
3250: (TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
3251: && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1),
3252: 0);
3253: else
3254: t = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
3255: ? INT_CST_LT_UNSIGNED (arg0, arg1)
3256: : INT_CST_LT (arg0, arg1)),
3257: 0);
3258: }
3259: /* Assume a nonexplicit constant cannot equal an explicit one,
3260: since such code would be undefined anyway.
3261: Exception: on sysvr4, using #pragma weak,
3262: a label can come out as 0. */
3263: else if (TREE_CODE (arg1) == INTEGER_CST
3264: && !integer_zerop (arg1)
3265: && TREE_CONSTANT (arg0)
3266: && TREE_CODE (arg0) == ADDR_EXPR
3267: && (code == EQ_EXPR || code == NE_EXPR))
3268: {
3269: t = build_int_2 (0, 0);
3270: }
3271: /* Two real constants can be compared explicitly. */
3272: else if (TREE_CODE (arg0) == REAL_CST
3273: && TREE_CODE (arg1) == REAL_CST)
3274: {
3275: if (code == EQ_EXPR || code == NE_EXPR)
3276: t = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
3277: TREE_REAL_CST (arg1)),
3278: 0);
3279: else
3280: t = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
3281: TREE_REAL_CST (arg1)),
3282: 0);
3283: }
3284: else if ((TREE_CODE (arg0) == COMPONENT_REF
3285: || TREE_CODE (arg0) == BIT_FIELD_REF)
3286: && (code == EQ_EXPR || code == NE_EXPR)
3287: /* Handle the constant case even without -O
3288: to make sure the warnings are given. */
3289: && (optimize || TREE_CODE (arg1) == INTEGER_CST))
3290: {
3291: tree tem = optimize_bit_field_compare (code, type, arg0, arg1);
3292: return tem ? tem : t;
3293: }
3294:
3295: /* If what we want is other than LT or EQ, invert the result. */
3296: if (code == GE_EXPR || code == LE_EXPR || code == NE_EXPR)
3297: TREE_INT_CST_LOW (t) ^= 1;
3298: TREE_TYPE (t) = type;
3299: return t;
3300:
3301: case COND_EXPR:
3302: if (TREE_CODE (arg0) == INTEGER_CST)
3303: return TREE_OPERAND (t, (integer_zerop (arg0) ? 2 : 1));
3304: else if (operand_equal_p (arg1, TREE_OPERAND (expr, 2), 0))
3305: return omit_one_operand (type, arg1, arg0);
3306: else if (integer_onep (TREE_OPERAND (t, 1))
3307: && integer_zerop (TREE_OPERAND (t, 2))
3308: /* If we try to convert TREE_OPERAND (t, 0) to our type, the
3309: call to fold will try to move the conversion inside
3310: a COND, which will recurse. In that case, the COND_EXPR
3311: is probably the best choice, so leave it alone. */
3312: && type == TREE_TYPE (arg0))
3313: return arg0;
3314: else if (integer_zerop (arg1) && integer_onep (TREE_OPERAND (t, 2)))
3315: return convert (type, invert_truthvalue (arg0));
3316:
3317: /* If we have (a >= 0 ? a : -a) or the same with ">", this is an
3318: absolute value expression. */
3319:
3320: if ((TREE_CODE (arg0) == GE_EXPR || TREE_CODE (arg0) == GT_EXPR)
3321: && integer_zerop (TREE_OPERAND (arg0, 1))
3322: && TREE_CODE (TREE_OPERAND (t, 2)) == NEGATE_EXPR
3323: && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
3324: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (t, 2), 0), arg1, 0))
3325: return fold (build1 (ABS_EXPR, type, arg1));
3326:
3327: /* Similarly for (a <= 0 ? -a : a). */
3328:
3329: if ((TREE_CODE (arg0) == LE_EXPR || TREE_CODE (arg0) == LT_EXPR)
3330: && integer_zerop (TREE_OPERAND (arg0, 1))
3331: && TREE_CODE (arg1) == NEGATE_EXPR
3332: && operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (t, 2), 0)
3333: && operand_equal_p (TREE_OPERAND (arg1, 0), TREE_OPERAND (t, 2), 0))
3334: return fold (build1 (ABS_EXPR, type, TREE_OPERAND (t, 2)));
3335:
3336: /* If we have a GT, GE, LT, or LE comparison, this might be a MIN or
3337: MAX test. If so, make a MIN_EXPR or MAX_EXPR. */
3338:
3339: if (TREE_CODE (arg0) == GT_EXPR || TREE_CODE (arg0) == GE_EXPR
3340: || TREE_CODE (arg0) == LT_EXPR || TREE_CODE (arg0) == LE_EXPR)
3341: {
3342: tree hi_true, lo_true;
3343:
3344: if (TREE_CODE (arg0) == GT_EXPR || TREE_CODE (arg0) == GE_EXPR)
3345: hi_true = TREE_OPERAND (arg0, 0), lo_true = TREE_OPERAND (arg0, 1);
3346: else
3347: hi_true = TREE_OPERAND (arg0, 1), lo_true = TREE_OPERAND (arg0, 0);
3348:
3349: if (comparison_equiv_p (hi_true, lo_true, arg1, TREE_OPERAND (t, 2)))
3350: /* We use arg1 and the other arg because they must have the same
3351: type as the intended result.
3352: The values being compared might have a narrower type. */
3353: return fold (build (MAX_EXPR, type, arg1, TREE_OPERAND (t, 2)));
3354: else if (comparison_equiv_p (lo_true, hi_true,
3355: arg1, TREE_OPERAND (t, 2)))
3356: return fold (build (MIN_EXPR, type, arg1, TREE_OPERAND (t, 2)));
3357: }
3358:
3359: /* Look for cases when we are comparing some expression A for equality
3360: with zero and the result is to be zero if A is zero. In that case,
3361: check to see if the value of A is the same as the value to be
3362: returned when A is non-zero.
3363:
3364: There are two cases: One is where we have (A ? A : 0) and the
3365: other is when a single bit is tested (e.g., A & 2 ? 2 : 0).
3366: In these cases, the result of the conditional is simply A.
3367:
3368: Start by setting ARG1 to be the true value and ARG0 to be the thing
3369: compared with zero. Then check for the two cases above. */
3370:
3371: if (integer_zerop (TREE_OPERAND (t, 2))
3372: && TREE_CODE (arg0) == NE_EXPR
3373: && integer_zerop (TREE_OPERAND (arg0, 1))
3374: && ! TREE_SIDE_EFFECTS (arg1))
3375: ;
3376: else if (integer_zerop (arg1)
3377: && TREE_CODE (arg0) == EQ_EXPR
3378: && integer_zerop (TREE_OPERAND (arg0, 1))
3379: && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
3380: arg1 = TREE_OPERAND (t, 2);
3381: else
3382: return t;
3383:
3384: arg0 = TREE_OPERAND (arg0, 0);
3385:
3386: STRIP_NOPS (arg1);
3387: if (operand_equal_p (arg0, arg1, 0)
3388: || (TREE_CODE (arg1) == INTEGER_CST
3389: && integer_pow2p (arg1)
3390: && TREE_CODE (arg0) == BIT_AND_EXPR
3391: && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0)))
3392: return convert (type, arg0);
3393: return t;
3394:
3395: case COMPOUND_EXPR:
3396: if (!TREE_SIDE_EFFECTS (arg0))
3397: return arg1;
3398: return t;
3399:
3400: default:
3401: return t;
3402: } /* switch (code) */
3403: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.