]>
gcc.gnu.org Git - gcc.git/blob - gcc/fold-const.c
7e2f2a350dc19c3b1ac976ca9a9a6189ed6331d4
1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
4 This file is part of GNU CC.
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)
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.
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. */
20 /*@@ Fix lossage on folding division of big integers. */
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. */
31 /* The entry points in this file are fold, size_int and size_binop.
33 fold takes a tree as argument and returns a simplified tree.
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'.
39 size_int takes an integer value, and creates a tree constant
40 with type from `sizetype'. */
48 void lshift_double ();
49 void rshift_double ();
50 void lrotate_double ();
51 void rrotate_double ();
52 static tree
const_binop ();
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. */
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. */
63 encode (shorts
, low
, hi
)
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;
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. */
82 decode (shorts
, low
, hi
)
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]);
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. */
102 register int prec
= TYPE_PRECISION (TREE_TYPE (t
));
104 if (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
)
107 /* First clear all bits that are beyond the type's precision. */
109 if (prec
== 2 * HOST_BITS_PER_INT
)
111 else if (prec
> HOST_BITS_PER_INT
)
113 TREE_INT_CST_HIGH (t
)
114 &= ~((-1) << (prec
- HOST_BITS_PER_INT
));
118 TREE_INT_CST_HIGH (t
) = 0;
119 if (prec
< HOST_BITS_PER_INT
)
124 /* If it's a signed type and value's sign bit is set, extend the sign. */
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))))
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
)
136 TREE_INT_CST_HIGH (t
)
137 |= ((-1) << (prec
- HOST_BITS_PER_INT
));
141 TREE_INT_CST_HIGH (t
) = -1;
142 if (prec
< HOST_BITS_PER_INT
)
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. */
156 add_double (l1
, h1
, l2
, h2
, lv
, hv
)
162 register int carry
= 0;
165 encode (arg1
, l1
, h1
);
166 encode (arg2
, l2
, h2
);
168 for (i
= 0; i
< 8; i
++)
170 carry
+= arg1
[i
] + arg2
[i
];
171 arg1
[i
] = carry
& 0xff;
175 decode (arg1
, lv
, hv
);
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. */
184 neg_double (l1
, h1
, lv
, hv
)
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. */
207 mul_double (l1
, h1
, l2
, h2
, lv
, hv
)
214 register int carry
= 0;
215 register int i
, j
, k
;
217 /* These two cases are used extensively, arising from pointer
223 unsigned temp
= l1
+ l1
;
224 *hv
= h1
* 2 + (temp
< l1
);
230 unsigned temp
= l1
+ l1
;
231 h1
= h1
* 4 + ((temp
< l1
) << 1);
241 unsigned temp
= l1
+ l1
;
242 h1
= h1
* 8 + ((temp
< l1
) << 2);
245 h1
+= (temp
< l1
) << 1;
255 encode (arg1
, l1
, h1
);
256 encode (arg2
, l2
, h2
);
258 bzero (prod
, sizeof prod
);
260 for (i
= 0; i
< 8; i
++)
261 for (j
= 0; j
< 8; j
++)
264 carry
= arg1
[i
] * arg2
[j
];
268 prod
[k
] = carry
& 0xff;
274 decode (prod
, lv
, hv
); /* @@decode ignores prod[8] -> prod[15] */
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. */
284 lshift_double (l1
, h1
, count
, prec
, lv
, hv
, arith
)
285 int l1
, h1
, count
, prec
;
295 rshift_double (l1
, h1
, - count
, prec
, lv
, hv
, arith
);
299 encode (arg1
, l1
, h1
);
307 for (i
= 0; i
< 8; i
++)
309 carry
+= arg1
[i
] << 1;
310 arg1
[i
] = carry
& 0xff;
316 decode (arg1
, lv
, hv
);
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. */
325 rshift_double (l1
, h1
, count
, prec
, lv
, hv
, arith
)
326 int l1
, h1
, count
, prec
;
334 encode (arg1
, l1
, h1
);
341 carry
= arith
&& arg1
[7] >> 7;
342 for (i
= 7; i
>= 0; i
--)
346 arg1
[i
] = (carry
>> 1) & 0xff;
351 decode (arg1
, lv
, hv
);
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. */
360 lrotate_double (l1
, h1
, count
, prec
, lv
, hv
)
361 int l1
, h1
, count
, prec
;
370 rrotate_double (l1
, h1
, - count
, prec
, lv
, hv
);
374 encode (arg1
, l1
, h1
);
379 carry
= arg1
[7] >> 7;
382 for (i
= 0; i
< 8; i
++)
384 carry
+= arg1
[i
] << 1;
385 arg1
[i
] = carry
& 0xff;
391 decode (arg1
, lv
, hv
);
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. */
399 rrotate_double (l1
, h1
, count
, prec
, lv
, hv
)
400 int l1
, h1
, count
, prec
;
407 encode (arg1
, l1
, h1
);
415 for (i
= 7; i
>= 0; i
--)
419 arg1
[i
] = (carry
>> 1) & 0xff;
424 decode (arg1
, lv
, hv
);
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
432 It controls how the quotient is rounded to a integer.
433 UNS nonzero says do unsigned division. */
436 div_and_round_double (code
, uns
,
437 lnum_orig
, hnum_orig
, lden_orig
, hden_orig
,
438 lquo
, hquo
, lrem
, hrem
)
441 int lnum_orig
, hnum_orig
; /* num == numerator == dividend */
442 int lden_orig
, hden_orig
; /* den == denominator == divisor */
443 int *lquo
, *hquo
, *lrem
, *hrem
;
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
;
454 if ((hden
== 0) && (lden
== 0))
457 /* calculate quotient sign and convert operands to unsigned. */
463 neg_double (lden
, hden
, &lden
, &hden
);
468 neg_double (lnum
, hnum
, &lnum
, &hnum
);
472 if (hnum
== 0 && hden
== 0)
473 { /* single precision */
475 *lquo
= lnum
/ lden
; /* rounds toward zero since positive args */
480 { /* trivial case: dividend < divisor */
481 /* hden != 0 already checked. */
488 bzero (quo
, sizeof quo
);
490 bzero (num
, sizeof num
); /* to zero 9th element */
491 bzero (den
, sizeof den
);
493 encode (num
, lnum
, hnum
);
494 encode (den
, lden
, hden
);
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
--)
505 work
= num
[i
] + (carry
<< 8);
506 quo
[i
] = work
/ lden
;
510 else { /* full double precision,
511 with thanks to Don Knuth's
512 "Semi-Numericial Algorithms". */
514 int quo_est
, scale
, num_hi_sig
, den_hi_sig
, quo_hi_sig
;
516 /* Find the highest non-zero divisor digit. */
527 quo_hi_sig
= num_hi_sig
- den_hi_sig
+ 1;
529 /* Insure that the first digit of the divisor is at least BASE/2.
530 This is required by the quotient digit estimation algorithm. */
532 scale
= BASE
/ (den
[den_hi_sig
] + 1);
533 if (scale
> 1) { /* scale divisor and dividend */
535 for (i
= 0; i
<= 8; i
++) {
536 work
= (num
[i
] * scale
) + carry
;
537 num
[i
] = work
& 0xff;
539 if (num
[i
] != 0) num_hi_sig
= i
;
542 for (i
= 0; i
<= 7; i
++) {
543 work
= (den
[i
] * scale
) + carry
;
544 den
[i
] = work
& 0xff;
546 if (den
[i
] != 0) den_hi_sig
= i
;
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. */
556 int num_hi
; /* index of highest remaining dividend digit */
558 num_hi
= i
+ den_hi_sig
;
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
];
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)))
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. */
580 for (j
= 0; j
<= den_hi_sig
; j
++)
584 work
= num
[i
+ j
- 1] - (quo_est
* den
[j
]) + carry
;
592 num
[i
+ j
- 1] = digit
;
595 /* if quo_est was high by one, then num[i] went negative and
596 we need to correct things. */
601 carry
= 0; /* add divisor back in */
602 for (j
= 0; j
<= den_hi_sig
; j
++)
604 work
= num
[i
+ j
- 1] + den
[j
] + carry
;
614 num
[i
+ j
- 1] = work
;
616 num
[num_hi
] += carry
;
619 /* store the quotient digit. */
620 quo
[i
- 1] = quo_est
;
624 decode (quo
, lquo
, hquo
);
627 /* if result is negative, make it so. */
629 neg_double (*lquo
, *hquo
, lquo
, hquo
);
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
);
639 case TRUNC_MOD_EXPR
: /* round toward zero */
640 case EXACT_DIV_EXPR
: /* for this one, it shouldn't matter */
644 case FLOOR_MOD_EXPR
: /* round toward negative infinity */
645 if (quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio < 0 && rem != 0 */
648 add_double (*lquo
, *hquo
, -1, -1, lquo
, hquo
);
654 case CEIL_MOD_EXPR
: /* round toward positive infinity */
655 if (!quo_neg
&& (*lrem
!= 0 || *hrem
!= 0)) /* ratio > 0 && rem != 0 */
657 add_double (*lquo
, *hquo
, 1, 0, lquo
, hquo
);
663 case ROUND_MOD_EXPR
: /* round to closest integer */
665 int labs_rem
= *lrem
, habs_rem
= *hrem
;
666 int labs_den
= lden
, habs_den
= hden
, ltwice
, htwice
;
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
);
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
)))
680 add_double (*lquo
, *hquo
, -1, -1, lquo
, hquo
);
683 add_double (*lquo
, *hquo
, 1, 0, lquo
, hquo
);
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
);
699 #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
701 /* Check for infinity in an IEEE double precision number. */
707 /* The IEEE 64-bit double format. */
712 unsigned exponent
: 11;
713 unsigned mantissa1
: 20;
718 unsigned mantissa1
: 20;
719 unsigned exponent
: 11;
725 if (u
.big_endian
.sign
== 1)
728 return (u
.big_endian
.exponent
== 2047
729 && u
.big_endian
.mantissa1
== 0
730 && u
.big_endian
.mantissa2
== 0);
735 return (u
.little_endian
.exponent
== 2047
736 && u
.little_endian
.mantissa1
== 0
737 && u
.little_endian
.mantissa2
== 0);
741 /* Check for minus zero in an IEEE double precision number. */
744 target_minus_zero (x
)
747 REAL_VALUE_TYPE d1
, d2
;
749 d1
= REAL_VALUE_NEGATE (x
);
752 return !bcmp (&d1
, &d2
, sizeof (d1
));
754 #else /* Target not IEEE */
756 /* Let's assume other float formats don't have infinity.
757 (This can be overridden by redefining REAL_VALUE_ISINF.) */
765 /* Let's assume other float formats don't have minus zero.
766 (This can be overridden by redefining REAL_VALUE_MINUS_ZERO.) */
768 target_minus_zero (x
)
773 #endif /* Target not IEEE */
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
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. */
790 split_tree (in
, code
, varp
, conp
, varsignp
)
796 register tree outtype
= TREE_TYPE (in
);
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);
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. */
814 ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
815 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
817 enum tree_code code
= TREE_CODE (TREE_OPERAND (in
, 0));
818 if (code
== INTEGER_CST
)
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;
828 if (TREE_CONSTANT (TREE_OPERAND (in
, 1)))
830 *conp
= TREE_OPERAND (in
, 1);
831 *varp
= TREE_OPERAND (in
, 0);
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
)
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
));
851 if (TREE_CONSTANT (TREE_OPERAND (in
, 0)))
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;
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. */
870 /* Handle floating overflow for `const_binop'. */
871 static jmp_buf const_binop_error
;
874 const_binop (code
, arg1
, arg2
)
876 register tree arg1
, arg2
;
878 if (TREE_CODE (arg1
) == INTEGER_CST
)
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
);
885 int garbagel
, garbageh
;
887 int uns
= TREE_UNSIGNED (TREE_TYPE (arg1
));
892 t
= build_int_2 (int1l
| int2l
, int1h
| int2h
);
896 t
= build_int_2 (int1l
^ int2l
, int1h
^ int2h
);
900 t
= build_int_2 (int1l
& int2l
, int1h
& int2h
);
904 t
= build_int_2 (int1l
& ~int2l
, int1h
& ~int2h
);
910 lshift_double (int1l
, int1h
, int2l
,
911 TYPE_PRECISION (TREE_TYPE (arg1
)),
914 t
= build_int_2 (low
, hi
);
920 lrotate_double (int1l
, int1h
, int2l
,
921 TYPE_PRECISION (TREE_TYPE (arg1
)),
923 t
= build_int_2 (low
, hi
);
930 if ((unsigned) int2l
< int1l
)
932 t
= build_int_2 (int2l
, int2h
);
938 if ((unsigned) int1l
< int2l
)
940 t
= build_int_2 (int1l
, int1h
);
943 add_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
944 t
= build_int_2 (low
, hi
);
948 if (int2h
== 0 && int2l
== 0)
950 t
= build_int_2 (int1l
, int1h
);
953 neg_double (int2l
, int2h
, &int2l
, &int2h
);
954 add_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
955 t
= build_int_2 (low
, hi
);
959 /* Optimize simple cases. */
967 t
= build_int_2 (0, 0);
970 t
= build_int_2 (int2l
, int2h
);
973 temp
= int2l
+ int2l
;
974 int2h
= int2h
* 2 + (temp
< int2l
);
975 t
= build_int_2 (temp
, int2h
);
978 temp
= int2l
+ int2l
+ int2l
;
979 int2h
= int2h
* 3 + (temp
< int2l
);
980 t
= build_int_2 (temp
, int2h
);
983 temp
= int2l
+ int2l
;
984 int2h
= int2h
* 4 + ((temp
< int2l
) << 1);
987 int2h
+= (temp
< int2l
);
988 t
= build_int_2 (temp
, int2h
);
991 temp
= int2l
+ int2l
;
992 int2h
= int2h
* 8 + ((temp
< int2l
) << 2);
995 int2h
+= (temp
< int2l
) << 1;
998 int2h
+= (temp
< int2l
);
999 t
= build_int_2 (temp
, int2h
);
1010 t
= build_int_2 (0, 0);
1015 t
= build_int_2 (int1l
, int1h
);
1020 mul_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
1021 t
= build_int_2 (low
, hi
);
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
1030 if (int2h
== 0 && int2l
> 0
1031 && TREE_TYPE (arg1
) == sizetype
1032 && int1h
== 0 && int1l
>= 0)
1034 if (code
== CEIL_DIV_EXPR
)
1036 return size_int (int1l
/ int2l
);
1038 case ROUND_DIV_EXPR
:
1039 if (int2h
== 0 && int2l
== 1)
1041 t
= build_int_2 (int1l
, int1h
);
1044 if (int1l
== int2l
&& int1h
== int2h
)
1046 if ((int1l
| int1h
) == 0)
1048 t
= build_int_2 (1, 0);
1051 div_and_round_double (code
, uns
, int1l
, int1h
, int2l
, int2h
,
1052 &low
, &hi
, &garbagel
, &garbageh
);
1053 t
= build_int_2 (low
, hi
);
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
);
1067 low
= (((unsigned) int1h
< (unsigned) int2h
)
1068 || (((unsigned) int1h
== (unsigned) int2h
)
1069 && ((unsigned) int1l
< (unsigned) int2l
)));
1073 low
= ((int1h
< int2h
)
1074 || ((int1h
== int2h
)
1075 && ((unsigned) int1l
< (unsigned) int2l
)));
1077 if (low
== (code
== MIN_EXPR
))
1078 t
= build_int_2 (int1l
, int1h
);
1080 t
= build_int_2 (int2l
, int2h
);
1087 TREE_TYPE (t
) = TREE_TYPE (arg1
);
1091 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1092 if (TREE_CODE (arg1
) == REAL_CST
)
1094 register REAL_VALUE_TYPE d1
;
1095 register REAL_VALUE_TYPE d2
;
1096 register REAL_VALUE_TYPE value
;
1098 d1
= TREE_REAL_CST (arg1
);
1099 d2
= TREE_REAL_CST (arg2
);
1100 if (setjmp (const_binop_error
))
1102 warning ("floating overflow in constant folding");
1103 return build (code
, TREE_TYPE (arg1
), arg1
, arg2
);
1105 set_float_handler (const_binop_error
);
1107 #ifdef REAL_ARITHMETIC
1108 REAL_ARITHMETIC (value
, code
, d1
, d2
);
1125 #ifndef REAL_INFINITY
1134 value
= MIN (d1
, d2
);
1138 value
= MAX (d1
, d2
);
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
);
1149 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1150 if (TREE_CODE (arg1
) == COMPLEX_CST
)
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
);
1161 t
= build_complex (const_binop (PLUS_EXPR
, r1
, r2
),
1162 const_binop (PLUS_EXPR
, i1
, i2
));
1166 t
= build_complex (const_binop (MINUS_EXPR
, r1
, r2
),
1167 const_binop (MINUS_EXPR
, i1
, i2
));
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
)));
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
)),
1190 const_binop (RDIV_EXPR
,
1191 const_binop (MINUS_EXPR
,
1192 const_binop (MULT_EXPR
, i1
, r2
),
1193 const_binop (MULT_EXPR
, r1
, i2
)),
1201 TREE_TYPE (t
) = TREE_TYPE (arg1
);
1207 /* Return an INTEGER_CST with value V and type from `sizetype'. */
1211 unsigned int number
;
1214 /* Type-size nodes already made for small sizes. */
1215 static tree size_table
[2*HOST_BITS_PER_INT
+1];
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)
1221 int temp
= allocation_temporary_p ();
1223 push_obstacks_nochange ();
1224 /* Make this a permanent node. */
1226 end_temporary_allocation ();
1227 t
= build_int_2 (number
, 0);
1228 TREE_TYPE (t
) = sizetype
;
1229 size_table
[number
] = t
;
1234 t
= build_int_2 (number
, 0);
1235 TREE_TYPE (t
) = sizetype
;
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. */
1245 size_binop (code
, arg0
, arg1
)
1246 enum tree_code code
;
1249 /* Handle the special case of two integer constants faster. */
1250 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
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)
1257 if (code
== MINUS_EXPR
1258 && TREE_INT_CST_LOW (arg1
) == 0
1259 && TREE_INT_CST_HIGH (arg1
) == 0)
1261 if (code
== MULT_EXPR
1262 && TREE_INT_CST_LOW (arg0
) == 1
1263 && TREE_INT_CST_HIGH (arg0
) == 0)
1265 /* Handle general case of two integer constants. */
1266 return const_binop (code
, arg0
, arg1
);
1269 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1270 return error_mark_node
;
1272 return fold (build (code
, sizetype
, arg0
, arg1
));
1275 /* Given T, a tree representing type conversion of ARG1, a constant,
1276 return a constant tree representing the result of conversion. */
1279 fold_convert (t
, arg1
)
1283 register tree type
= TREE_TYPE (t
);
1285 if (TREE_CODE (type
) == POINTER_TYPE
1286 || TREE_CODE (type
) == INTEGER_TYPE
1287 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1289 if (TREE_CODE (arg1
) == INTEGER_CST
)
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
;
1298 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1299 else if (TREE_CODE (arg1
) == REAL_CST
)
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
))))
1306 warning ("real constant out of range for integer conversion");
1309 #ifndef REAL_ARITHMETIC
1313 int half_word
= 1 << (HOST_BITS_PER_INT
/ 2);
1315 d
= TREE_REAL_CST (arg1
);
1319 high
= (int) (d
/ half_word
/ half_word
);
1320 d
-= (REAL_VALUE_TYPE
) high
* half_word
* half_word
;
1322 if (TREE_REAL_CST (arg1
) < 0)
1323 neg_double (low
, high
, &low
, &high
);
1324 t
= build_int_2 (low
, high
);
1329 REAL_VALUE_TO_INT (low
, high
, TREE_REAL_CST (arg1
));
1330 t
= build_int_2 (low
, high
);
1333 TREE_TYPE (t
) = type
;
1336 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1337 TREE_TYPE (t
) = type
;
1339 else if (TREE_CODE (type
) == REAL_TYPE
)
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
)));
1349 TREE_CONSTANT (t
) = 1;
1353 /* Return an expr equal to X but certainly not valid as an lvalue. */
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
)
1369 result
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
1370 TREE_CONSTANT (result
) = TREE_CONSTANT (x
);
1374 /* Return nonzero if two operands are necessarily equal.
1375 If ONLY_CONST is non-zero, only return non-zero for constants. */
1378 operand_equal_p (arg0
, arg1
, only_const
)
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
)))
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
;
1397 if (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
))
1400 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
1401 && TREE_CODE (arg0
) == ADDR_EXPR
1402 && TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0))
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
))
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
)))
1422 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
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
)))
1429 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
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
))))
1438 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1439 TREE_OPERAND (arg1
, 0), 0);
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));
1449 switch (TREE_CODE (arg0
))
1452 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1453 TREE_OPERAND (arg1
, 0), 0);
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));
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));
1476 /* Return nonzero if comparing COMP1 with COMP2
1477 gives the same result as comparing OP1 with OP2.
1478 When in doubt, return 0. */
1481 comparison_equiv_p (comp1
, comp2
, op1
, op2
)
1482 tree comp1
, comp2
, op1
, op2
;
1484 int unsignedp1
, unsignedp2
;
1485 tree primop1
, primop2
;
1488 if (operand_equal_p (comp1
, op1
, 0)
1489 && operand_equal_p (comp2
, op2
, 0))
1492 if (TREE_CODE (TREE_TYPE (op1
)) != INTEGER_TYPE
)
1495 if (TREE_TYPE (op1
) != TREE_TYPE (op2
))
1498 if (TREE_TYPE (comp1
) != TREE_TYPE (comp2
))
1501 /* Duplicate what shorten_compare does to the comparison operands,
1502 and see if that gives the actual comparison operands, COMP1 and COMP2. */
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
);
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
)
1514 tree type
= TREE_TYPE (comp1
);
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
)),
1520 primop2
= convert (signed_or_unsigned_type (unsignedp2
, TREE_TYPE (primop2
)),
1523 primop1
= convert (type
, primop1
);
1524 primop2
= convert (type
, primop2
);
1526 if (operand_equal_p (comp1
, primop1
, 0)
1527 && operand_equal_p (comp2
, primop2
, 0))
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).
1538 If OMITTED has side effects, we must evaluate it. Otherwise, just do
1539 the conversion of RESULT to TYPE. */
1542 omit_one_operand (type
, result
, omitted
)
1543 tree type
, result
, omitted
;
1545 tree t
= convert (type
, result
);
1547 if (TREE_SIDE_EFFECTS (omitted
))
1548 return build (COMPOUND_EXPR
, type
, omitted
, t
);
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). */
1558 invert_truthvalue (arg
)
1561 tree type
= TREE_TYPE (arg
);
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
);
1569 switch (TREE_CODE (arg
))
1572 TREE_SET_CODE (arg
, EQ_EXPR
);
1576 TREE_SET_CODE (arg
, NE_EXPR
);
1580 TREE_SET_CODE (arg
, LT_EXPR
);
1584 TREE_SET_CODE (arg
, LE_EXPR
);
1588 TREE_SET_CODE (arg
, GT_EXPR
);
1592 TREE_SET_CODE (arg
, GE_EXPR
);
1596 return convert (type
, build_int_2 (TREE_INT_CST_LOW (arg
) == 0
1597 && TREE_INT_CST_HIGH (arg
) == 0, 0));
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)));
1605 return build (TRUTH_AND_EXPR
, type
,
1606 invert_truthvalue (TREE_OPERAND (arg
, 0)),
1607 invert_truthvalue (TREE_OPERAND (arg
, 1)));
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)));
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)));
1619 case TRUTH_NOT_EXPR
:
1620 return TREE_OPERAND (arg
, 0);
1623 return build (COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
1624 invert_truthvalue (TREE_OPERAND (arg
, 1)),
1625 invert_truthvalue (TREE_OPERAND (arg
, 2)));
1627 case NON_LVALUE_EXPR
:
1628 return invert_truthvalue (TREE_OPERAND (arg
, 0));
1633 return build1 (TREE_CODE (arg
), type
,
1634 invert_truthvalue (TREE_OPERAND (arg
, 0)));
1637 if (! integer_onep (TREE_OPERAND (arg
, 1)))
1639 return build (EQ_EXPR
, type
, arg
, convert (type
, integer_zero_node
));
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.
1652 If this optimization cannot be done, 0 will be returned. */
1655 distribute_bit_expr (code
, type
, arg0
, arg1
)
1656 enum tree_code code
;
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
))
1669 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0))
1671 common
= TREE_OPERAND (arg0
, 0);
1672 left
= TREE_OPERAND (arg0
, 1);
1673 right
= TREE_OPERAND (arg1
, 1);
1675 else if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1), 0))
1677 common
= TREE_OPERAND (arg0
, 0);
1678 left
= TREE_OPERAND (arg0
, 1);
1679 right
= TREE_OPERAND (arg1
, 0);
1681 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 0), 0))
1683 common
= TREE_OPERAND (arg0
, 1);
1684 left
= TREE_OPERAND (arg0
, 0);
1685 right
= TREE_OPERAND (arg1
, 1);
1687 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1), 0))
1689 common
= TREE_OPERAND (arg0
, 1);
1690 left
= TREE_OPERAND (arg0
, 0);
1691 right
= TREE_OPERAND (arg1
, 0);
1696 return fold (build (TREE_CODE (arg0
), type
, common
,
1697 fold (build (code
, type
, left
, right
))));
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. */
1704 make_bit_field_ref (inner
, type
, bitsize
, bitpos
, unsignedp
)
1707 int bitsize
, bitpos
;
1710 tree result
= build (BIT_FIELD_REF
, type
, inner
,
1711 size_int (bitsize
), size_int (bitpos
));
1713 TREE_UNSIGNED (result
) = unsignedp
;
1718 /* Optimize a bit-field compare.
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.
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.
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.
1735 If the optimization described above can be done, we return the resuling
1736 tree. Otherwise we return zero. */
1739 optimize_bit_field_compare (code
, compare_type
, lhs
, rhs
)
1740 enum tree_code code
;
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
;
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
))
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
);
1770 if (lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
1771 || lunsignedp
!= runsignedp
)
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
,
1780 if (lnmode
== VOIDmode
)
1783 /* Set signed and unsigned types of the precision of this mode for the
1785 signed_type
= type_for_mode (lnmode
, 0);
1786 unsigned_type
= type_for_mode (lnmode
, 1);
1790 rnmode
= get_best_mode (rbitsize
, rbitpos
,
1791 TYPE_ALIGN (TREE_TYPE (rinner
)), word_mode
,
1793 if (rnmode
== VOIDmode
)
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
)
1808 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
1809 rnbitpos
= rbitpos
& ~ (rnbitsize
- 1);
1810 rbitpos
-= rnbitpos
;
1811 if (rnbitsize
== rbitsize
)
1815 #if BYTES_BIG_ENDIAN
1816 lbitpos
= lnbitsize
- lbitsize
- lbitpos
;
1817 rbitpos
= rnbitsize
- rbitsize
- rbitpos
;
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
));
1827 /* If not comparing with constant, just rework the comparison
1829 return build (code
, compare_type
,
1830 build (BIT_AND_EXPR
, type
,
1831 make_bit_field_ref (linner
, type
,
1832 lnbitsize
, lnbitpos
, lunsignedp
),
1834 build (BIT_AND_EXPR
, type
,
1835 make_bit_field_ref (rinner
, type
,
1836 rnbitsize
, rnbitpos
, runsignedp
),
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.
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
1850 if (! integer_zerop (const_binop (RSHIFT_EXPR
,
1851 convert (unsigned_type
, rhs
),
1852 size_int (lbitsize
))))
1854 warning ("comparison is always %s due to width of bitfield",
1855 code
== NE_EXPR
? "one" : "zero");
1856 return convert (compare_type
,
1858 ? integer_one_node
: integer_zero_node
));
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
))
1867 warning ("comparison is always %s due to width of bitfield",
1868 code
== NE_EXPR
? "one" : "zero");
1869 return convert (compare_type
,
1871 ? integer_one_node
: integer_zero_node
));
1875 /* Single-bit compares should always be against zero. */
1876 if (lbitsize
== 1 && ! integer_zerop (rhs
))
1878 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
1879 rhs
= convert (type
, integer_zero_node
);
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
,
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
)));
1894 return build (code
, compare_type
,
1895 build (BIT_AND_EXPR
, type
, lhs
, mask
),
1899 /* Subroutine for the following routine: decode a field reference.
1901 If EXP is a comparison reference, we return the innermost reference.
1903 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
1904 set to the starting bit number.
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.
1909 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
1910 otherwise it is not changed.
1912 *PUNSIGNEDP is set to the signedness of the field.
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.
1917 Return 0 if this is not a component reference or is one that we can't
1918 do anything with. */
1921 decode_field_reference (exp
, pbitsize
, pbitpos
, pmode
, punsignedp
,
1924 int *pbitsize
, *pbitpos
;
1925 enum machine_mode
*pmode
;
1926 int *punsignedp
, *pvolatilep
;
1934 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
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
)
1943 if (TREE_CODE (exp
) != COMPONENT_REF
&& TREE_CODE (exp
) != ARRAY_REF
1944 && TREE_CODE (exp
) != BIT_FIELD_REF
)
1947 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, pmode
,
1948 punsignedp
, pvolatilep
);
1952 tree unsigned_type
= type_for_size (*pbitsize
, 1);
1953 int precision
= TYPE_PRECISION (unsigned_type
);
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
));
1964 /* Return non-zero if MASK respresents a mask of SIZE ones in the low-order
1968 all_ones_mask_p (mask
, size
)
1972 tree type
= TREE_TYPE (mask
);
1973 int precision
= TYPE_PRECISION (type
);
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);
1985 /* Try to merge two comparisons to the same innermost item.
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.
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.
1994 We check for both normal comparisons and the BIT_AND_EXPRs made this by
1995 function and the one above.
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.
2000 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
2003 We return the simplified tree or 0 if no optimization is possible. */
2006 merge_component_references (code
, truth_type
, lhs
, rhs
)
2007 enum tree_code code
;
2008 tree truth_type
, lhs
, rhs
;
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).
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. */
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;
2033 int first_bit
, end_bit
;
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. */
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
))
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
);
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
2064 if (volatilep
|| ll_inner
== 0 || rl_inner
== 0
2065 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
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))
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
)
2080 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
2086 if (rcode
!= wanted_code
)
2088 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
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
,
2102 if (lnmode
== VOIDmode
)
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
;
2110 #if BYTES_BIG_ENDIAN
2111 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
2112 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
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
));
2120 /* Make sure the constants are interpreted as unsigned, so we
2121 don't have sign bits outside the range of their type. */
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
));
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
));
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. */
2141 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
2142 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
)
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
,
2150 if (rnmode
== VOIDmode
)
2153 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
2154 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
2155 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
2157 #if BYTES_BIG_ENDIAN
2158 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
2159 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
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
));
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
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
)
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
))
2181 lhs
= build (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
2182 rhs
= build (BIT_AND_EXPR
, type
, rhs
, ll_mask
);
2184 return build (wanted_code
, truth_type
, lhs
, rhs
);
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
),
2199 make_bit_field_ref (lr_inner
, type
,
2200 lr_bitsize
+ rr_bitsize
,
2201 MIN (lr_bitpos
, rr_bitpos
),
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)
2216 if (wanted_code
== NE_EXPR
)
2218 warning ("`or' of unmatched not-equal tests is always 1");
2219 return convert (truth_type
, integer_one_node
);
2223 warning ("`and' of mutually exclusive equal-tests is always zero");
2224 return convert (truth_type
, integer_zero_node
);
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
2232 result
= make_bit_field_ref (ll_inner
, type
, lnbitsize
, lnbitpos
,
2233 ll_unsignedp
|| rl_unsignedp
);
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
);
2239 return build (wanted_code
, truth_type
, result
,
2240 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
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. */
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
);
2262 /* WINS will be nonzero when the switch is done
2263 if all operands are constant. */
2267 /* Return right away if already constant. */
2268 if (TREE_CONSTANT (t
))
2270 if (code
== CONST_DECL
)
2271 return DECL_INITIAL (t
);
2275 kind
= TREE_CODE_CLASS (code
);
2276 if (kind
== 'e' || kind
== '<' || kind
== '1' || kind
== '2' || kind
== 'r')
2278 register int len
= tree_code_length
[(int) code
];
2280 for (i
= 0; i
< len
; i
++)
2282 tree op
= TREE_OPERAND (t
, i
);
2285 continue; /* Valid for CALL_EXPR, at least. */
2287 /* Strip any conversions that don't change the mode. */
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 */
2295 /* Note that TREE_CONSTANT isn't enough:
2296 static var addresses are constant but we can't
2297 do arithmetic on them. */
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
))
2315 arg0
= arg1
; arg1
= tem
;
2317 TREE_OPERAND (t
, 0) = arg0
;
2318 TREE_OPERAND (t
, 1) = arg1
;
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).
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
2331 if (TREE_CODE_CLASS (code
) == '1')
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
))));
2345 else if (TREE_CODE_CLASS (code
) == '2')
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
)) == '<')
2353 tree test
, true_value
, false_value
;
2355 if (TREE_CODE (arg1
) == COND_EXPR
)
2357 test
= TREE_OPERAND (arg1
, 0);
2358 true_value
= TREE_OPERAND (arg1
, 1);
2359 false_value
= TREE_OPERAND (arg1
, 2);
2364 true_value
= integer_one_node
;
2365 false_value
= integer_zero_node
;
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
);
2377 return convert (type
, test
);
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
)) == '<')
2386 tree test
, true_value
, false_value
;
2388 if (TREE_CODE (arg0
) == COND_EXPR
)
2390 test
= TREE_OPERAND (arg0
, 0);
2391 true_value
= TREE_OPERAND (arg0
, 1);
2392 false_value
= TREE_OPERAND (arg0
, 2);
2397 true_value
= integer_one_node
;
2398 false_value
= integer_zero_node
;
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
);
2410 return convert (type
, test
);
2424 return fold (DECL_INITIAL (t
));
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)))
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)))))
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)))
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));
2460 if (TREE_CODE (TREE_OPERAND (t
, 0)) == MODIFY_EXPR
2461 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)))
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
));
2473 TREE_CONSTANT (t
) = TREE_CONSTANT (arg0
);
2476 return fold_convert (t
, arg0
);
2478 #if 0 /* This loses on &"foo"[0]. */
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
))
2489 t
= build_int_2 (TREE_STRING_POINTER (arg0
)[i
], 0);
2490 TREE_TYPE (t
) = TREE_TYPE (TREE_TYPE (arg0
));
2498 TREE_CONSTANT (t
) = wins
;
2504 if (TREE_CODE (arg0
) == INTEGER_CST
)
2506 if (TREE_INT_CST_LOW (arg0
) == 0)
2507 t
= build_int_2 (0, - TREE_INT_CST_HIGH (arg0
));
2509 t
= build_int_2 (- TREE_INT_CST_LOW (arg0
),
2510 ~ TREE_INT_CST_HIGH (arg0
));
2511 TREE_TYPE (t
) = type
;
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
;
2518 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
2519 return TREE_OPERAND (arg0
, 0);
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));
2531 if (TREE_CODE (arg0
) == INTEGER_CST
)
2533 if (! TREE_UNSIGNED (type
)
2534 && TREE_INT_CST_HIGH (arg0
) < 0)
2536 if (TREE_INT_CST_LOW (arg0
) == 0)
2537 t
= build_int_2 (0, - TREE_INT_CST_HIGH (arg0
));
2539 t
= build_int_2 (- TREE_INT_CST_LOW (arg0
),
2540 ~ TREE_INT_CST_HIGH (arg0
));
2543 else if (TREE_CODE (arg0
) == REAL_CST
)
2545 if (REAL_VALUES_LESS (TREE_REAL_CST (arg0
), dconst0
))
2546 t
= build_real (type
,
2547 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0
)));
2549 TREE_TYPE (t
) = type
;
2551 else if (TREE_CODE (arg0
) == ABS_EXPR
|| TREE_CODE (arg0
) == NEGATE_EXPR
)
2552 return build1 (ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
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
;
2564 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
2565 return TREE_OPERAND (arg0
, 0);
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
)
2574 if (integer_zerop (arg1
))
2575 return non_lvalue (convert (type
, arg0
));
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
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))))
2589 code
= BIT_IOR_EXPR
;
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
));
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
)
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. */
2611 if (split_tree (arg0
, code
, &var
, &con
, &varsign
))
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
);
2620 /* Otherwise return (CON +- ARG1) - VAR. */
2621 TREE_SET_CODE (t
, MINUS_EXPR
);
2622 TREE_OPERAND (t
, 1) = var
;
2624 = fold (build (code
, TREE_TYPE (t
), con
, arg1
));
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
);
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
)
2647 tree tem1
= TREE_OPERAND (tem
, 1);
2648 TREE_OPERAND (tem
, 1) = TREE_OPERAND (tem
, 0);
2649 TREE_OPERAND (tem
, 0) = tem1
;
2651 (code
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
));
2657 if (split_tree (arg1
, code
, &var
, &con
, &varsign
))
2659 /* EXPR is ARG0 +- (CON +- VAR). */
2662 (code
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
));
2663 if (TREE_CODE (t
) == MINUS_EXPR
2664 && operand_equal_p (var
, arg0
, 0))
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
)));
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
);
2682 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
2683 if (TREE_CODE (arg1
) == REAL_CST
)
2685 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
2687 t1
= const_binop (code
, arg0
, arg1
);
2688 if (t1
!= NULL_TREE
)
2690 /* The return value should always have
2691 the same type as the original expression. */
2692 TREE_TYPE (t1
) = TREE_TYPE (t
);
2698 if (TREE_CODE (type
) != REAL_TYPE
)
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
));
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)));
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
));
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
2721 if (operand_equal_p (arg0
, arg1
,
2722 TREE_CODE (type
) == REAL_TYPE
))
2723 return convert (type
, integer_zero_node
);
2727 if (TREE_CODE (type
) != REAL_TYPE
)
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
));
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)));
2744 /* In IEEE floating point, these optimizations are not correct. */
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
));
2756 if (! wins
&& real_twop (arg1
))
2758 tree arg
= save_expr (arg0
);
2759 return build (PLUS_EXPR
, type
, arg
, arg
);
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
)
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
));
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
)
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))))
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));
2800 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
2801 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
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));
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
)
2817 arg1
= fold (build1 (BIT_NOT_EXPR
, type
, arg1
));
2818 code
= BIT_AND_EXPR
;
2823 case TRUNC_DIV_EXPR
:
2824 case ROUND_DIV_EXPR
:
2825 case FLOOR_DIV_EXPR
:
2827 case EXACT_DIV_EXPR
:
2829 if (integer_onep (arg1
))
2830 return non_lvalue (convert (type
, arg0
));
2831 if (integer_zerop (arg1
))
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
))
2839 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
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
))
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
))
2866 if (operand_equal_p (arg0
, arg1
, 0))
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
);
2874 if (operand_equal_p (arg0
, arg1
, 0))
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
);
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
);
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
))
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
)
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. */
2913 if (TREE_CODE (arg0
) == code
)
2915 tem
= merge_component_references (code
, type
,
2916 TREE_OPERAND (arg0
, 1), arg1
);
2918 return fold (build (code
, type
, TREE_OPERAND (arg0
, 0), tem
));
2921 tem
= merge_component_references (code
, type
, arg0
, arg1
);
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
))
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
)
2951 /* If one arg is a constant integer, put it last. */
2952 if (TREE_CODE (arg0
) == INTEGER_CST
2953 && TREE_CODE (arg1
) != INTEGER_CST
)
2955 TREE_OPERAND (t
, 0) = arg1
;
2956 TREE_OPERAND (t
, 1) = arg0
;
2957 arg0
= TREE_OPERAND (t
, 0);
2958 arg1
= TREE_OPERAND (t
, 1);
2974 TREE_SET_CODE (t
, code
);
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. */
2981 tree constop
= 0, varop
;
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
;
2989 if (constop
&& TREE_CODE (varop
) == POSTINCREMENT_EXPR
)
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
)
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
)))
3006 TREE_SET_CODE (varop
, PREINCREMENT_EXPR
);
3007 *constoploc
= newconst
;
3012 else if (constop
&& TREE_CODE (varop
) == POSTDECREMENT_EXPR
)
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
)
3020 if (TREE_CODE (TREE_TYPE (newconst
)) != REAL_TYPE
3021 || !REAL_VALUES_EQUAL (TREE_REAL_CST (newconst
),
3022 TREE_REAL_CST (constop
)))
3024 TREE_SET_CODE (varop
, PREDECREMENT_EXPR
);
3025 *constoploc
= newconst
;
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
))
3037 switch (TREE_CODE (t
))
3041 TREE_SET_CODE (t
, code
);
3042 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
3043 TREE_OPERAND (t
, 1) = arg1
;
3048 TREE_SET_CODE (t
, code
);
3049 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
3050 TREE_OPERAND (t
, 1) = arg1
;
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
3059 if (TREE_CODE (arg1
) == INTEGER_CST
)
3061 tree comparison
= arg0
;
3063 while (TREE_CODE (comparison
) == NOP_EXPR
3064 || TREE_CODE (comparison
) == CONVERT_EXPR
)
3065 comparison
= TREE_OPERAND (comparison
, 0);
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
)
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. */
3083 char *actions
, action
;
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];
3114 action
= actions
[3];
3119 return omit_one_operand (type
, integer_zero_node
,
3123 return omit_one_operand (type
, integer_one_node
, comparison
);
3126 return convert (type
, comparison
);
3129 return convert (type
, invert_truthvalue (comparison
));
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
)
3145 if (TREE_CODE (TREE_OPERAND (arg0
, 0)) == LSHIFT_EXPR
3146 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0)))
3148 fold (build (code
, type
,
3149 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
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
),
3157 else if (TREE_CODE (TREE_OPERAND (arg0
, 1)) == LSHIFT_EXPR
3158 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 1), 0)))
3160 fold (build (code
, type
,
3161 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
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
),
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
);
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
);
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
)
3197 t
= build_int_2 (1, 0);
3198 TREE_TYPE (t
) = type
;
3203 t
= build_int_2 (0, 0);
3204 TREE_TYPE (t
) = type
;
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
)))
3215 switch (TREE_CODE (t
))
3218 TREE_SET_CODE (t
, NE_EXPR
);
3221 TREE_SET_CODE (t
, EQ_EXPR
);
3224 return omit_one_operand (integer_type_node
,
3225 integer_one_node
, arg0
);
3227 return omit_one_operand (integer_type_node
,
3228 integer_zero_node
, arg0
);
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
)
3238 register tree temp
= arg0
;
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
)
3248 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3250 (TREE_INT_CST_LOW (arg0
) == TREE_INT_CST_LOW (arg1
)
3251 && TREE_INT_CST_HIGH (arg0
) == TREE_INT_CST_HIGH (arg1
),
3254 t
= build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0
))
3255 ? INT_CST_LT_UNSIGNED (arg0
, arg1
)
3256 : INT_CST_LT (arg0
, arg1
)),
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
))
3269 t
= build_int_2 (0, 0);
3271 /* Two real constants can be compared explicitly. */
3272 else if (TREE_CODE (arg0
) == REAL_CST
3273 && TREE_CODE (arg1
) == REAL_CST
)
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
)),
3280 t
= build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0
),
3281 TREE_REAL_CST (arg1
)),
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
))
3291 tree tem
= optimize_bit_field_compare (code
, type
, arg0
, arg1
);
3292 return tem
? tem
: t
;
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
;
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
))
3314 else if (integer_zerop (arg1
) && integer_onep (TREE_OPERAND (t
, 2)))
3315 return convert (type
, invert_truthvalue (arg0
));
3317 /* If we have (a >= 0 ? a : -a) or the same with ">", this is an
3318 absolute value expression. */
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
));
3327 /* Similarly for (a <= 0 ? -a : a). */
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)));
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. */
3339 if (TREE_CODE (arg0
) == GT_EXPR
|| TREE_CODE (arg0
) == GE_EXPR
3340 || TREE_CODE (arg0
) == LT_EXPR
|| TREE_CODE (arg0
) == LE_EXPR
)
3342 tree hi_true
, lo_true
;
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);
3347 hi_true
= TREE_OPERAND (arg0
, 1), lo_true
= TREE_OPERAND (arg0
, 0);
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)));
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.
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.
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. */
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
))
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);
3384 arg0
= TREE_OPERAND (arg0
, 0);
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
);
3396 if (!TREE_SIDE_EFFECTS (arg0
))
3402 } /* switch (code) */
This page took 0.19716 seconds and 4 git commands to generate.