![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to fold-const.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /*@@ Fix lossage on folding division of big integers. */
2:
3: /*@@ This file should be rewritten to use an arbitary precision
4: @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
5: @@ Perhaps the routines could also be used for bc/dc, and made a lib.
6: @@ The routines that translate from the ap rep should
7: @@ warn if precision et. al. is lost.
8: @@ This would also make life easier when this technology is used
9: @@ for cross-compilers. */
10:
11: /* Fold a constant sub-tree into a single node for C-compiler
12: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
13:
14: This file is part of GNU CC.
15:
16: GNU CC is distributed in the hope that it will be useful,
17: but WITHOUT ANY WARRANTY. No author or distributor
18: accepts responsibility to anyone for the consequences of using it
19: or for whether it serves any particular purpose or works at all,
20: unless he says so in writing. Refer to the GNU CC General Public
21: License for full details.
22:
23: Everyone is granted permission to copy, modify and redistribute
24: GNU CC, but only under the conditions described in the
25: GNU CC General Public License. A copy of this license is
26: supposed to have been given to you along with GNU CC so you
27: can know your rights and responsibilities. It should be in a
28: file named COPYING. Among other things, the copyright notice
29: and this notice must be preserved on all copies. */
30:
31:
32: /* There are only two entry points in this file:
33: fold and combine.
34:
35: fold takes a tree as argument and returns a simplified tree.
36:
37: combine takes a tree code for an arithmetic operation
38: and two operands that are trees for constant values
39: and returns the result of the specified operation on those values,
40: also as a tree. */
41:
42: #include <stdio.h>
43: #include "config.h"
44: #include "tree.h"
45:
46: static void lshift_double ();
47: static void rshift_double ();
48: static void lrotate_double ();
49: static void rrotate_double ();
50:
51: /* To do constant folding on INTEGER_CST nodes requires 64-bit arithmetic.
52: We do that by representing the 64-bit integer as 8 shorts,
53: with only 8 bits stored in each short, as a positive number. */
54:
55: /* Unpack a 64-bit integer into 8 shorts.
56: LOW and HI are the integer, as two `int' pieces.
57: SHORTS points to the array of shorts. */
58:
59: static void
60: encode (shorts, low, hi)
61: short *shorts;
62: int low, hi;
63: {
64: shorts[0] = low & 0xff;
65: shorts[1] = (low >> 8) & 0xff;
66: shorts[2] = (low >> 16) & 0xff;
67: shorts[3] = (low >> 24) & 0xff;
68: shorts[4] = hi & 0xff;
69: shorts[5] = (hi >> 8) & 0xff;
70: shorts[6] = (hi >> 16) & 0xff;
71: shorts[7] = (hi >> 24) & 0xff;
72: }
73:
74: /* Pack an array of 8 shorts into a 64-bit integer.
75: SHORTS points to the array of shorts.
76: The integer is stored into *LOW and *HI as two `int' pieces. */
77:
78: static void
79: decode (shorts, low, hi)
80: short *shorts;
81: int *low, *hi;
82: {
83: *low = (shorts[3] << 24) | (shorts[2] << 16) | (shorts[1] << 8) | shorts[0];
84: *hi = (shorts[7] << 24) | (shorts[6] << 16) | (shorts[5] << 8) | shorts[4];
85: }
86:
87: /* Make the integer constant T valid for its type
88: by setting to 0 or 1 all the bits in the constant
89: that don't belong in the type. */
90:
91: static void
92: force_fit_type (t)
93: tree t;
94: {
95: register int prec = TYPE_PRECISION (TREE_TYPE (t));
96:
97: if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
98: prec = BITS_PER_WORD;
99:
100: /* First clear all bits that are beyond the type's precision. */
101:
102: if (prec > HOST_BITS_PER_INT)
103: {
104: TREE_INT_CST_HIGH (t)
105: &= ~((-1) << (prec - HOST_BITS_PER_INT));
106: }
107: else
108: {
109: TREE_INT_CST_HIGH (t) = 0;
110: if (prec < HOST_BITS_PER_INT)
111: TREE_INT_CST_LOW (t)
112: &= ~((-1) << prec);
113: }
114:
115: /* If it's a signed type and value's sign bit is set, extend the sign. */
116:
117: if (! TREE_UNSIGNED (TREE_TYPE (t))
118: && (prec > HOST_BITS_PER_INT
119: ? TREE_INT_CST_HIGH (t) & (1 << (prec - HOST_BITS_PER_INT - 1))
120: : TREE_INT_CST_LOW (t) & (1 << (prec - 1))))
121: {
122: /* Value is negative:
123: set to 1 all the bits that are outside this type's precision. */
124: if (prec > HOST_BITS_PER_INT)
125: {
126: TREE_INT_CST_HIGH (t)
127: |= ((-1) << (prec - HOST_BITS_PER_INT));
128: }
129: else
130: {
131: TREE_INT_CST_HIGH (t) = -1;
132: if (prec < HOST_BITS_PER_INT)
133: TREE_INT_CST_LOW (t)
134: |= ((-1) << prec);
135: }
136: }
137: }
138:
139: /* Add two 64-bit integers with 64-bit result.
140: Each argument is given as two `int' pieces.
141: One argument is L1 and H1; the other, L2 and H2.
142: The value is stored as two `int' pieces in *LV and *HV.
143: We use the 8-shorts representation internally. */
144:
145: static void
146: add_double (l1, h1, l2, h2, lv, hv)
147: int l1, h1, l2, h2;
148: int *lv, *hv;
149: {
150: short arg1[8];
151: short arg2[8];
152: register int carry = 0;
153: register int i;
154:
155: encode (arg1, l1, h1);
156: encode (arg2, l2, h2);
157:
158: for (i = 0; i < 8; i++)
159: {
160: carry += arg1[i] + arg2[i];
161: arg1[i] = carry & 0xff;
162: carry >>= 8;
163: }
164:
165: decode (arg1, lv, hv);
166: }
167:
168: /* Negate a 64-bit integers with 64-bit result.
169: The argument is given as two `int' pieces in L1 and H1.
170: The value is stored as two `int' pieces in *LV and *HV.
171: We use the 8-shorts representation internally. */
172:
173: static void
174: neg_double (l1, h1, lv, hv)
175: int l1, h1;
176: int *lv, *hv;
177: {
178: if (l1 == 0)
179: {
180: *lv = 0;
181: *hv = - h1;
182: }
183: else
184: {
185: *lv = - l1;
186: *hv = ~ h1;
187: }
188: }
189:
190: /* Multiply two 64-bit integers with 64-bit result.
191: Each argument is given as two `int' pieces.
192: One argument is L1 and H1; the other, L2 and H2.
193: The value is stored as two `int' pieces in *LV and *HV.
194: We use the 8-shorts representation internally. */
195:
196: static void
197: mul_double (l1, h1, l2, h2, lv, hv)
198: int l1, h1, l2, h2;
199: int *lv, *hv;
200: {
201: short arg1[8];
202: short arg2[8];
203: short prod[16];
204: register int carry = 0;
205: register int i, j, k;
206:
207: encode (arg1, l1, h1);
208: encode (arg2, l2, h2);
209:
210: bzero (prod, sizeof prod);
211:
212: for (i = 0; i < 8; i++)
213: for (j = 0; j < 8; j++)
214: {
215: k = i + j;
216: carry = arg1[i] * arg2[j];
217: while (carry)
218: {
219: carry += prod[k];
220: prod[k] = carry & 0xff;
221: carry >>= 8;
222: k++;
223: }
224: }
225:
226: decode (prod, lv, hv); /* @@decode ignores prod[8] -> prod[15] */
227: }
228:
229: /* Shift the 64-bit integer in L1, H1 left by COUNT places
230: keeping only PREC bits of result.
231: Shift right if COUNT is negative.
232: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
233: Store the value as two `int' pieces in *LV and *HV. */
234:
235: static void
236: lshift_double (l1, h1, count, prec, lv, hv, arith)
237: int l1, h1, count, prec;
238: int *lv, *hv;
239: int arith;
240: {
241: short arg1[8];
242: register int i;
243: register int carry;
244:
245: if (count < 0)
246: {
247: rshift_double (l1, h1, - count, prec, lv, hv, arith);
248: return;
249: }
250:
251: encode (arg1, l1, h1);
252: if (prec < HOST_BITS_PER_INT)
253: count &= (1 << prec) - 1;
254:
255: while (count > 0)
256: {
257: carry = 0;
258: for (i = 0; i < 8; i++)
259: {
260: carry += arg1[i] << 1;
261: arg1[i] = carry & 0xff;
262: carry >>= 8;
263: }
264: count--;
265: }
266:
267: decode (arg1, lv, hv);
268: }
269:
270: /* Shift the 64-bit integer in L1, H1 right by COUNT places
271: keeping only PREC bits of result. COUNT must be positive.
272: ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
273: Store the value as two `int' pieces in *LV and *HV. */
274:
275: static void
276: rshift_double (l1, h1, count, prec, lv, hv, arith)
277: int l1, h1, count, prec;
278: int *lv, *hv;
279: int arith;
280: {
281: short arg1[8];
282: register int i;
283: register int carry;
284:
285: encode (arg1, l1, h1);
286: if (prec < HOST_BITS_PER_INT)
287: count &= (1 << prec) - 1;
288:
289: carry = arith && arg1[7] >> 7;
290: while (count > 0)
291: {
292: for (i = 7; i >= 0; i--)
293: {
294: carry <<= 8;
295: carry += arg1[i];
296: arg1[i] = (carry >> 1) & 0xff;
297: }
298: count--;
299: }
300:
301: decode (arg1, lv, hv);
302: }
303:
304: /* Rotate the 64-bit integer in L1, H1 left by COUNT places
305: keeping only PREC bits of result.
306: Rotate right if COUNT is negative.
307: Store the value as two `int' pieces in *LV and *HV. */
308:
309: static void
310: lrotate_double (l1, h1, count, prec, lv, hv)
311: int l1, h1, count, prec;
312: int *lv, *hv;
313: {
314: short arg1[8];
315: register int i;
316: register int carry;
317:
318: if (count < 0)
319: {
320: rrotate_double (l1, h1, - count, prec, lv, hv);
321: return;
322: }
323:
324: encode (arg1, l1, h1);
325: if (prec < HOST_BITS_PER_INT)
326: count &= (1 << prec) - 1;
327:
328: carry = arg1[7] >> 7;
329: while (count > 0)
330: {
331: for (i = 0; i < 8; i++)
332: {
333: carry += arg1[i] << 1;
334: arg1[i] = carry & 0xff;
335: carry >>= 8;
336: }
337: count--;
338: }
339:
340: decode (arg1, lv, hv);
341: }
342:
343: /* Rotate the 64-bit integer in L1, H1 left by COUNT places
344: keeping only PREC bits of result. COUNT must be positive.
345: Store the value as two `int' pieces in *LV and *HV. */
346:
347: static void
348: rrotate_double (l1, h1, count, prec, lv, hv)
349: int l1, h1, count, prec;
350: int *lv, *hv;
351: {
352: short arg1[8];
353: register int i;
354: register int carry;
355:
356: encode (arg1, l1, h1);
357: if (prec < HOST_BITS_PER_INT)
358: count &= (1 << prec) - 1;
359:
360: carry = arg1[0] & 1;
361: while (count > 0)
362: {
363: for (i = 7; i >= 0; i--)
364: {
365: carry <<= 8;
366: carry += arg1[i];
367: arg1[i] = (carry >> 1) & 0xff;
368: }
369: count--;
370: }
371:
372: decode (arg1, lv, hv);
373: }
374:
375: /* Divide 64 bit integer LNUM, HNUM by 64 bit integer LDEN, HDEN
376: for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
377: CODE is a tree code for a kind of division, one of
378: TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR and ROUND_DIV_EXPR.
379: It controls how the quotient is rounded to a integer.
380: UNS nonzero says do unsigned division. */
381:
382: static void
383: div_and_round_double (code, uns,
384: lnum_orig, hnum_orig, lden_orig, hden_orig,
385: lquo, hquo, lrem, hrem)
386: enum tree_code code;
387: int uns;
388: int lnum_orig, hnum_orig; /* num == numerator == dividend */
389: int lden_orig, hden_orig; /* den == denominator == divisor */
390: int *lquo, *hquo, *lrem, *hrem;
391: {
392: int quo_neg = 0;
393: short num[9], den[8], quo[8]; /* extra element for scaling. */
394: register int i, j, work;
395: register int carry = 0;
396: int lnum = lnum_orig, hnum = hnum_orig;
397: int lden = lden_orig, hden = hden_orig;
398:
399: if ((hden == 0) && (lden == 0)) {
400: *hquo = *lquo = *hrem = *lrem = 0;
401: error
402: ("divide by 0 in constant folding - quotient and remainder set to 0.");
403: return;
404: }
405:
406: /* calculate quotient sign and convert operands to unsigned. */
407: if (!uns)
408: {
409: if (hden < 0)
410: {
411: quo_neg = ~ quo_neg;
412: neg_double (lden, hden, &lden, &hden);
413: }
414: if (hnum < 0)
415: {
416: quo_neg = ~ quo_neg;
417: neg_double (lnum, hnum, &lnum, &hnum);
418: }
419: }
420:
421: if (hnum == 0 && hden == 0)
422: { /* single precision */
423: *hquo = *hrem = 0;
424: *lquo = (unsigned) lnum / lden; /* rounds toward zero since positive args */
425: goto finish_up;
426: }
427:
428: if (hnum == 0)
429: { /* trivial case: dividend < divisor */
430: /* hden != 0 already checked. */
431: *hquo = *lquo = 0;
432: *hrem = hnum;
433: *lrem = lnum;
434: goto finish_up;
435: }
436:
437: bzero (quo, sizeof quo);
438:
439: bzero (num, sizeof num); /* to zero 9th element */
440: bzero (den, sizeof den);
441:
442: encode (num, lnum, hnum);
443: encode (den, lden, hden);
444:
445: if (hden == 0)
446: { /* simpler algorithm */
447: /* hnum != 0 already checked. */
448: for (i = 7; i >= 0; i--)
449: {
450: work = num[i] + (carry << 8);
451: quo[i] = work / lden;
452: carry = work % lden;
453: }
454: }
455: else { /* full double precision,
456: with thanks to Don Knuth's
457: "Semi-Numericial Algorithms". */
458: #define BASE 256
459: int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
460:
461: /* Find the highest non-zero divisor digit. */
462: for (i = 7; ; i--)
463: if (den[i] != 0) {
464: den_hi_sig = i;
465: break;
466: }
467: for (i = 7; ; i--)
468: if (num[i] != 0) {
469: num_hi_sig = i;
470: break;
471: }
472: quo_hi_sig = num_hi_sig - den_hi_sig + 1;
473:
474: /* Insure that the first digit of the divisor is at least BASE/2.
475: This is required by the quotient digit estimation algorithm. */
476:
477: scale = BASE / (den[den_hi_sig] + 1);
478: if (scale > 1) { /* scale divisor and dividend */
479: carry = 0;
480: for (i = 0; i <= 8; i++) {
481: work = (num[i] * scale) + carry;
482: num[i] = work & 0xff;
483: carry = work >> 8;
484: if (num[i] != 0) num_hi_sig = i;
485: }
486: carry = 0;
487: for (i = 0; i <= 7; i++) {
488: work = (den[i] * scale) + carry;
489: den[i] = work & 0xff;
490: carry = work >> 8;
491: if (den[i] != 0) den_hi_sig = i;
492: }
493: }
494:
495: /* Main loop */
496: for (i = quo_hi_sig; i > 0; i--) {
497: /* quess the next quotient digit, quo_est, by dividing the first
498: two remaining dividend digits by the high order quotient digit.
499: quo_est is never low and is at most 2 high. */
500:
501: int num_hi; /* index of highest remaining dividend digit */
502:
503: num_hi = i + den_hi_sig;
504:
505: work = (num[num_hi] * BASE) + (num_hi ? 0 : num[num_hi - 1]);
506: if (num[num_hi] != den[den_hi_sig]) {
507: quo_est = work / den[den_hi_sig];
508: }
509: else {
510: quo_est = BASE - 1;
511: }
512:
513: /* refine quo_est so it's usually correct, and at most one high. */
514: while ((den[den_hi_sig - 1] * quo_est)
515: > (((work - (quo_est * den[den_hi_sig])) * BASE)
516: + ((num_hi - 1) ? 0 : num[num_hi - 2]))) {
517: quo_est--;
518: }
519:
520: /* try quo_est as the quotient digit, by multiplying the
521: divisor by quo_est and subtracting from the remaining dividend. */
522:
523: carry = 0;
524:
525: for (j = 0; j <= den_hi_sig; j++) {
526: int digit;
527:
528: work = num[i + j] - (quo_est * den[j]) + carry;
529: digit = work & 0xff;
530: carry = work >> 8;
531: if (digit < 0) {
532: digit += BASE;
533: carry--;
534: }
535: num[i + j] = digit;
536: }
537:
538: /* if quo_est was high by one, then num[i] went negative and
539: we need to correct things. */
540:
541: if (num[num_hi] < 0) {
542: quo_est--;
543: carry = 0; /* add divisor back in */
544: for (j = 0; j <= den_hi_sig; j++) {
545: work = num[i + j] + den[j] + carry;
546: if (work > BASE) {
547: work -= BASE;
548: carry = 1;
549: }
550: else {
551: carry = 0;
552: }
553: num[i + j] = work;
554: }
555: num [num_hi] += carry;
556: }
557:
558: /* store the quotient digit. */
559: quo[i - 1] = quo_est;
560: }
561: }
562:
563: decode (quo, lquo, hquo);
564:
565: finish_up:
566: /* if result is negative, make it so. */
567: if (quo_neg)
568: neg_double (*lquo, *hquo, lquo, hquo);
569:
570: /* compute trial remainder: rem = num - (quo * den) */
571: mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
572: neg_double (*lrem, *hrem, lrem, hrem);
573: add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
574:
575: switch (code)
576: {
577: case TRUNC_DIV_EXPR:
578: case TRUNC_MOD_EXPR: /* round toward zero */
579: return;
580:
581: case FLOOR_DIV_EXPR:
582: case FLOOR_MOD_EXPR: /* round toward negative infinity */
583: if (quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio < 0 && rem != 0 */
584: {
585: /* quo = quo - 1; */
586: add_double (*lquo, *hquo, -1, -1, lquo, hquo);
587: }
588: else return;
589: break;
590:
591: case CEIL_DIV_EXPR:
592: case CEIL_MOD_EXPR: /* round toward positive infinity */
593: if (!quo_neg && (*lrem != 0 || *hrem != 0)) /* ratio > 0 && rem != 0 */
594: {
595: add_double (*lquo, *hquo, 1, 0, lquo, hquo);
596: }
597: else return;
598: break;
599:
600: case ROUND_DIV_EXPR:
601: case ROUND_MOD_EXPR: /* round to closest integer */
602: {
603: int labs_rem = *lrem, habs_rem = *hrem;
604: int labs_den = lden, habs_den = hden, ltwice, htwice;
605:
606: /* get absolute values */
607: if (*hrem < 0) neg_double(*lrem, *hrem, &labs_rem, &habs_rem);
608: if (hden < 0) neg_double(lden, hden, &labs_den, &habs_den);
609:
610: /* if (2 * abs (lrem) >= abs (lden)) */
611: mul_double(2, 0, labs_rem, habs_rem, <wice, &htwice);
612: if (((unsigned) habs_den < (unsigned) htwice)
613: || (((unsigned) habs_den == (unsigned) htwice)
614: && ((unsigned) labs_den < (unsigned) ltwice)))
615: {
616: if (*hquo < 0)
617: /* quo = quo - 1; */
618: add_double (*lquo, *hquo, -1, -1, lquo, hquo);
619: else
620: /* quo = quo + 1; */
621: add_double (*lquo, *hquo, 1, 0, lquo, hquo);
622: }
623: else return;
624: }
625: break;
626:
627: default:
628: abort ();
629: }
630:
631: /* compute true 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:
637: /* Split a tree IN into a constant and a variable part
638: that could be combined with CODE to make IN.
639: CODE must be a commutative arithmetic operation.
640: Store the constant part into *CONP and the variable in &VARP.
641: Return 1 if this was done; zero means the tree IN did not decompose
642: this way.
643:
644: If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
645: Therefore, we must tell the caller whether the variable part
646: was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
647: The value stored is the coefficient for the variable term.
648: The constant term we return should always be added;
649: we negate it if necessary. */
650:
651: static int
652: split_tree (in, code, varp, conp, varsignp)
653: tree in;
654: enum tree_code code;
655: tree *varp, *conp;
656: int *varsignp;
657: {
658: register tree outtype = TREE_TYPE (in);
659: *varp = 0;
660: *conp = 0;
661:
662: /* Strip any conversions that don't change the machine mode. */
663: while ((TREE_CODE (in) == NOP_EXPR
664: || TREE_CODE (in) == CONVERT_EXPR)
665: && (TYPE_MODE (TREE_TYPE (in))
666: == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
667: in = TREE_OPERAND (in, 0);
668:
669: if (TREE_CODE (in) == code
670: || (TREE_CODE (TREE_TYPE (in)) != REAL_TYPE
671: /* We can associate addition and subtraction together
672: (even though the C standard doesn't say so)
673: for integers because the value is not affected.
674: For reals, the value might be affected, so we can't. */
675: &&
676: ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
677: || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
678: {
679: enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
680: if (code == INTEGER_CST || code == REAL_CST)
681: {
682: *conp = TREE_OPERAND (in, 0);
683: *varp = TREE_OPERAND (in, 1);
684: if (TREE_TYPE (*varp) != outtype)
685: *varp = convert (outtype, *varp);
686: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
687: return 1;
688: }
689: if (TREE_LITERAL (TREE_OPERAND (in, 1)))
690: {
691: *conp = TREE_OPERAND (in, 1);
692: *varp = TREE_OPERAND (in, 0);
693: *varsignp = 1;
694: if (TREE_TYPE (*varp) != outtype)
695: *varp = convert (outtype, *varp);
696: if (TREE_CODE (in) == MINUS_EXPR)
697: {
698: /* If operation is subtraction and constant is second,
699: must negate it to get an additive constant.
700: And this cannot be done unless it is a manifest constant.
701: It could also be the address of a static variable.
702: We cannot negate that, so give up. */
703: if (TREE_CODE (*conp) == INTEGER_CST
704: || TREE_CODE (*conp) == REAL_CST)
705: *conp = combine (MINUS_EXPR, integer_zero_node, *conp);
706: else
707: return 0;
708: }
709: return 1;
710: }
711: if (TREE_LITERAL (TREE_OPERAND (in, 0)))
712: {
713: *conp = TREE_OPERAND (in, 0);
714: *varp = TREE_OPERAND (in, 1);
715: if (TREE_TYPE (*varp) != outtype)
716: *varp = convert (outtype, *varp);
717: *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
718: return 1;
719: }
720: }
721: return 0;
722: }
723:
724: /* Combine two constants NUM and ARG2 under operation CODE
725: to produce a new constant.
726: We assume ARG1 and ARG2 have the same data type,
727: or at least are the same kind of constant and the same machine mode. */
728:
729: tree
730: combine (code, arg1, arg2)
731: enum tree_code code;
732: register tree arg1, arg2;
733: {
734: if (TREE_CODE (arg1) == INTEGER_CST)
735: {
736: register int int1l = TREE_INT_CST_LOW (arg1);
737: register int int1h = TREE_INT_CST_HIGH (arg1);
738: int int2l = TREE_INT_CST_LOW (arg2);
739: int int2h = TREE_INT_CST_HIGH (arg2);
740: int low, hi;
741: int garbagel, garbageh;
742: register tree t;
743: int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
744:
745: switch (code)
746: {
747: case BIT_IOR_EXPR:
748: t = build_int_2 (int1l | int2l, int1h | int2h);
749: break;
750:
751: case BIT_XOR_EXPR:
752: t = build_int_2 (int1l ^ int2l, int1h ^ int2h);
753: break;
754:
755: case BIT_AND_EXPR:
756: t = build_int_2 (int1l & int2l, int1h & int2h);
757: break;
758:
759: case BIT_ANDTC_EXPR:
760: t = build_int_2 (int1l & ~int2l, int1h & ~int2h);
761: break;
762:
763: case RSHIFT_EXPR:
764: int2l = - int2l;
765: case LSHIFT_EXPR:
766: lshift_double (int1l, int1h, int2l,
767: TYPE_PRECISION (TREE_TYPE (arg1)),
768: &low, &hi,
769: !uns);
770: t = build_int_2 (low, hi);
771: break;
772:
773: case RROTATE_EXPR:
774: int2l = - int2l;
775: case LROTATE_EXPR:
776: lrotate_double (int1l, int1h, int2l,
777: TYPE_PRECISION (TREE_TYPE (arg1)),
778: &low, &hi);
779: t = build_int_2 (low, hi);
780: break;
781:
782: case PLUS_EXPR:
783: add_double (int1l, int1h, int2l, int2h, &low, &hi);
784: t = build_int_2 (low, hi);
785: break;
786:
787: case MINUS_EXPR:
788: neg_double (int2l, int2h, &int2l, &int2h);
789: add_double (int1l, int1h, int2l, int2h, &low, &hi);
790: t = build_int_2 (low, hi);
791: break;
792:
793: case MULT_EXPR:
794: mul_double (int1l, int1h, int2l, int2h, &low, &hi);
795: t = build_int_2 (low, hi);
796: break;
797:
798: case TRUNC_DIV_EXPR: case ROUND_DIV_EXPR:
799: case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
800: div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
801: &low, &hi, &garbagel, &garbageh);
802: t = build_int_2 (low, hi);
803: break;
804:
805: case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR:
806: case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
807: div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
808: &garbagel, &garbageh, &low, &hi);
809: t = build_int_2 (low, hi);
810: break;
811:
812: case MIN_EXPR:
813: case MAX_EXPR:
814: if (uns)
815: {
816: low = (((unsigned) int1h < (unsigned) int2h)
817: || (((unsigned) int1h == (unsigned) int2h)
818: && ((unsigned) int1l < (unsigned) int2l)));
819: }
820: else
821: {
822: low = ((int1h < int2h)
823: || ((int1h == int2h)
824: && ((unsigned) int1l < (unsigned) int2l)));
825: }
826: if (low == (code == MIN_EXPR))
827: t = build_int_2 (int1l, int1h);
828: else
829: t = build_int_2 (int2l, int2h);
830: break;
831:
832: default:
833: abort ();
834: }
835: TREE_TYPE (t) = TREE_TYPE (arg1);
836: force_fit_type (t);
837: return t;
838: }
839: if (TREE_CODE (arg1) == REAL_CST)
840: {
841: register double d1 = TREE_REAL_CST (arg1);
842: register double d2 = TREE_REAL_CST (arg2);
843: register tree t;
844:
845: switch (code)
846: {
847: case PLUS_EXPR:
848: t = build_real (d1 + d2);
849: break;
850:
851: case MINUS_EXPR:
852: t = build_real (d1 - d2);
853: break;
854:
855: case MULT_EXPR:
856: t = build_real (d1 * d2);
857: break;
858:
859: case RDIV_EXPR:
860: if (d2 == 0)
861: return 0;
862:
863: t = build_real (d1 / d2);
864: break;
865:
866: case MIN_EXPR:
867: if (d1 < d2)
868: t = build_real (d1);
869: else
870: t = build_real (d2);
871: break;
872:
873: case MAX_EXPR:
874: if (d1 > d2)
875: t = build_real (d1);
876: else
877: t = build_real (d2);
878: break;
879:
880: default:
881: abort ();
882: }
883: TREE_TYPE (t) = TREE_TYPE (arg1);
884: return t;
885: }
886: if (TREE_CODE (arg1) == COMPLEX_CST)
887: {
888: register tree r1 = TREE_REALPART (arg1);
889: register tree i1 = TREE_IMAGPART (arg1);
890: register tree r2 = TREE_REALPART (arg2);
891: register tree i2 = TREE_IMAGPART (arg2);
892: register tree t;
893:
894: switch (code)
895: {
896: case PLUS_EXPR:
897: t = build_complex (combine (PLUS_EXPR, r1, r2),
898: combine (PLUS_EXPR, i1, i2));
899: break;
900:
901: case MINUS_EXPR:
902: t = build_complex (combine (MINUS_EXPR, r1, r2),
903: combine (MINUS_EXPR, i1, i2));
904: break;
905:
906: case MULT_EXPR:
907: t = build_complex (combine (MINUS_EXPR,
908: combine (MULT_EXPR, r1, r2),
909: combine (MULT_EXPR, i1, i2)),
910: combine (PLUS_EXPR,
911: combine (MULT_EXPR, r1, i2),
912: combine (MULT_EXPR, i1, r2)));
913: break;
914:
915: case RDIV_EXPR:
916: {
917: register tree magsquared
918: = combine (PLUS_EXPR,
919: combine (MULT_EXPR, r2, r2),
920: combine (MULT_EXPR, i2, i2));
921: t = build_complex (combine (RDIV_EXPR,
922: combine (PLUS_EXPR,
923: combine (MULT_EXPR, r1, r2),
924: combine (MULT_EXPR, i1, i2)),
925: magsquared),
926: combine (RDIV_EXPR,
927: combine (MINUS_EXPR,
928: combine (MULT_EXPR, i1, r2),
929: combine (MULT_EXPR, r1, i2)),
930: magsquared));
931: }
932: break;
933:
934: default:
935: abort ();
936: }
937: TREE_TYPE (t) = TREE_TYPE (arg1);
938: return t;
939: }
940: return 0;
941: }
942:
943: /* Given T, a tree representing type conversion of a constant,
944: return a constant tree representing the result of conversion. */
945:
946: static tree
947: fold_convert (t)
948: register tree t;
949: {
950: register tree arg1 = TREE_OPERAND (t, 0);
951: register tree type = TREE_TYPE (t);
952:
953: if (TREE_CODE (type) == POINTER_TYPE
954: || TREE_CODE (type) == INTEGER_TYPE
955: || TREE_CODE (type) == ENUMERAL_TYPE)
956: {
957: if (TREE_CODE (arg1) == INTEGER_CST)
958: {
959: /* Given an integer constant, make new constant with new type,
960: appropriately sign-extended or truncated. */
961: register int inprec;
962: register int outprec;
963:
964: if (TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE)
965: inprec = BITS_PER_WORD;
966: else
967: inprec = TYPE_PRECISION (TREE_TYPE (arg1));
968: if (TREE_CODE (type) == POINTER_TYPE)
969: outprec = BITS_PER_WORD;
970: else
971: outprec = TYPE_PRECISION (type);
972:
973: t = build_int_2 (TREE_INT_CST_LOW (arg1),
974: TREE_INT_CST_HIGH (arg1));
975: TREE_TYPE (t) = type;
976: force_fit_type (t);
977: }
978: else if (TREE_CODE (arg1) == REAL_CST)
979: t = build_int_2 ((int) TREE_REAL_CST (arg1),
980: (int) (TREE_REAL_CST (arg1) / 0x10000 / 0x10000));
981: }
982: else if (TREE_CODE (type) == REAL_TYPE)
983: {
984: if (TREE_CODE (arg1) == INTEGER_CST)
985: t = build_real_from_int_cst (arg1);
986: else if (TREE_CODE (arg1) == REAL_CST)
987: t = build_real (TREE_REAL_CST (arg1));
988: }
989: TREE_TYPE (t) = type;
990: TREE_LITERAL (t) = 1;
991: return t;
992: }
993:
994: /* Return nonzero if two constants (that are not manifest constants)
995: are necessarily equal. It detects only the easiest, common case of
996: equality. */
997:
998: static int
999: operand_equal_p (arg0, arg1)
1000: tree arg0, arg1;
1001: {
1002: while ((TREE_CODE (arg0) == NOP_EXPR
1003: || TREE_CODE (arg0) == CONVERT_EXPR)
1004: && TYPE_MODE (TREE_TYPE (arg0)) == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg0, 0))))
1005: arg0 = TREE_OPERAND (arg0, 0);
1006: while ((TREE_CODE (arg1) == NOP_EXPR
1007: || TREE_CODE (arg1) == CONVERT_EXPR)
1008: && TYPE_MODE (TREE_TYPE (arg1)) == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg1, 0))))
1009: arg1 = TREE_OPERAND (arg1, 0);
1010:
1011: if (TREE_CODE (arg0) == TREE_CODE (arg1)
1012: && TREE_CODE (arg0) == ADDR_EXPR
1013: && TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0))
1014: return 1;
1015: return 0;
1016: }
1017:
1018: /* Perform constant folding and related simplification of EXPR.
1019: The related simplifications include x*1 => x, x*0 => 0, etc.,
1020: and application of the associative law.
1021: NOP_EXPR conversions may be removed freely (as long as we
1022: are careful not to change the C type of the overall expression)
1023: We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
1024: but we can constant-fold them if they have constant operands. */
1025:
1026: tree
1027: fold (expr)
1028: tree expr;
1029: {
1030: register tree t = expr;
1031: register tree arg0, arg1;
1032: register enum tree_code code = TREE_CODE (t);
1033: register int kind;
1034:
1035: /* WINS will be nonzero when the switch is done
1036: if all operands are constant.
1037:
1038: LOSES will be nonzero when the switch is done
1039: if any operand is volatile.
1040: This inhibits optimizations such as (foo () * 0) => 0.
1041: But identity-element optimizations such as
1042: (foo () * 1) => (foo ()) can be done even if LOSES is set. */
1043:
1044: int wins = 1;
1045: int loses = 0;
1046:
1047: /* Return right away if already constant. */
1048: if (TREE_LITERAL (t))
1049: {
1050: if (code == CONST_DECL)
1051: return DECL_INITIAL (t);
1052: return t;
1053: }
1054:
1055: kind = *tree_code_type[(int) code];
1056: if (kind == 'e' || kind == 'r')
1057: {
1058: register int len = tree_code_length[(int) code];
1059: register int i;
1060: for (i = 0; i < len; i++)
1061: {
1062: if (TREE_OPERAND (t, i) == 0)
1063: continue; /* Valid for CALL_EXPR, at least. */
1064: if (TREE_CODE (TREE_OPERAND (t, i)) != INTEGER_CST
1065: && TREE_CODE (TREE_OPERAND (t, i)) != REAL_CST)
1066: /* Note that TREE_LITERAL isn't enough:
1067: static var addresses are constant but we can't
1068: do arithmetic on them. */
1069: wins = 0;
1070: if (TREE_VOLATILE (TREE_OPERAND (t, i)))
1071: loses = 1;
1072: }
1073: arg0 = TREE_OPERAND (t, 0);
1074: if (len > 1)
1075: arg1 = TREE_OPERAND (t, 1);
1076: }
1077:
1078: /* Now WINS and LOSES are set as described above,
1079: ARG0 is the first operand of EXPR,
1080: and ARG1 is the second operand (if it has more than one operand). */
1081:
1082: switch (code)
1083: {
1084: case INTEGER_CST:
1085: case REAL_CST:
1086: case STRING_CST:
1087: case COMPLEX_CST:
1088: case CONSTRUCTOR:
1089: return t;
1090:
1091: case CONST_DECL:
1092: return fold (DECL_INITIAL (t));
1093:
1094: case NOP_EXPR:
1095: case FLOAT_EXPR:
1096: case CONVERT_EXPR:
1097: case FIX_TRUNC_EXPR:
1098: /* Other kinds of FIX are not handled properly by fold_convert. */
1099: if (!wins)
1100: {
1101: TREE_LITERAL (t) = TREE_LITERAL (arg0);
1102: return t;
1103: }
1104: return fold_convert (t);
1105:
1106: case RANGE_EXPR:
1107: TREE_LITERAL (t) = wins;
1108: return t;
1109:
1110: case NEGATE_EXPR:
1111: if (wins)
1112: {
1113: if (TREE_CODE (arg0) == INTEGER_CST)
1114: {
1115: if (TREE_INT_CST_LOW (arg0) == 0)
1116: t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
1117: else
1118: t = build_int_2 (- TREE_INT_CST_LOW (arg0),
1119: ~ TREE_INT_CST_HIGH (arg0));
1120: force_fit_type (t);
1121: }
1122: else if (TREE_CODE (arg0) == REAL_CST)
1123: t = build_real (- TREE_REAL_CST (arg0));
1124: TREE_TYPE (t) = TREE_TYPE (expr);
1125: }
1126: return t;
1127:
1128: case ABS_EXPR:
1129: if (wins)
1130: {
1131: if (TREE_CODE (arg0) == INTEGER_CST)
1132: {
1133: if (! TREE_UNSIGNED (TREE_TYPE (expr))
1134: || TREE_INT_CST_HIGH (arg0) < 0)
1135: {
1136: if (TREE_INT_CST_LOW (arg0) == 0)
1137: t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
1138: else
1139: t = build_int_2 (- TREE_INT_CST_LOW (arg0),
1140: ~ TREE_INT_CST_HIGH (arg0));
1141: }
1142: }
1143: else if (TREE_CODE (arg0) == REAL_CST)
1144: {
1145: if (TREE_REAL_CST (arg0) < 0)
1146: t = build_real (- TREE_REAL_CST (arg0));
1147: }
1148: TREE_TYPE (t) = TREE_TYPE (expr);
1149: }
1150: return t;
1151:
1152: case BIT_NOT_EXPR:
1153: if (wins)
1154: {
1155: if (TREE_CODE (arg0) == INTEGER_CST)
1156: t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
1157: ~ TREE_INT_CST_HIGH (arg0));
1158: TREE_TYPE (t) = TREE_TYPE (expr);
1159: force_fit_type (t);
1160: }
1161: return t;
1162:
1163: case PLUS_EXPR:
1164: if (integer_zerop (arg0))
1165: return convert (TREE_TYPE (expr), arg1);
1166: if (integer_zerop (arg1))
1167: return convert (TREE_TYPE (expr), arg0);
1168: associate:
1169: /* In most languages, can't associate operations on floats
1170: through parentheses. Rather than remember where the parentheses
1171: were, we don't associate floats at all. It shouldn't matter much. */
1172: if (TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
1173: goto binary;
1174: /* The varsign == -1 cases happen only for addition and subtraction.
1175: It says that the arg that was split was really CON minus VAR.
1176: The rest of the code applies to all associative operations. */
1177: if (!wins)
1178: {
1179: tree var, con, tem;
1180: int varsign;
1181: tree inner_arg;
1182:
1183: if (split_tree (arg0, code, &var, &con, &varsign))
1184: {
1185: if (varsign == -1)
1186: {
1187: /* EXPR is (CON-VAR) +- ARG1. */
1188: /* If it is + and VAR==ARG1, return just CONST. */
1189: if (code == PLUS_EXPR && operand_equal_p (var, arg1))
1190: return con;
1191:
1192: /* Otherwise return (CON +- ARG1) - VAR. */
1193: TREE_SET_CODE (t, MINUS_EXPR);
1194: TREE_OPERAND (t, 1) = var;
1195: TREE_OPERAND (t, 0)
1196: = fold (build (code, TREE_TYPE (t), con, arg1));
1197: }
1198: else
1199: {
1200: /* EXPR is (VAR+CON) +- ARG1. */
1201: /* If it is - and VAR==ARG1, return just CONST. */
1202: if (code == MINUS_EXPR && operand_equal_p (var, arg1))
1203: return con;
1204:
1205: /* Otherwise return VAR +- (ARG1 +- CON). */
1206: TREE_OPERAND (t, 1) = tem
1207: = fold (build (code, TREE_TYPE (t), arg1, con));
1208: TREE_OPERAND (t, 0) = var;
1209: if (integer_zerop (tem)
1210: && (code == PLUS_EXPR || code == MINUS_EXPR))
1211: return var;
1212: /* If we have x +/- (c - d) [c an explicit integer]
1213: change it to x -/+ (d - c) since if d is relocatable
1214: then the latter can be a single immediate insn
1215: and the former cannot. */
1216: if (TREE_CODE (tem) == MINUS_EXPR
1217: && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
1218: {
1219: tree tem1 = TREE_OPERAND (tem, 1);
1220: TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
1221: TREE_OPERAND (tem, 0) = tem1;
1222: TREE_SET_CODE (t,
1223: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
1224: }
1225: }
1226: return t;
1227: }
1228:
1229: if (split_tree (arg1, code, &var, &con, &varsign))
1230: {
1231: /* EXPR is ARG0 +- (CON +- VAR). */
1232: if (varsign == -1)
1233: TREE_SET_CODE (t,
1234: (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
1235: if (TREE_CODE (t) == MINUS_EXPR && operand_equal_p (var, arg0))
1236: return con;
1237: TREE_OPERAND (t, 0)
1238: = fold (build (code, TREE_TYPE (t), arg0, con));
1239: TREE_OPERAND (t, 1) = var;
1240: if (integer_zerop (TREE_OPERAND (t, 0))
1241: && TREE_CODE (t) == PLUS_EXPR)
1242: return var;
1243: return t;
1244: }
1245: }
1246: binary:
1247: {
1248: register tree t1 = NULL_TREE;
1249: if (wins)
1250: t1 = combine (code, arg0, arg1);
1251: if (t1 != NULL_TREE) return t1;
1252: return t;
1253: }
1254:
1255: case MINUS_EXPR:
1256: if (! wins && integer_zerop (arg0))
1257: return build (NEGATE_EXPR, TREE_TYPE (expr), arg1);
1258: if (integer_zerop (arg1))
1259: return convert (TREE_TYPE (expr), arg0);
1260: /* Fold &x - &x. This can happen from &x.foo - &x. */
1261: if (operand_equal_p (arg0, arg1))
1262: return convert (TREE_TYPE (t), integer_zero_node);
1263: goto associate;
1264:
1265: case MULT_EXPR:
1266: if (!loses && integer_zerop (arg0))
1267: return convert (TREE_TYPE (expr), arg0);
1268: if (!loses && integer_zerop (arg1))
1269: return convert (TREE_TYPE (expr), arg1);
1270: if (integer_onep (arg0))
1271: return convert (TREE_TYPE (expr), arg1);
1272: if (integer_onep (arg1))
1273: return convert (TREE_TYPE (expr), arg0);
1274: goto associate;
1275:
1276: case BIT_IOR_EXPR:
1277: if (!loses && integer_all_onesp (arg0))
1278: return convert (TREE_TYPE (expr), arg0);
1279: if (!loses && integer_all_onesp (arg1))
1280: return convert (TREE_TYPE (expr), arg1);
1281: case BIT_XOR_EXPR:
1282: if (integer_zerop (arg0))
1283: return convert (TREE_TYPE (expr), arg1);
1284: if (integer_zerop (arg1))
1285: return convert (TREE_TYPE (expr), arg0);
1286: goto associate;
1287:
1288: case BIT_AND_EXPR:
1289: if (integer_all_onesp (arg0))
1290: return convert (TREE_TYPE (expr), arg1);
1291: if (integer_all_onesp (arg1))
1292: return convert (TREE_TYPE (expr), arg0);
1293: if (!loses && integer_zerop (arg0))
1294: return convert (TREE_TYPE (expr), arg0);
1295: if (!loses && integer_zerop (arg1))
1296: return convert (TREE_TYPE (expr), arg1);
1297: /* Simplify (int)((unsigned char)x & 0x377) into (int)(unsigned char)x. */
1298: if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
1299: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
1300: {
1301: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
1302: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
1303: && (~TREE_INT_CST_LOW (arg0) & ((1 << prec) - 1)) == 0)
1304: return convert (TREE_TYPE (expr), arg1);
1305: }
1306: if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
1307: && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
1308: {
1309: int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
1310: if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
1311: && (~TREE_INT_CST_LOW (arg1) & ((1 << prec) - 1)) == 0)
1312: return convert (TREE_TYPE (expr), arg0);
1313: }
1314: goto associate;
1315:
1316: case BIT_ANDTC_EXPR:
1317: if (integer_all_onesp (arg0))
1318: return convert (TREE_TYPE (expr), arg1);
1319: if (integer_zerop (arg1))
1320: return convert (TREE_TYPE (expr), arg0);
1321: if (!loses && integer_zerop (arg0))
1322: return convert (TREE_TYPE (expr), arg0);
1323: if (!loses && integer_all_onesp (arg1))
1324: return combine (code, arg1, arg1);
1325: goto binary;
1326:
1327: case TRUNC_DIV_EXPR:
1328: case ROUND_DIV_EXPR:
1329: case FLOOR_DIV_EXPR:
1330: case CEIL_DIV_EXPR:
1331: case RDIV_EXPR:
1332: if (integer_onep (arg1))
1333: return convert (TREE_TYPE (expr), arg0);
1334: goto binary;
1335:
1336: case CEIL_MOD_EXPR:
1337: case FLOOR_MOD_EXPR:
1338: case ROUND_MOD_EXPR:
1339: case TRUNC_MOD_EXPR:
1340: if (!loses && integer_onep (arg1))
1341: return combine (code, arg1, arg1);
1342: goto binary;
1343:
1344: case LSHIFT_EXPR:
1345: case RSHIFT_EXPR:
1346: case LROTATE_EXPR:
1347: case RROTATE_EXPR:
1348: if (integer_zerop (arg1))
1349: return convert (TREE_TYPE (expr), arg0);
1350: goto binary;
1351:
1352: case MIN_EXPR: case MAX_EXPR:
1353: goto associate;
1354:
1355: case TRUTH_NOT_EXPR:
1356: if (wins)
1357: {
1358: if (TREE_CODE (arg0) == INTEGER_CST)
1359: {
1360: t = build_int_2 ((TREE_INT_CST_LOW (arg0) == 0
1361: && TREE_INT_CST_HIGH (arg0) == 0),
1362: 0);
1363: TREE_TYPE (t) = integer_type_node;
1364: }
1365: if (TREE_CODE (arg0) == REAL_CST)
1366: {
1367: t = build_int_2 (TREE_REAL_CST (arg0) == 0, 0);
1368: TREE_TYPE (t) = integer_type_node;
1369: }
1370: }
1371: return t;
1372:
1373: case TRUTH_AND_EXPR:
1374: case TRUTH_ANDIF_EXPR:
1375: if (wins)
1376: {
1377: if (TREE_CODE (arg0) == INTEGER_CST
1378: && TREE_CODE (arg1) == INTEGER_CST)
1379: t = build_int_2 (((TREE_INT_CST_LOW (arg0) || TREE_INT_CST_HIGH (arg0))
1380: && (TREE_INT_CST_LOW (arg1) || TREE_INT_CST_HIGH (arg1))),
1381: 0);
1382: if (TREE_CODE (arg0) == REAL_CST
1383: && TREE_CODE (arg1) == REAL_CST)
1384: t = build_int_2 ((TREE_REAL_CST (arg0) && TREE_REAL_CST (arg1)),
1385: 0);
1386: TREE_TYPE (t) = TREE_TYPE (expr);
1387: }
1388: return t;
1389:
1390: case TRUTH_OR_EXPR:
1391: case TRUTH_ORIF_EXPR:
1392: if (wins)
1393: {
1394: if (TREE_CODE (arg0) == INTEGER_CST
1395: && TREE_CODE (arg1) == INTEGER_CST)
1396: t = build_int_2 (((TREE_INT_CST_LOW (arg0) || TREE_INT_CST_HIGH (arg0))
1397: || (TREE_INT_CST_LOW (arg1) || TREE_INT_CST_HIGH (arg1))),
1398: 0);
1399: if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
1400: t = build_int_2 ((TREE_REAL_CST (arg0) || TREE_REAL_CST (arg1)),
1401: 0);
1402: TREE_TYPE (t) = TREE_TYPE (expr);
1403: }
1404: return t;
1405:
1406: case EQ_EXPR:
1407: case NE_EXPR:
1408: case LT_EXPR:
1409: case GT_EXPR:
1410: case LE_EXPR:
1411: case GE_EXPR:
1412: /* Convert foo++ == CONST into ++foo == CONST + INCR.
1413: First, see if one arg is constant; find the constant arg
1414: and the other one. */
1415: {
1416: tree constop = 0, varop;
1417: tree *constoploc;
1418:
1419: if (TREE_LITERAL (arg1))
1420: constoploc = &TREE_OPERAND (t, 1), constop = arg1, varop = arg0;
1421: if (TREE_LITERAL (arg0))
1422: constoploc = &TREE_OPERAND (t, 0), constop = arg0, varop = arg1;
1423:
1424: if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
1425: {
1426: tree newconst
1427: = fold (build (PLUS_EXPR, TREE_TYPE (t),
1428: constop, TREE_OPERAND (varop, 1)));
1429: /* This optimization is invalid for ordered comparisons
1430: if CONST+INCR overflows!
1431: We can assume that address + integer will not overflow. */
1432: if (TREE_CODE (newconst) != INTEGER_CST
1433: || ! tree_int_cst_lt (newconst, constop)
1434: || code == EQ_EXPR || code == NE_EXPR)
1435: {
1436: TREE_CODE (varop) = PREINCREMENT_EXPR;
1437: *constoploc = newconst;
1438: return t;
1439: }
1440: }
1441: else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
1442: {
1443: tree newconst
1444: = fold (build (MINUS_EXPR, TREE_TYPE (t),
1445: constop, TREE_OPERAND (varop, 1)));
1446: if (TREE_CODE (newconst) != INTEGER_CST
1447: || tree_int_cst_lt (newconst, constop)
1448: || code == EQ_EXPR || code == NE_EXPR)
1449: {
1450: TREE_CODE (varop) = PREDECREMENT_EXPR;
1451: *constoploc = newconst;
1452: return t;
1453: }
1454: }
1455: }
1456:
1457: /* An unsigned comparison against 0 can be simplified. */
1458: if (integer_zerop (arg0)
1459: && (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
1460: || TREE_CODE (TREE_TYPE (arg0)) == POINTER_TYPE)
1461: && TREE_UNSIGNED (TREE_TYPE (arg0)))
1462: {
1463: switch (TREE_CODE (t))
1464: {
1465: case LT_EXPR:
1466: TREE_CODE (t) = NE_EXPR;
1467: break;
1468: case GE_EXPR:
1469: TREE_CODE (t) = EQ_EXPR;
1470: break;
1471: case LE_EXPR:
1472: return build (COMPOUND_EXPR, integer_type_node,
1473: arg1, integer_one_node);
1474: case GT_EXPR:
1475: return build (COMPOUND_EXPR, integer_type_node,
1476: arg1, integer_zero_node);
1477: }
1478: }
1479:
1480: /* An unsigned comparison against 0 can be simplified. */
1481: if (integer_zerop (arg1)
1482: && (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
1483: || TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE)
1484: && TREE_UNSIGNED (TREE_TYPE (arg1)))
1485: {
1486: switch (TREE_CODE (t))
1487: {
1488: case GT_EXPR:
1489: TREE_CODE (t) = NE_EXPR;
1490: break;
1491: case LE_EXPR:
1492: TREE_CODE (t) = EQ_EXPR;
1493: break;
1494: case GE_EXPR:
1495: return build (COMPOUND_EXPR, integer_type_node,
1496: arg0, integer_one_node);
1497: case LT_EXPR:
1498: return build (COMPOUND_EXPR, integer_type_node,
1499: arg0, integer_zero_node);
1500: }
1501: }
1502:
1503: /* To compute GT, swap the arguments and do LT.
1504: To compute GE, do LT and invert the result.
1505: To compute LE, swap the arguments, do LT and invert the result.
1506: To compute NE, do EQ and invert the result. */
1507: if (code == LE_EXPR || code == GT_EXPR)
1508: {
1509: register tree temp = arg0;
1510: arg0 = arg1;
1511: arg1 = temp;
1512: }
1513:
1514: /* Compute a result for LT or EQ if args permit. */
1515: if (TREE_CODE (arg0) == INTEGER_CST
1516: && TREE_CODE (arg1) == INTEGER_CST)
1517: {
1518: if (code == EQ_EXPR || code == NE_EXPR)
1519: t = build_int_2
1520: (TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
1521: && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1),
1522: 0);
1523: else
1524: t = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
1525: ? INT_CST_LT_UNSIGNED (arg0, arg1)
1526: : INT_CST_LT (arg0, arg1)),
1527: 0);
1528: }
1529: else if (TREE_CODE (arg0) == REAL_CST
1530: && TREE_CODE (arg1) == REAL_CST)
1531: {
1532: if (code == EQ_EXPR || code == NE_EXPR)
1533: t = build_int_2 (TREE_REAL_CST (arg0) == TREE_REAL_CST (arg1), 0);
1534: else
1535: t = build_int_2 (TREE_REAL_CST (arg0) < TREE_REAL_CST (arg1), 0);
1536: }
1537: else
1538: return t;
1539:
1540: /* If we wanted ...-or-equal, invert the result. */
1541: if (code == GE_EXPR || code == LE_EXPR || code == NE_EXPR)
1542: TREE_INT_CST_LOW (t) ^= 1;
1543: TREE_TYPE (t) = TREE_TYPE (expr);
1544: return t;
1545:
1546: COND_EXPR:
1547: if (TREE_LITERAL (arg0))
1548: return TREE_OPERAND (expr, (integer_zerop (arg0) ? 2 : 1));
1549: return t;
1550:
1551: default:
1552: return t;
1553: } /* switch (code) */
1554: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.