]>
gcc.gnu.org Git - gcc.git/blob - gcc/fold-const.c
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 whether an IEEE double precision number is a NaN. */
747 /* The IEEE 64-bit double format. */
752 unsigned exponent
: 11;
753 unsigned mantissa1
: 20;
758 unsigned mantissa1
: 20;
759 unsigned exponent
: 11;
765 if (u
.big_endian
.sign
== 1)
768 return (u
.big_endian
.exponent
== 2047
769 && (u
.big_endian
.mantissa1
!= 0
770 || u
.big_endian
.mantissa2
!= 0));
775 return (u
.little_endian
.exponent
== 2047
776 && (u
.little_endian
.mantissa1
!= 0
777 || u
.little_endian
.mantissa2
!= 0));
781 /* Check for minus zero in an IEEE double precision number. */
784 target_minus_zero (x
)
787 REAL_VALUE_TYPE d1
, d2
;
789 d1
= REAL_VALUE_NEGATE (x
);
792 return !bcmp (&d1
, &d2
, sizeof (d1
));
794 #else /* Target not IEEE */
796 /* Let's assume other float formats don't have infinity.
797 (This can be overridden by redefining REAL_VALUE_ISINF.) */
805 /* Let's assume other float formats don't have NaNs.
806 (This can be overridden by redefining REAL_VALUE_ISNAN.) */
814 /* Let's assume other float formats don't have minus zero.
815 (This can be overridden by redefining REAL_VALUE_MINUS_ZERO.) */
817 target_minus_zero (x
)
822 #endif /* Target not IEEE */
824 /* Split a tree IN into a constant and a variable part
825 that could be combined with CODE to make IN.
826 CODE must be a commutative arithmetic operation.
827 Store the constant part into *CONP and the variable in &VARP.
828 Return 1 if this was done; zero means the tree IN did not decompose
831 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
832 Therefore, we must tell the caller whether the variable part
833 was subtracted. We do this by storing 1 or -1 into *VARSIGNP.
834 The value stored is the coefficient for the variable term.
835 The constant term we return should always be added;
836 we negate it if necessary. */
839 split_tree (in
, code
, varp
, conp
, varsignp
)
845 register tree outtype
= TREE_TYPE (in
);
849 /* Strip any conversions that don't change the machine mode. */
850 while ((TREE_CODE (in
) == NOP_EXPR
851 || TREE_CODE (in
) == CONVERT_EXPR
)
852 && (TYPE_MODE (TREE_TYPE (in
))
853 == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in
, 0)))))
854 in
= TREE_OPERAND (in
, 0);
856 if (TREE_CODE (in
) == code
857 || (TREE_CODE (TREE_TYPE (in
)) != REAL_TYPE
858 /* We can associate addition and subtraction together
859 (even though the C standard doesn't say so)
860 for integers because the value is not affected.
861 For reals, the value might be affected, so we can't. */
863 ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
864 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
866 enum tree_code code
= TREE_CODE (TREE_OPERAND (in
, 0));
867 if (code
== INTEGER_CST
)
869 *conp
= TREE_OPERAND (in
, 0);
870 *varp
= TREE_OPERAND (in
, 1);
871 if (TYPE_MODE (TREE_TYPE (*varp
)) != TYPE_MODE (outtype
)
872 && TREE_TYPE (*varp
) != outtype
)
873 *varp
= convert (outtype
, *varp
);
874 *varsignp
= (TREE_CODE (in
) == MINUS_EXPR
) ? -1 : 1;
877 if (TREE_CONSTANT (TREE_OPERAND (in
, 1)))
879 *conp
= TREE_OPERAND (in
, 1);
880 *varp
= TREE_OPERAND (in
, 0);
882 if (TYPE_MODE (TREE_TYPE (*varp
)) != TYPE_MODE (outtype
)
883 && TREE_TYPE (*varp
) != outtype
)
884 *varp
= convert (outtype
, *varp
);
885 if (TREE_CODE (in
) == MINUS_EXPR
)
887 /* If operation is subtraction and constant is second,
888 must negate it to get an additive constant.
889 And this cannot be done unless it is a manifest constant.
890 It could also be the address of a static variable.
891 We cannot negate that, so give up. */
892 if (TREE_CODE (*conp
) == INTEGER_CST
)
893 /* Subtracting from integer_zero_node loses for long long. */
894 *conp
= fold (build1 (NEGATE_EXPR
, TREE_TYPE (*conp
), *conp
));
900 if (TREE_CONSTANT (TREE_OPERAND (in
, 0)))
902 *conp
= TREE_OPERAND (in
, 0);
903 *varp
= TREE_OPERAND (in
, 1);
904 if (TYPE_MODE (TREE_TYPE (*varp
)) != TYPE_MODE (outtype
)
905 && TREE_TYPE (*varp
) != outtype
)
906 *varp
= convert (outtype
, *varp
);
907 *varsignp
= (TREE_CODE (in
) == MINUS_EXPR
) ? -1 : 1;
914 /* Combine two constants NUM and ARG2 under operation CODE
915 to produce a new constant.
916 We assume ARG1 and ARG2 have the same data type,
917 or at least are the same kind of constant and the same machine mode. */
919 /* Handle floating overflow for `const_binop'. */
920 static jmp_buf const_binop_error
;
923 const_binop (code
, arg1
, arg2
)
925 register tree arg1
, arg2
;
927 if (TREE_CODE (arg1
) == INTEGER_CST
)
929 register int int1l
= TREE_INT_CST_LOW (arg1
);
930 register int int1h
= TREE_INT_CST_HIGH (arg1
);
931 int int2l
= TREE_INT_CST_LOW (arg2
);
932 int int2h
= TREE_INT_CST_HIGH (arg2
);
934 int garbagel
, garbageh
;
936 int uns
= TREE_UNSIGNED (TREE_TYPE (arg1
));
941 t
= build_int_2 (int1l
| int2l
, int1h
| int2h
);
945 t
= build_int_2 (int1l
^ int2l
, int1h
^ int2h
);
949 t
= build_int_2 (int1l
& int2l
, int1h
& int2h
);
953 t
= build_int_2 (int1l
& ~int2l
, int1h
& ~int2h
);
959 lshift_double (int1l
, int1h
, int2l
,
960 TYPE_PRECISION (TREE_TYPE (arg1
)),
963 t
= build_int_2 (low
, hi
);
969 lrotate_double (int1l
, int1h
, int2l
,
970 TYPE_PRECISION (TREE_TYPE (arg1
)),
972 t
= build_int_2 (low
, hi
);
979 if ((unsigned) int2l
< int1l
)
981 t
= build_int_2 (int2l
, int2h
);
987 if ((unsigned) int1l
< int2l
)
989 t
= build_int_2 (int1l
, int1h
);
992 add_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
993 t
= build_int_2 (low
, hi
);
997 if (int2h
== 0 && int2l
== 0)
999 t
= build_int_2 (int1l
, int1h
);
1002 neg_double (int2l
, int2h
, &int2l
, &int2h
);
1003 add_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
1004 t
= build_int_2 (low
, hi
);
1008 /* Optimize simple cases. */
1016 t
= build_int_2 (0, 0);
1019 t
= build_int_2 (int2l
, int2h
);
1022 temp
= int2l
+ int2l
;
1023 int2h
= int2h
* 2 + (temp
< int2l
);
1024 t
= build_int_2 (temp
, int2h
);
1027 temp
= int2l
+ int2l
+ int2l
;
1028 int2h
= int2h
* 3 + (temp
< int2l
);
1029 t
= build_int_2 (temp
, int2h
);
1032 temp
= int2l
+ int2l
;
1033 int2h
= int2h
* 4 + ((temp
< int2l
) << 1);
1036 int2h
+= (temp
< int2l
);
1037 t
= build_int_2 (temp
, int2h
);
1040 temp
= int2l
+ int2l
;
1041 int2h
= int2h
* 8 + ((temp
< int2l
) << 2);
1044 int2h
+= (temp
< int2l
) << 1;
1047 int2h
+= (temp
< int2l
);
1048 t
= build_int_2 (temp
, int2h
);
1059 t
= build_int_2 (0, 0);
1064 t
= build_int_2 (int1l
, int1h
);
1069 mul_double (int1l
, int1h
, int2l
, int2h
, &low
, &hi
);
1070 t
= build_int_2 (low
, hi
);
1073 case TRUNC_DIV_EXPR
:
1074 case FLOOR_DIV_EXPR
: case CEIL_DIV_EXPR
:
1075 case EXACT_DIV_EXPR
:
1076 /* This is a shortcut for a common special case.
1077 It reduces the number of tree nodes generated
1079 if (int2h
== 0 && int2l
> 0
1080 && TREE_TYPE (arg1
) == sizetype
1081 && int1h
== 0 && int1l
>= 0)
1083 if (code
== CEIL_DIV_EXPR
)
1085 return size_int (int1l
/ int2l
);
1087 case ROUND_DIV_EXPR
:
1088 if (int2h
== 0 && int2l
== 1)
1090 t
= build_int_2 (int1l
, int1h
);
1093 if (int1l
== int2l
&& int1h
== int2h
)
1095 if ((int1l
| int1h
) == 0)
1097 t
= build_int_2 (1, 0);
1100 div_and_round_double (code
, uns
, int1l
, int1h
, int2l
, int2h
,
1101 &low
, &hi
, &garbagel
, &garbageh
);
1102 t
= build_int_2 (low
, hi
);
1105 case TRUNC_MOD_EXPR
: case ROUND_MOD_EXPR
:
1106 case FLOOR_MOD_EXPR
: case CEIL_MOD_EXPR
:
1107 div_and_round_double (code
, uns
, int1l
, int1h
, int2l
, int2h
,
1108 &garbagel
, &garbageh
, &low
, &hi
);
1109 t
= build_int_2 (low
, hi
);
1116 low
= (((unsigned) int1h
< (unsigned) int2h
)
1117 || (((unsigned) int1h
== (unsigned) int2h
)
1118 && ((unsigned) int1l
< (unsigned) int2l
)));
1122 low
= ((int1h
< int2h
)
1123 || ((int1h
== int2h
)
1124 && ((unsigned) int1l
< (unsigned) int2l
)));
1126 if (low
== (code
== MIN_EXPR
))
1127 t
= build_int_2 (int1l
, int1h
);
1129 t
= build_int_2 (int2l
, int2h
);
1136 TREE_TYPE (t
) = TREE_TYPE (arg1
);
1140 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1141 if (TREE_CODE (arg1
) == REAL_CST
)
1143 register REAL_VALUE_TYPE d1
;
1144 register REAL_VALUE_TYPE d2
;
1145 register REAL_VALUE_TYPE value
;
1147 d1
= TREE_REAL_CST (arg1
);
1148 d2
= TREE_REAL_CST (arg2
);
1149 if (setjmp (const_binop_error
))
1151 warning ("floating overflow in constant folding");
1152 return build (code
, TREE_TYPE (arg1
), arg1
, arg2
);
1154 set_float_handler (const_binop_error
);
1156 #ifdef REAL_ARITHMETIC
1157 REAL_ARITHMETIC (value
, code
, d1
, d2
);
1174 #ifndef REAL_INFINITY
1183 value
= MIN (d1
, d2
);
1187 value
= MAX (d1
, d2
);
1193 #endif /* no REAL_ARITHMETIC */
1194 set_float_handler (0);
1195 return build_real (TREE_TYPE (arg1
),
1196 REAL_VALUE_TRUNCATE (TYPE_MODE (TREE_TYPE (arg1
)), value
));
1198 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1199 if (TREE_CODE (arg1
) == COMPLEX_CST
)
1201 register tree r1
= TREE_REALPART (arg1
);
1202 register tree i1
= TREE_IMAGPART (arg1
);
1203 register tree r2
= TREE_REALPART (arg2
);
1204 register tree i2
= TREE_IMAGPART (arg2
);
1210 t
= build_complex (const_binop (PLUS_EXPR
, r1
, r2
),
1211 const_binop (PLUS_EXPR
, i1
, i2
));
1215 t
= build_complex (const_binop (MINUS_EXPR
, r1
, r2
),
1216 const_binop (MINUS_EXPR
, i1
, i2
));
1220 t
= build_complex (const_binop (MINUS_EXPR
,
1221 const_binop (MULT_EXPR
, r1
, r2
),
1222 const_binop (MULT_EXPR
, i1
, i2
)),
1223 const_binop (PLUS_EXPR
,
1224 const_binop (MULT_EXPR
, r1
, i2
),
1225 const_binop (MULT_EXPR
, i1
, r2
)));
1230 register tree magsquared
1231 = const_binop (PLUS_EXPR
,
1232 const_binop (MULT_EXPR
, r2
, r2
),
1233 const_binop (MULT_EXPR
, i2
, i2
));
1234 t
= build_complex (const_binop (RDIV_EXPR
,
1235 const_binop (PLUS_EXPR
,
1236 const_binop (MULT_EXPR
, r1
, r2
),
1237 const_binop (MULT_EXPR
, i1
, i2
)),
1239 const_binop (RDIV_EXPR
,
1240 const_binop (MINUS_EXPR
,
1241 const_binop (MULT_EXPR
, i1
, r2
),
1242 const_binop (MULT_EXPR
, r1
, i2
)),
1250 TREE_TYPE (t
) = TREE_TYPE (arg1
);
1256 /* Return an INTEGER_CST with value V and type from `sizetype'. */
1260 unsigned int number
;
1263 /* Type-size nodes already made for small sizes. */
1264 static tree size_table
[2*HOST_BITS_PER_INT
+1];
1266 if (number
>= 0 && number
< 2*HOST_BITS_PER_INT
+1 && size_table
[number
] != 0)
1267 return size_table
[number
];
1268 if (number
>= 0 && number
< 2*HOST_BITS_PER_INT
+1)
1270 int temp
= allocation_temporary_p ();
1272 push_obstacks_nochange ();
1273 /* Make this a permanent node. */
1275 end_temporary_allocation ();
1276 t
= build_int_2 (number
, 0);
1277 TREE_TYPE (t
) = sizetype
;
1278 size_table
[number
] = t
;
1283 t
= build_int_2 (number
, 0);
1284 TREE_TYPE (t
) = sizetype
;
1289 /* Combine operands OP1 and OP2 with arithmetic operation CODE.
1290 CODE is a tree code. Data type is taken from `sizetype',
1291 If the operands are constant, so is the result. */
1294 size_binop (code
, arg0
, arg1
)
1295 enum tree_code code
;
1298 /* Handle the special case of two integer constants faster. */
1299 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1301 /* And some specific cases even faster than that. */
1302 if (code
== PLUS_EXPR
1303 && TREE_INT_CST_LOW (arg0
) == 0
1304 && TREE_INT_CST_HIGH (arg0
) == 0)
1306 if (code
== MINUS_EXPR
1307 && TREE_INT_CST_LOW (arg1
) == 0
1308 && TREE_INT_CST_HIGH (arg1
) == 0)
1310 if (code
== MULT_EXPR
1311 && TREE_INT_CST_LOW (arg0
) == 1
1312 && TREE_INT_CST_HIGH (arg0
) == 0)
1314 /* Handle general case of two integer constants. */
1315 return const_binop (code
, arg0
, arg1
);
1318 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1319 return error_mark_node
;
1321 return fold (build (code
, sizetype
, arg0
, arg1
));
1324 /* Given T, a tree representing type conversion of ARG1, a constant,
1325 return a constant tree representing the result of conversion. */
1328 fold_convert (t
, arg1
)
1332 register tree type
= TREE_TYPE (t
);
1334 if (TREE_CODE (type
) == POINTER_TYPE
1335 || TREE_CODE (type
) == INTEGER_TYPE
1336 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1338 if (TREE_CODE (arg1
) == INTEGER_CST
)
1340 /* Given an integer constant, make new constant with new type,
1341 appropriately sign-extended or truncated. */
1342 t
= build_int_2 (TREE_INT_CST_LOW (arg1
),
1343 TREE_INT_CST_HIGH (arg1
));
1344 TREE_TYPE (t
) = type
;
1347 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1348 else if (TREE_CODE (arg1
) == REAL_CST
)
1350 if (REAL_VALUES_LESS (real_value_from_int_cst (TYPE_MAX_VALUE (type
)),
1351 TREE_REAL_CST (arg1
))
1352 || REAL_VALUES_LESS (TREE_REAL_CST (arg1
),
1353 real_value_from_int_cst (TYPE_MIN_VALUE (type
))))
1355 warning ("real constant out of range for integer conversion");
1358 #ifndef REAL_ARITHMETIC
1362 int half_word
= 1 << (HOST_BITS_PER_INT
/ 2);
1364 d
= TREE_REAL_CST (arg1
);
1368 high
= (int) (d
/ half_word
/ half_word
);
1369 d
-= (REAL_VALUE_TYPE
) high
* half_word
* half_word
;
1371 if (TREE_REAL_CST (arg1
) < 0)
1372 neg_double (low
, high
, &low
, &high
);
1373 t
= build_int_2 (low
, high
);
1378 REAL_VALUE_TO_INT (low
, high
, TREE_REAL_CST (arg1
));
1379 t
= build_int_2 (low
, high
);
1382 TREE_TYPE (t
) = type
;
1385 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1386 TREE_TYPE (t
) = type
;
1388 else if (TREE_CODE (type
) == REAL_TYPE
)
1390 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1391 if (TREE_CODE (arg1
) == INTEGER_CST
)
1392 return build_real_from_int_cst (type
, arg1
);
1393 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1394 if (TREE_CODE (arg1
) == REAL_CST
)
1395 return build_real (type
, REAL_VALUE_TRUNCATE (TYPE_MODE (type
),
1396 TREE_REAL_CST (arg1
)));
1398 TREE_CONSTANT (t
) = 1;
1402 /* Return an expr equal to X but certainly not valid as an lvalue. */
1410 /* These things are certainly not lvalues. */
1411 if (TREE_CODE (x
) == NON_LVALUE_EXPR
1412 || TREE_CODE (x
) == INTEGER_CST
1413 || TREE_CODE (x
) == REAL_CST
1414 || TREE_CODE (x
) == STRING_CST
1415 || TREE_CODE (x
) == ADDR_EXPR
)
1418 result
= build1 (NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
1419 TREE_CONSTANT (result
) = TREE_CONSTANT (x
);
1423 /* Return nonzero if two operands are necessarily equal.
1424 If ONLY_CONST is non-zero, only return non-zero for constants. */
1427 operand_equal_p (arg0
, arg1
, only_const
)
1431 /* If both types don't have the same signedness, then we can't consider
1432 them equal. We must check this before the STRIP_NOPS calls
1433 because they may change the signedness of the arguments. */
1434 if (TREE_UNSIGNED (TREE_TYPE (arg0
)) != TREE_UNSIGNED (TREE_TYPE (arg1
)))
1440 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
1441 We don't care about side effects in that case because the SAVE_EXPR
1442 takes care of that for us. */
1443 if (TREE_CODE (arg0
) == SAVE_EXPR
&& arg0
== arg1
)
1444 return ! only_const
;
1446 if (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
))
1449 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
1450 && TREE_CODE (arg0
) == ADDR_EXPR
1451 && TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0))
1454 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
1455 && TREE_CODE (arg0
) == INTEGER_CST
1456 && TREE_INT_CST_LOW (arg0
) == TREE_INT_CST_LOW (arg1
)
1457 && TREE_INT_CST_HIGH (arg0
) == TREE_INT_CST_HIGH (arg1
))
1460 /* Detect when real constants are equal.
1461 But reject weird values because we can't be sure what to do with them. */
1462 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
1463 && TREE_CODE (arg0
) == REAL_CST
1464 && REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
), TREE_REAL_CST (arg1
))
1465 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg0
))
1466 && !REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
)))
1475 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
1477 /* This is needed for conversions and for COMPONENT_REF.
1478 Might as well play it safe and always test this. */
1479 if (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
)))
1482 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
1485 /* Two conversions are equal only if signedness and modes match. */
1486 if ((TREE_CODE (arg0
) == NOP_EXPR
|| TREE_CODE (arg0
) == CONVERT_EXPR
)
1487 && (TREE_UNSIGNED (TREE_TYPE (arg0
))
1488 != TREE_UNSIGNED (TREE_TYPE (arg1
))))
1491 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1492 TREE_OPERAND (arg1
, 0), 0);
1496 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
1497 TREE_OPERAND (arg1
, 0), 0)
1498 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1499 TREE_OPERAND (arg1
, 1), 0));
1502 switch (TREE_CODE (arg0
))
1505 return operand_equal_p (TREE_OPERAND (arg0
, 0),
1506 TREE_OPERAND (arg1
, 0), 0);
1510 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
1511 TREE_OPERAND (arg1
, 0), 0)
1512 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1513 TREE_OPERAND (arg1
, 1), 0));
1516 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
1517 TREE_OPERAND (arg1
, 0), 0)
1518 && operand_equal_p (TREE_OPERAND (arg0
, 1),
1519 TREE_OPERAND (arg1
, 1), 0)
1520 && operand_equal_p (TREE_OPERAND (arg0
, 2),
1521 TREE_OPERAND (arg1
, 2), 0));
1529 /* Return nonzero if comparing COMP1 with COMP2
1530 gives the same result as comparing OP1 with OP2.
1531 When in doubt, return 0. */
1534 comparison_equiv_p (comp1
, comp2
, op1
, op2
)
1535 tree comp1
, comp2
, op1
, op2
;
1537 int unsignedp1
, unsignedp2
;
1538 tree primop1
, primop2
;
1541 if (operand_equal_p (comp1
, op1
, 0)
1542 && operand_equal_p (comp2
, op2
, 0))
1545 if (TREE_CODE (TREE_TYPE (op1
)) != INTEGER_TYPE
)
1548 if (TREE_TYPE (op1
) != TREE_TYPE (op2
))
1551 if (TREE_TYPE (comp1
) != TREE_TYPE (comp2
))
1554 /* Duplicate what shorten_compare does to the comparison operands,
1555 and see if that gives the actual comparison operands, COMP1 and COMP2. */
1557 /* Throw away any conversions to wider types
1558 already present in the operands. */
1559 primop1
= get_narrower (op1
, &unsignedp1
);
1560 primop2
= get_narrower (op2
, &unsignedp2
);
1562 correct_width
= TYPE_PRECISION (TREE_TYPE (op2
));
1563 if (unsignedp1
== unsignedp2
1564 && TYPE_PRECISION (TREE_TYPE (primop1
)) < correct_width
1565 && TYPE_PRECISION (TREE_TYPE (primop2
)) < correct_width
)
1567 tree type
= TREE_TYPE (comp1
);
1569 /* Make sure shorter operand is extended the right way
1570 to match the longer operand. */
1571 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1573 primop2
= convert (signed_or_unsigned_type (unsignedp2
, TREE_TYPE (primop2
)),
1576 primop1
= convert (type
, primop1
);
1577 primop2
= convert (type
, primop2
);
1579 if (operand_equal_p (comp1
, primop1
, 0)
1580 && operand_equal_p (comp2
, primop2
, 0))
1587 /* Return a tree for the case when the result of an expression is RESULT
1588 converted to TYPE and OMITTED was previously an operand of the expression
1589 but is now not needed (e.g., we folded OMITTED * 0).
1591 If OMITTED has side effects, we must evaluate it. Otherwise, just do
1592 the conversion of RESULT to TYPE. */
1595 omit_one_operand (type
, result
, omitted
)
1596 tree type
, result
, omitted
;
1598 tree t
= convert (type
, result
);
1600 if (TREE_SIDE_EFFECTS (omitted
))
1601 return build (COMPOUND_EXPR
, type
, omitted
, t
);
1606 /* Return a simplified tree node for the truth-negation of ARG
1607 (perhaps by altering ARG). It is known that ARG is an operation that
1608 returns a truth value (0 or 1). */
1611 invert_truthvalue (arg
)
1614 tree type
= TREE_TYPE (arg
);
1616 /* For floating-point comparisons, it isn't safe to invert the condition.
1617 So just enclose a TRUTH_NOT_EXPR around what we have. */
1618 if (TREE_CODE_CLASS (TREE_CODE (arg
)) == '<'
1619 && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 0))) == REAL_TYPE
)
1620 return build1 (TRUTH_NOT_EXPR
, type
, arg
);
1622 switch (TREE_CODE (arg
))
1625 TREE_SET_CODE (arg
, EQ_EXPR
);
1629 TREE_SET_CODE (arg
, NE_EXPR
);
1633 TREE_SET_CODE (arg
, LT_EXPR
);
1637 TREE_SET_CODE (arg
, LE_EXPR
);
1641 TREE_SET_CODE (arg
, GT_EXPR
);
1645 TREE_SET_CODE (arg
, GE_EXPR
);
1649 return convert (type
, build_int_2 (TREE_INT_CST_LOW (arg
) == 0
1650 && TREE_INT_CST_HIGH (arg
) == 0, 0));
1652 case TRUTH_AND_EXPR
:
1653 return build (TRUTH_OR_EXPR
, type
,
1654 invert_truthvalue (TREE_OPERAND (arg
, 0)),
1655 invert_truthvalue (TREE_OPERAND (arg
, 1)));
1658 return build (TRUTH_AND_EXPR
, type
,
1659 invert_truthvalue (TREE_OPERAND (arg
, 0)),
1660 invert_truthvalue (TREE_OPERAND (arg
, 1)));
1662 case TRUTH_ANDIF_EXPR
:
1663 return build (TRUTH_ORIF_EXPR
, type
,
1664 invert_truthvalue (TREE_OPERAND (arg
, 0)),
1665 invert_truthvalue (TREE_OPERAND (arg
, 1)));
1667 case TRUTH_ORIF_EXPR
:
1668 return build (TRUTH_ANDIF_EXPR
, type
,
1669 invert_truthvalue (TREE_OPERAND (arg
, 0)),
1670 invert_truthvalue (TREE_OPERAND (arg
, 1)));
1672 case TRUTH_NOT_EXPR
:
1673 return TREE_OPERAND (arg
, 0);
1676 return build (COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
1677 invert_truthvalue (TREE_OPERAND (arg
, 1)),
1678 invert_truthvalue (TREE_OPERAND (arg
, 2)));
1681 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg
, 0),
1682 invert_truthvalue (TREE_OPERAND (arg
, 1)));
1684 case NON_LVALUE_EXPR
:
1685 return invert_truthvalue (TREE_OPERAND (arg
, 0));
1690 return build1 (TREE_CODE (arg
), type
,
1691 invert_truthvalue (TREE_OPERAND (arg
, 0)));
1694 if (! integer_onep (TREE_OPERAND (arg
, 1)))
1696 return build (EQ_EXPR
, type
, arg
, convert (type
, integer_zero_node
));
1702 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
1703 operands are another bit-wise operation with a common input. If so,
1704 distribute the bit operations to save an operation and possibly two if
1705 constants are involved. For example, convert
1706 (A | B) & (A | C) into A | (B & C)
1707 Further simplification will occur if B and C are constants.
1709 If this optimization cannot be done, 0 will be returned. */
1712 distribute_bit_expr (code
, type
, arg0
, arg1
)
1713 enum tree_code code
;
1720 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
1721 || TREE_CODE (arg0
) == code
1722 || (TREE_CODE (arg0
) != BIT_AND_EXPR
1723 && TREE_CODE (arg0
) != BIT_IOR_EXPR
))
1726 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0))
1728 common
= TREE_OPERAND (arg0
, 0);
1729 left
= TREE_OPERAND (arg0
, 1);
1730 right
= TREE_OPERAND (arg1
, 1);
1732 else if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1), 0))
1734 common
= TREE_OPERAND (arg0
, 0);
1735 left
= TREE_OPERAND (arg0
, 1);
1736 right
= TREE_OPERAND (arg1
, 0);
1738 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 0), 0))
1740 common
= TREE_OPERAND (arg0
, 1);
1741 left
= TREE_OPERAND (arg0
, 0);
1742 right
= TREE_OPERAND (arg1
, 1);
1744 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1), 0))
1746 common
= TREE_OPERAND (arg0
, 1);
1747 left
= TREE_OPERAND (arg0
, 0);
1748 right
= TREE_OPERAND (arg1
, 0);
1753 return fold (build (TREE_CODE (arg0
), type
, common
,
1754 fold (build (code
, type
, left
, right
))));
1757 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
1758 starting at BITPOS. The field is unsigned if UNSIGNEDP is non-zero. */
1761 make_bit_field_ref (inner
, type
, bitsize
, bitpos
, unsignedp
)
1764 int bitsize
, bitpos
;
1767 tree result
= build (BIT_FIELD_REF
, type
, inner
,
1768 size_int (bitsize
), size_int (bitpos
));
1770 TREE_UNSIGNED (result
) = unsignedp
;
1775 /* Optimize a bit-field compare.
1777 There are two cases: First is a compare against a constant and the
1778 second is a comparison of two items where the fields are at the same
1779 bit position relative to the start of a chunk (byte, halfword, word)
1780 large enough to contain it. In these cases we can avoid the shift
1781 implicit in bitfield extractions.
1783 For constants, we emit a compare of the shifted constant with the
1784 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
1785 compared. For two fields at the same position, we do the ANDs with the
1786 similar mask and compare the result of the ANDs.
1788 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
1789 COMPARE_TYPE is the type of the comparison, and LHS and RHS
1790 are the left and right operands of the comparison, respectively.
1792 If the optimization described above can be done, we return the resuling
1793 tree. Otherwise we return zero. */
1796 optimize_bit_field_compare (code
, compare_type
, lhs
, rhs
)
1797 enum tree_code code
;
1801 int lbitpos
, lbitsize
, rbitpos
, rbitsize
;
1802 int lnbitpos
, lnbitsize
, rnbitpos
, rnbitsize
;
1803 tree type
= TREE_TYPE (lhs
);
1804 tree signed_type
, unsigned_type
;
1805 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
1806 enum machine_mode lmode
, rmode
, lnmode
, rnmode
;
1807 int lunsignedp
, runsignedp
;
1808 int lvolatilep
= 0, rvolatilep
= 0;
1809 tree linner
, rinner
;
1812 /* Get all the information about the extractions being done. If the bit size
1813 if the same as the size of the underlying object, we aren't doing an
1814 extraction at all and so can do nothing. */
1815 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &lmode
,
1816 &lunsignedp
, &lvolatilep
);
1817 if (lbitsize
== GET_MODE_BITSIZE (lmode
))
1822 /* If this is not a constant, we can only do something if bit positions,
1823 sizes, and signedness are the same. */
1824 rinner
= get_inner_reference (rhs
, &rbitsize
, &rbitpos
,
1825 &rmode
, &runsignedp
, &rvolatilep
);
1827 if (lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
1828 || lunsignedp
!= runsignedp
)
1832 /* See if we can find a mode to refer to this field. We should be able to,
1833 but fail if we can't. */
1834 lnmode
= get_best_mode (lbitsize
, lbitpos
,
1835 TYPE_ALIGN (TREE_TYPE (linner
)), word_mode
,
1837 if (lnmode
== VOIDmode
)
1840 /* Set signed and unsigned types of the precision of this mode for the
1842 signed_type
= type_for_mode (lnmode
, 0);
1843 unsigned_type
= type_for_mode (lnmode
, 1);
1847 rnmode
= get_best_mode (rbitsize
, rbitpos
,
1848 TYPE_ALIGN (TREE_TYPE (rinner
)), word_mode
,
1850 if (rnmode
== VOIDmode
)
1854 /* Compute the bit position and size for the new reference and our offset
1855 within it. If the new reference is the same size as the original, we
1856 won't optimize anything, so return zero. */
1857 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
1858 lnbitpos
= lbitpos
& ~ (lnbitsize
- 1);
1859 lbitpos
-= lnbitpos
;
1860 if (lnbitsize
== lbitsize
)
1865 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
1866 rnbitpos
= rbitpos
& ~ (rnbitsize
- 1);
1867 rbitpos
-= rnbitpos
;
1868 if (rnbitsize
== rbitsize
)
1872 #if BYTES_BIG_ENDIAN
1873 lbitpos
= lnbitsize
- lbitsize
- lbitpos
;
1874 rbitpos
= rnbitsize
- rbitsize
- rbitpos
;
1877 /* Make the mask to be used against the extracted field. */
1878 mask
= convert (unsigned_type
, build_int_2 (~0, ~0));
1879 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (lnbitsize
- lbitsize
));
1880 mask
= const_binop (RSHIFT_EXPR
, mask
,
1881 size_int (lnbitsize
- lbitsize
- lbitpos
));
1884 /* If not comparing with constant, just rework the comparison
1886 return build (code
, compare_type
,
1887 build (BIT_AND_EXPR
, type
,
1888 make_bit_field_ref (linner
, type
,
1889 lnbitsize
, lnbitpos
, lunsignedp
),
1891 build (BIT_AND_EXPR
, type
,
1892 make_bit_field_ref (rinner
, type
,
1893 rnbitsize
, rnbitpos
, runsignedp
),
1896 /* Otherwise, we are handling the constant case. See if the constant is too
1897 big for the field. Warn and return a tree of for 0 (false) if so. We do
1898 this not only for its own sake, but to avoid having to test for this
1899 error case below. If we didn't, we might generate wrong code.
1901 For unsigned fields, the constant shifted right by the field length should
1902 be all zero. For signed fields, the high-order bits should agree with
1907 if (! integer_zerop (const_binop (RSHIFT_EXPR
,
1908 convert (unsigned_type
, rhs
),
1909 size_int (lbitsize
))))
1911 warning ("comparison is always %s due to width of bitfield",
1912 code
== NE_EXPR
? "one" : "zero");
1913 return convert (compare_type
,
1915 ? integer_one_node
: integer_zero_node
));
1920 tree tem
= const_binop (RSHIFT_EXPR
, convert (signed_type
, rhs
),
1921 size_int (lbitsize
- 1));
1922 if (! integer_zerop (tem
) && ! integer_all_onesp (tem
))
1924 warning ("comparison is always %s due to width of bitfield",
1925 code
== NE_EXPR
? "one" : "zero");
1926 return convert (compare_type
,
1928 ? integer_one_node
: integer_zero_node
));
1932 /* Single-bit compares should always be against zero. */
1933 if (lbitsize
== 1 && ! integer_zerop (rhs
))
1935 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
1936 rhs
= convert (type
, integer_zero_node
);
1939 /* Make a new bitfield reference, shift the constant over the
1940 appropriate number of bits and mask it with the computed mask
1941 (in case this was a signed field). If we changed it, make a new one. */
1942 lhs
= make_bit_field_ref (linner
, TREE_TYPE (lhs
), lnbitsize
, lnbitpos
,
1945 rhs
= fold (build1 (NOP_EXPR
, type
,
1946 const_binop (BIT_AND_EXPR
,
1947 const_binop (LSHIFT_EXPR
,
1948 convert (unsigned_type
, rhs
),
1949 size_int (lbitpos
)), mask
)));
1951 return build (code
, compare_type
,
1952 build (BIT_AND_EXPR
, type
, lhs
, mask
),
1956 /* Subroutine for the following routine: decode a field reference.
1958 If EXP is a comparison reference, we return the innermost reference.
1960 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
1961 set to the starting bit number.
1963 If the innermost field can be completely contained in a mode-sized
1964 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
1966 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
1967 otherwise it is not changed.
1969 *PUNSIGNEDP is set to the signedness of the field.
1971 *PMASK is set to the mask used. This is either contained in a
1972 BIT_AND_EXPR or derived from the width of the field.
1974 Return 0 if this is not a component reference or is one that we can't
1975 do anything with. */
1978 decode_field_reference (exp
, pbitsize
, pbitpos
, pmode
, punsignedp
,
1981 int *pbitsize
, *pbitpos
;
1982 enum machine_mode
*pmode
;
1983 int *punsignedp
, *pvolatilep
;
1991 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
1993 mask
= TREE_OPERAND (exp
, 1);
1994 exp
= TREE_OPERAND (exp
, 0);
1995 STRIP_NOPS (exp
); STRIP_NOPS (mask
);
1996 if (TREE_CODE (mask
) != INTEGER_CST
)
2000 if (TREE_CODE (exp
) != COMPONENT_REF
&& TREE_CODE (exp
) != ARRAY_REF
2001 && TREE_CODE (exp
) != BIT_FIELD_REF
)
2004 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, pmode
,
2005 punsignedp
, pvolatilep
);
2009 tree unsigned_type
= type_for_size (*pbitsize
, 1);
2010 int precision
= TYPE_PRECISION (unsigned_type
);
2012 mask
= convert (unsigned_type
, build_int_2 (~0, ~0));
2013 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
2014 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
2021 /* Return non-zero if MASK respresents a mask of SIZE ones in the low-order
2025 all_ones_mask_p (mask
, size
)
2029 tree type
= TREE_TYPE (mask
);
2030 int precision
= TYPE_PRECISION (type
);
2033 operand_equal_p (mask
,
2034 const_binop (RSHIFT_EXPR
,
2035 const_binop (LSHIFT_EXPR
,
2036 convert (signed_type (type
),
2037 build_int_2 (~0, ~0)),
2038 size_int (precision
- size
)),
2039 size_int (precision
- size
)), 0);
2042 /* Try to merge two comparisons to the same innermost item.
2044 For example, if we have p->a == 2 && p->b == 4 and we can make an
2045 object large enough to span both A and B, we can do this with a comparison
2046 against the object ANDed with the a mask.
2048 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
2049 operations to do this with one comparison.
2051 We check for both normal comparisons and the BIT_AND_EXPRs made this by
2052 function and the one above.
2054 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
2055 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
2057 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
2060 We return the simplified tree or 0 if no optimization is possible. */
2063 merge_component_references (code
, truth_type
, lhs
, rhs
)
2064 enum tree_code code
;
2065 tree truth_type
, lhs
, rhs
;
2067 /* If this is the "or" of two comparisons, we can do something if we
2068 the comparisons are NE_EXPR. If this is the "and", we can do something
2069 if the comparisons are EQ_EXPR. I.e.,
2070 (a->b == 2 && a->c == 4) can become (a->new == NEW).
2072 WANTED_CODE is this operation code. For single bit fields, we can
2073 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
2074 comparison for one-bit fields. */
2076 enum tree_code wanted_code
2077 = (code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
) ? EQ_EXPR
: NE_EXPR
;
2078 enum tree_code lcode
, rcode
;
2079 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
2080 int ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
2081 int rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
2082 int xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
2083 int lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
2084 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
2085 enum machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
2086 enum machine_mode lnmode
, rnmode
;
2087 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
2088 tree l_const
= 0, r_const
= 0;
2090 int first_bit
, end_bit
;
2093 /* Start by getting the comparison codes and seeing if we may be able
2094 to do something. Then get all the parameters for each side. Fail
2095 if anything is volatile. */
2097 lcode
= TREE_CODE (lhs
);
2098 rcode
= TREE_CODE (rhs
);
2099 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
2100 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
)
2101 || TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
2104 ll_inner
= decode_field_reference (TREE_OPERAND (lhs
, 0),
2105 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
2106 &ll_unsignedp
, &volatilep
, &ll_mask
);
2107 lr_inner
= decode_field_reference (TREE_OPERAND (lhs
, 1),
2108 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
2109 &lr_unsignedp
, &volatilep
, &lr_mask
);
2110 rl_inner
= decode_field_reference (TREE_OPERAND (rhs
, 0),
2111 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
2112 &rl_unsignedp
, &volatilep
, &rl_mask
);
2113 rr_inner
= decode_field_reference (TREE_OPERAND (rhs
, 1),
2114 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
2115 &rr_unsignedp
, &volatilep
, &rr_mask
);
2117 /* It must be true that the inner operation on the lhs of each
2118 comparison must be the same if we are to be able to do anything.
2119 Then see if we have constants. If not, the same must be true for
2121 if (volatilep
|| ll_inner
== 0 || rl_inner
== 0
2122 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
2125 if (TREE_CODE (TREE_OPERAND (lhs
, 1)) == INTEGER_CST
2126 && TREE_CODE (TREE_OPERAND (rhs
, 1)) == INTEGER_CST
)
2127 l_const
= TREE_OPERAND (lhs
, 1), r_const
= TREE_OPERAND (rhs
, 1);
2128 else if (lr_inner
== 0 || rr_inner
== 0
2129 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
2132 /* If either comparison code is not correct for our logical operation,
2133 fail. However, we can convert a one-bit comparison against zero into
2134 the opposite comparison against that bit being set in the field. */
2135 if (lcode
!= wanted_code
)
2137 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
2143 if (rcode
!= wanted_code
)
2145 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
2151 /* See if we can find a mode that contains both fields being compared on
2152 the left. If we can't, fail. Otherwise, update all constants and masks
2153 to be relative to a field of that size. */
2154 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
2155 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
2156 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
,
2157 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
2159 if (lnmode
== VOIDmode
)
2162 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
2163 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
2164 type
= type_for_size (lnbitsize
, 1);
2165 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
2167 #if BYTES_BIG_ENDIAN
2168 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
2169 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
2172 ll_mask
= const_binop (LSHIFT_EXPR
, convert (type
, ll_mask
),
2173 size_int (xll_bitpos
));
2174 rl_mask
= const_binop (LSHIFT_EXPR
, convert (type
, rl_mask
),
2175 size_int (xrl_bitpos
));
2177 /* Make sure the constants are interpreted as unsigned, so we
2178 don't have sign bits outside the range of their type. */
2182 l_const
= convert (unsigned_type (TREE_TYPE (l_const
)), l_const
);
2183 l_const
= const_binop (LSHIFT_EXPR
, convert (type
, l_const
),
2184 size_int (xll_bitpos
));
2188 r_const
= convert (unsigned_type (TREE_TYPE (r_const
)), r_const
);
2189 r_const
= const_binop (LSHIFT_EXPR
, convert (type
, r_const
),
2190 size_int (xrl_bitpos
));
2193 /* If the right sides are not constant, do the same for it. Also,
2194 disallow this optimization if a size or signedness mismatch occurs
2195 between the left and right sides. */
2198 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
2199 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
)
2202 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
2203 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
2204 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
,
2205 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
2207 if (rnmode
== VOIDmode
)
2210 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
2211 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
2212 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
2214 #if BYTES_BIG_ENDIAN
2215 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
2216 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
2219 lr_mask
= const_binop (LSHIFT_EXPR
, convert (type
, lr_mask
),
2220 size_int (xlr_bitpos
));
2221 rr_mask
= const_binop (LSHIFT_EXPR
, convert (type
, rr_mask
),
2222 size_int (xrr_bitpos
));
2224 /* Make a mask that corresponds to both fields being compared.
2225 Do this for both items being compared. If the masks agree,
2226 we can do this by masking both and comparing the masked
2228 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
2229 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
2230 if (operand_equal_p (ll_mask
, lr_mask
, 0) && lnbitsize
== rnbitsize
)
2232 lhs
= make_bit_field_ref (ll_inner
, type
, lnbitsize
, lnbitpos
,
2233 ll_unsignedp
|| rl_unsignedp
);
2234 rhs
= make_bit_field_ref (lr_inner
, type
, rnbitsize
, rnbitpos
,
2235 lr_unsignedp
|| rr_unsignedp
);
2236 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
2238 lhs
= build (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
2239 rhs
= build (BIT_AND_EXPR
, type
, rhs
, ll_mask
);
2241 return build (wanted_code
, truth_type
, lhs
, rhs
);
2244 /* There is still another way we can do something: If both pairs of
2245 fields being compared are adjacent, we may be able to make a wider
2246 field containing them both. */
2247 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
2248 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
2249 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
2250 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
2251 return build (wanted_code
, truth_type
,
2252 make_bit_field_ref (ll_inner
, type
,
2253 ll_bitsize
+ rl_bitsize
,
2254 MIN (ll_bitpos
, rl_bitpos
),
2256 make_bit_field_ref (lr_inner
, type
,
2257 lr_bitsize
+ rr_bitsize
,
2258 MIN (lr_bitpos
, rr_bitpos
),
2264 /* Handle the case of comparisons with constants. If there is something in
2265 common between the masks, those bits of the constants must be the same.
2266 If not, the condition is always false. Test for this to avoid generating
2267 incorrect code below. */
2268 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
2269 if (! integer_zerop (result
)
2270 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
2271 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
2273 if (wanted_code
== NE_EXPR
)
2275 warning ("`or' of unmatched not-equal tests is always 1");
2276 return convert (truth_type
, integer_one_node
);
2280 warning ("`and' of mutually exclusive equal-tests is always zero");
2281 return convert (truth_type
, integer_zero_node
);
2285 /* Construct the expression we will return. First get the component
2286 reference we will make. Unless the mask is all ones the width of
2287 that field, perform the mask operation. Then compare with the
2289 result
= make_bit_field_ref (ll_inner
, type
, lnbitsize
, lnbitpos
,
2290 ll_unsignedp
|| rl_unsignedp
);
2292 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
2293 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
2294 result
= build (BIT_AND_EXPR
, type
, result
, ll_mask
);
2296 return build (wanted_code
, truth_type
, result
,
2297 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
2300 /* Perform constant folding and related simplification of EXPR.
2301 The related simplifications include x*1 => x, x*0 => 0, etc.,
2302 and application of the associative law.
2303 NOP_EXPR conversions may be removed freely (as long as we
2304 are careful not to change the C type of the overall expression)
2305 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
2306 but we can constant-fold them if they have constant operands. */
2312 register tree t
= expr
;
2313 tree t1
= NULL_TREE
;
2314 tree type
= TREE_TYPE (expr
);
2315 register tree arg0
, arg1
;
2316 register enum tree_code code
= TREE_CODE (t
);
2319 /* WINS will be nonzero when the switch is done
2320 if all operands are constant. */
2324 /* Return right away if already constant. */
2325 if (TREE_CONSTANT (t
))
2327 if (code
== CONST_DECL
)
2328 return DECL_INITIAL (t
);
2332 kind
= TREE_CODE_CLASS (code
);
2333 if (kind
== 'e' || kind
== '<' || kind
== '1' || kind
== '2' || kind
== 'r')
2335 register int len
= tree_code_length
[(int) code
];
2337 for (i
= 0; i
< len
; i
++)
2339 tree op
= TREE_OPERAND (t
, i
);
2342 continue; /* Valid for CALL_EXPR, at least. */
2344 /* Strip any conversions that don't change the mode. */
2347 if (TREE_CODE (op
) != INTEGER_CST
2348 #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2349 && TREE_CODE (op
) != REAL_CST
2350 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2352 /* Note that TREE_CONSTANT isn't enough:
2353 static var addresses are constant but we can't
2354 do arithmetic on them. */
2364 /* If this is a commutative operation, and ARG0 is a constant, move it
2365 to ARG1 to reduce the number of tests below. */
2366 if ((code
== PLUS_EXPR
|| code
== MULT_EXPR
|| code
== MIN_EXPR
2367 || code
== MAX_EXPR
|| code
== BIT_IOR_EXPR
|| code
== BIT_XOR_EXPR
2368 || code
== BIT_AND_EXPR
)
2369 && (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
))
2372 arg0
= arg1
; arg1
= tem
;
2374 TREE_OPERAND (t
, 0) = arg0
;
2375 TREE_OPERAND (t
, 1) = arg1
;
2378 /* Now WINS is set as described above,
2379 ARG0 is the first operand of EXPR,
2380 and ARG1 is the second operand (if it has more than one operand).
2382 First check for cases where an arithmetic operation is applied to a
2383 compound, conditional, or comparison operation. Push the arithmetic
2384 operation inside the compound or conditional to see if any folding
2385 can then be done. Convert comparison to conditional for this purpose.
2386 The also optimizes non-constant cases that used to be done in
2388 if (TREE_CODE_CLASS (code
) == '1')
2390 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
2391 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
2392 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 1))));
2393 else if (TREE_CODE (arg0
) == COND_EXPR
)
2394 return fold (build (COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
2395 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 1))),
2396 fold (build1 (code
, type
, TREE_OPERAND (arg0
, 2)))));
2397 else if (TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<')
2398 return fold (build (COND_EXPR
, type
, arg0
,
2399 fold (build1 (code
, type
, integer_one_node
)),
2400 fold (build1 (code
, type
, integer_zero_node
))));
2402 else if (TREE_CODE_CLASS (code
) == '2')
2404 if (TREE_CODE (arg1
) == COMPOUND_EXPR
)
2405 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
2406 fold (build (code
, type
, arg0
, TREE_OPERAND (arg1
, 1))));
2407 else if (TREE_CODE (arg1
) == COND_EXPR
2408 || TREE_CODE_CLASS (TREE_CODE (arg1
)) == '<')
2410 tree test
, true_value
, false_value
;
2412 if (TREE_CODE (arg1
) == COND_EXPR
)
2414 test
= TREE_OPERAND (arg1
, 0);
2415 true_value
= TREE_OPERAND (arg1
, 1);
2416 false_value
= TREE_OPERAND (arg1
, 2);
2421 true_value
= integer_one_node
;
2422 false_value
= integer_zero_node
;
2425 if (TREE_CODE (arg0
) != VAR_DECL
&& TREE_CODE (arg0
) != PARM_DECL
)
2426 arg0
= save_expr (arg0
);
2427 test
= fold (build (COND_EXPR
, type
, test
,
2428 fold (build (code
, type
, arg0
, true_value
)),
2429 fold (build (code
, type
, arg0
, false_value
))));
2430 if (TREE_CODE (arg0
) == SAVE_EXPR
)
2431 return build (COMPOUND_EXPR
, type
,
2432 convert (void_type_node
, arg0
), test
);
2434 return convert (type
, test
);
2437 else if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
2438 return build (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
2439 fold (build (code
, type
, TREE_OPERAND (arg0
, 1), arg1
)));
2440 else if (TREE_CODE (arg0
) == COND_EXPR
2441 || TREE_CODE_CLASS (TREE_CODE (arg0
)) == '<')
2443 tree test
, true_value
, false_value
;
2445 if (TREE_CODE (arg0
) == COND_EXPR
)
2447 test
= TREE_OPERAND (arg0
, 0);
2448 true_value
= TREE_OPERAND (arg0
, 1);
2449 false_value
= TREE_OPERAND (arg0
, 2);
2454 true_value
= integer_one_node
;
2455 false_value
= integer_zero_node
;
2458 if (TREE_CODE (arg1
) != VAR_DECL
&& TREE_CODE (arg1
) != PARM_DECL
)
2459 arg1
= save_expr (arg1
);
2460 test
= fold (build (COND_EXPR
, type
, test
,
2461 fold (build (code
, type
, true_value
, arg1
)),
2462 fold (build (code
, type
, false_value
, arg1
))));
2463 if (TREE_CODE (arg1
) == SAVE_EXPR
)
2464 return build (COMPOUND_EXPR
, type
,
2465 convert (void_type_node
, arg1
), test
);
2467 return convert (type
, test
);
2481 return fold (DECL_INITIAL (t
));
2486 case FIX_TRUNC_EXPR
:
2487 /* Other kinds of FIX are not handled properly by fold_convert. */
2488 /* Two conversions in a row are not needed unless:
2489 - the intermediate type is narrower than both initial and final, or
2490 - the initial type is a pointer type and the precisions of the
2491 intermediate and final types differ, or
2492 - the final type is a pointer type and the precisions of the
2493 initial and intermediate types differ. */
2494 if ((TREE_CODE (TREE_OPERAND (t
, 0)) == NOP_EXPR
2495 || TREE_CODE (TREE_OPERAND (t
, 0)) == CONVERT_EXPR
)
2496 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0)))
2497 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
2499 TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0)))
2500 > TYPE_PRECISION (TREE_TYPE (t
)))
2501 && ((TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (t
, 0)))
2502 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0)))
2503 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))))
2505 (TREE_UNSIGNED (TREE_TYPE (t
))
2506 && (TYPE_PRECISION (TREE_TYPE (t
))
2507 > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2508 && ! ((TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
2510 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0)))
2511 != TYPE_PRECISION (TREE_TYPE (t
))))
2512 && ! (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
2513 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
2514 != TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (t
, 0))))))
2515 return convert (TREE_TYPE (t
), TREE_OPERAND (TREE_OPERAND (t
, 0), 0));
2517 if (TREE_CODE (TREE_OPERAND (t
, 0)) == MODIFY_EXPR
2518 && TREE_CONSTANT (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)))
2520 /* Don't leave an assignment inside a conversion. */
2521 tree prev
= TREE_OPERAND (t
, 0);
2522 TREE_OPERAND (t
, 0) = TREE_OPERAND (prev
, 1);
2523 /* First do the assignment, then return converted constant. */
2524 t
= build (COMPOUND_EXPR
, TREE_TYPE (t
), prev
, fold (t
));
2530 TREE_CONSTANT (t
) = TREE_CONSTANT (arg0
);
2533 return fold_convert (t
, arg0
);
2535 #if 0 /* This loses on &"foo"[0]. */
2540 /* Fold an expression like: "foo"[2] */
2541 if (TREE_CODE (arg0
) == STRING_CST
2542 && TREE_CODE (arg1
) == INTEGER_CST
2543 && !TREE_INT_CST_HIGH (arg1
)
2544 && (i
= TREE_INT_CST_LOW (arg1
)) < TREE_STRING_LENGTH (arg0
))
2546 t
= build_int_2 (TREE_STRING_POINTER (arg0
)[i
], 0);
2547 TREE_TYPE (t
) = TREE_TYPE (TREE_TYPE (arg0
));
2555 TREE_CONSTANT (t
) = wins
;
2561 if (TREE_CODE (arg0
) == INTEGER_CST
)
2563 if (TREE_INT_CST_LOW (arg0
) == 0)
2564 t
= build_int_2 (0, - TREE_INT_CST_HIGH (arg0
));
2566 t
= build_int_2 (- TREE_INT_CST_LOW (arg0
),
2567 ~ TREE_INT_CST_HIGH (arg0
));
2568 TREE_TYPE (t
) = type
;
2571 else if (TREE_CODE (arg0
) == REAL_CST
)
2572 t
= build_real (type
, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0
)));
2573 TREE_TYPE (t
) = type
;
2575 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
2576 return TREE_OPERAND (arg0
, 0);
2578 /* Convert - (a - b) to (b - a) for non-floating-point. */
2579 else if (TREE_CODE (arg0
) == MINUS_EXPR
&& TREE_CODE (type
) != REAL_TYPE
)
2580 return build (MINUS_EXPR
, type
, TREE_OPERAND (arg0
, 1),
2581 TREE_OPERAND (arg0
, 0));
2588 if (TREE_CODE (arg0
) == INTEGER_CST
)
2590 if (! TREE_UNSIGNED (type
)
2591 && TREE_INT_CST_HIGH (arg0
) < 0)
2593 if (TREE_INT_CST_LOW (arg0
) == 0)
2594 t
= build_int_2 (0, - TREE_INT_CST_HIGH (arg0
));
2596 t
= build_int_2 (- TREE_INT_CST_LOW (arg0
),
2597 ~ TREE_INT_CST_HIGH (arg0
));
2600 else if (TREE_CODE (arg0
) == REAL_CST
)
2602 if (REAL_VALUES_LESS (TREE_REAL_CST (arg0
), dconst0
))
2603 t
= build_real (type
,
2604 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0
)));
2606 TREE_TYPE (t
) = type
;
2608 else if (TREE_CODE (arg0
) == ABS_EXPR
|| TREE_CODE (arg0
) == NEGATE_EXPR
)
2609 return build1 (ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
2615 if (TREE_CODE (arg0
) == INTEGER_CST
)
2616 t
= build_int_2 (~ TREE_INT_CST_LOW (arg0
),
2617 ~ TREE_INT_CST_HIGH (arg0
));
2618 TREE_TYPE (t
) = type
;
2621 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
2622 return TREE_OPERAND (arg0
, 0);
2626 /* A + (-B) -> A - B */
2627 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
2628 return fold (build (MINUS_EXPR
, type
, arg0
, TREE_OPERAND (arg1
, 0)));
2629 else if (TREE_CODE (type
) != REAL_TYPE
)
2631 if (integer_zerop (arg1
))
2632 return non_lvalue (convert (type
, arg0
));
2634 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
2635 with a constant, and the two constants have no bits in common,
2636 we should treat this as a BIT_IOR_EXPR since this may produce more
2638 if (TREE_CODE (arg0
) == BIT_AND_EXPR
2639 && TREE_CODE (arg1
) == BIT_AND_EXPR
2640 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
2641 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
2642 && integer_zerop (const_binop (BIT_AND_EXPR
,
2643 TREE_OPERAND (arg0
, 1),
2644 TREE_OPERAND (arg1
, 1))))
2646 code
= BIT_IOR_EXPR
;
2650 /* In IEEE floating point, x+0 may not equal x. */
2651 else if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
2652 && real_zerop (arg1
))
2653 return non_lvalue (convert (type
, arg0
));
2655 /* In most languages, can't associate operations on floats
2656 through parentheses. Rather than remember where the parentheses
2657 were, we don't associate floats at all. It shouldn't matter much. */
2658 if (TREE_CODE (type
) == REAL_TYPE
)
2660 /* The varsign == -1 cases happen only for addition and subtraction.
2661 It says that the arg that was split was really CON minus VAR.
2662 The rest of the code applies to all associative operations. */
2668 if (split_tree (arg0
, code
, &var
, &con
, &varsign
))
2672 /* EXPR is (CON-VAR) +- ARG1. */
2673 /* If it is + and VAR==ARG1, return just CONST. */
2674 if (code
== PLUS_EXPR
&& operand_equal_p (var
, arg1
, 0))
2675 return convert (TREE_TYPE (t
), con
);
2677 /* Otherwise return (CON +- ARG1) - VAR. */
2678 TREE_SET_CODE (t
, MINUS_EXPR
);
2679 TREE_OPERAND (t
, 1) = var
;
2681 = fold (build (code
, TREE_TYPE (t
), con
, arg1
));
2685 /* EXPR is (VAR+CON) +- ARG1. */
2686 /* If it is - and VAR==ARG1, return just CONST. */
2687 if (code
== MINUS_EXPR
&& operand_equal_p (var
, arg1
, 0))
2688 return convert (TREE_TYPE (t
), con
);
2690 /* Otherwise return VAR +- (ARG1 +- CON). */
2691 TREE_OPERAND (t
, 1) = tem
2692 = fold (build (code
, TREE_TYPE (t
), arg1
, con
));
2693 TREE_OPERAND (t
, 0) = var
;
2694 if (integer_zerop (tem
)
2695 && (code
== PLUS_EXPR
|| code
== MINUS_EXPR
))
2696 return convert (type
, var
);
2697 /* If we have x +/- (c - d) [c an explicit integer]
2698 change it to x -/+ (d - c) since if d is relocatable
2699 then the latter can be a single immediate insn
2700 and the former cannot. */
2701 if (TREE_CODE (tem
) == MINUS_EXPR
2702 && TREE_CODE (TREE_OPERAND (tem
, 0)) == INTEGER_CST
)
2704 tree tem1
= TREE_OPERAND (tem
, 1);
2705 TREE_OPERAND (tem
, 1) = TREE_OPERAND (tem
, 0);
2706 TREE_OPERAND (tem
, 0) = tem1
;
2708 (code
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
));
2714 if (split_tree (arg1
, code
, &var
, &con
, &varsign
))
2716 /* EXPR is ARG0 +- (CON +- VAR). */
2719 (code
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
));
2720 if (TREE_CODE (t
) == MINUS_EXPR
2721 && operand_equal_p (var
, arg0
, 0))
2723 /* If VAR and ARG0 cancel, return just CON or -CON. */
2724 if (code
== PLUS_EXPR
)
2725 return convert (TREE_TYPE (t
), con
);
2726 return fold (build1 (NEGATE_EXPR
, TREE_TYPE (t
),
2727 convert (TREE_TYPE (t
), con
)));
2730 = fold (build (code
, TREE_TYPE (t
), arg0
, con
));
2731 TREE_OPERAND (t
, 1) = var
;
2732 if (integer_zerop (TREE_OPERAND (t
, 0))
2733 && TREE_CODE (t
) == PLUS_EXPR
)
2734 return convert (TREE_TYPE (t
), var
);
2739 #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
2740 if (TREE_CODE (arg1
) == REAL_CST
)
2742 #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
2744 t1
= const_binop (code
, arg0
, arg1
);
2745 if (t1
!= NULL_TREE
)
2747 /* The return value should always have
2748 the same type as the original expression. */
2749 TREE_TYPE (t1
) = TREE_TYPE (t
);
2755 if (TREE_CODE (type
) != REAL_TYPE
)
2757 if (! wins
&& integer_zerop (arg0
))
2758 return build1 (NEGATE_EXPR
, type
, arg1
);
2759 if (integer_zerop (arg1
))
2760 return non_lvalue (convert (type
, arg0
));
2762 /* Convert A - (-B) to A + B. */
2763 else if (TREE_CODE (arg1
) == NEGATE_EXPR
)
2764 return fold (build (PLUS_EXPR
, type
, arg0
, TREE_OPERAND (arg1
, 0)));
2767 if (! wins
&& real_zerop (arg0
))
2768 return build1 (NEGATE_EXPR
, type
, arg1
);
2769 /* In IEEE floating point, x-0 may not equal x. */
2770 if (real_zerop (arg1
) && TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
2771 return non_lvalue (convert (type
, arg0
));
2773 /* Fold &x - &x. This can happen from &x.foo - &x.
2774 Note that can't be done for certain floats even in non-IEEE formats.
2775 Also note that operand_equal_p is always false is an operand
2778 if (operand_equal_p (arg0
, arg1
,
2779 TREE_CODE (type
) == REAL_TYPE
))
2780 return convert (type
, integer_zero_node
);
2784 if (TREE_CODE (type
) != REAL_TYPE
)
2786 if (integer_zerop (arg1
))
2787 return omit_one_operand (type
, arg1
, arg0
);
2788 if (integer_onep (arg1
))
2789 return non_lvalue (convert (type
, arg0
));
2791 /* (a * (1 << b)) is (a << b) */
2792 if (TREE_CODE (arg1
) == LSHIFT_EXPR
2793 && integer_onep (TREE_OPERAND (arg1
, 0)))
2794 return fold (build (LSHIFT_EXPR
, type
, arg0
,
2795 TREE_OPERAND (arg1
, 1)));
2796 if (TREE_CODE (arg0
) == LSHIFT_EXPR
2797 && integer_onep (TREE_OPERAND (arg0
, 0)))
2798 return fold (build (LSHIFT_EXPR
, type
, arg1
,
2799 TREE_OPERAND (arg0
, 1)));
2801 /* In IEEE floating point, these optimizations are not correct. */
2804 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
2805 && real_zerop (arg1
))
2806 return omit_one_operand (type
, arg1
, arg0
);
2807 /* In IEEE floating point, x*1 is not equivalent to x for nans.
2808 However, ANSI says we can drop signals,
2809 so we can do this anyway. */
2810 if (real_onep (arg1
))
2811 return non_lvalue (convert (type
, arg0
));
2813 if (! wins
&& real_twop (arg1
))
2815 tree arg
= save_expr (arg0
);
2816 return build (PLUS_EXPR
, type
, arg
, arg
);
2823 if (integer_all_onesp (arg1
))
2824 return omit_one_operand (type
, arg1
, arg0
);
2825 if (integer_zerop (arg1
))
2826 return non_lvalue (convert (type
, arg0
));
2827 t1
= distribute_bit_expr (code
, type
, arg0
, arg1
);
2828 if (t1
!= NULL_TREE
)
2833 if (integer_zerop (arg1
))
2834 return non_lvalue (convert (type
, arg0
));
2835 if (integer_all_onesp (arg1
))
2836 return fold (build1 (BIT_NOT_EXPR
, type
, arg0
));
2841 if (integer_all_onesp (arg1
))
2842 return non_lvalue (convert (type
, arg0
));
2843 if (integer_zerop (arg1
))
2844 return omit_one_operand (type
, arg1
, arg0
);
2845 t1
= distribute_bit_expr (code
, type
, arg0
, arg1
);
2846 if (t1
!= NULL_TREE
)
2848 /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char. */
2849 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == NOP_EXPR
2850 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
2852 int prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)));
2853 if (prec
< BITS_PER_WORD
&& prec
< HOST_BITS_PER_INT
2854 && (~TREE_INT_CST_LOW (arg0
) & ((1 << prec
) - 1)) == 0)
2855 return build1 (NOP_EXPR
, type
, TREE_OPERAND (arg1
, 0));
2857 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
2858 && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
2860 int prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
2861 if (prec
< BITS_PER_WORD
&& prec
< HOST_BITS_PER_INT
2862 && (~TREE_INT_CST_LOW (arg1
) & ((1 << prec
) - 1)) == 0)
2863 return build1 (NOP_EXPR
, type
, TREE_OPERAND (arg0
, 0));
2867 case BIT_ANDTC_EXPR
:
2868 if (integer_all_onesp (arg0
))
2869 return non_lvalue (convert (type
, arg1
));
2870 if (integer_zerop (arg0
))
2871 return omit_one_operand (type
, arg0
, arg1
);
2872 if (TREE_CODE (arg1
) == INTEGER_CST
)
2874 arg1
= fold (build1 (BIT_NOT_EXPR
, type
, arg1
));
2875 code
= BIT_AND_EXPR
;
2880 case TRUNC_DIV_EXPR
:
2881 case ROUND_DIV_EXPR
:
2882 case FLOOR_DIV_EXPR
:
2884 case EXACT_DIV_EXPR
:
2886 if (integer_onep (arg1
))
2887 return non_lvalue (convert (type
, arg0
));
2888 if (integer_zerop (arg1
))
2890 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
2891 #ifndef REAL_INFINITY
2892 if (TREE_CODE (arg1
) == REAL_CST
2893 && real_zerop (arg1
))
2896 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
2901 case FLOOR_MOD_EXPR
:
2902 case ROUND_MOD_EXPR
:
2903 case TRUNC_MOD_EXPR
:
2904 if (integer_onep (arg1
))
2905 return omit_one_operand (type
, integer_zero_node
, arg0
);
2906 if (integer_zerop (arg1
))
2914 if (integer_zerop (arg1
))
2915 return non_lvalue (convert (type
, arg0
));
2916 /* Since negative shift count is not well-defined,
2917 don't try to compute it in the compiler. */
2918 if (tree_int_cst_lt (arg1
, integer_zero_node
))
2923 if (operand_equal_p (arg0
, arg1
, 0))
2925 if (TREE_CODE (type
) == INTEGER_TYPE
2926 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), 1))
2927 return omit_one_operand (type
, arg1
, arg0
);
2931 if (operand_equal_p (arg0
, arg1
, 0))
2933 if (TREE_CODE (type
) == INTEGER_TYPE
2934 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), 1))
2935 return omit_one_operand (type
, arg1
, arg0
);
2938 case TRUTH_NOT_EXPR
:
2939 /* Note that the operand of this must be an int
2940 and its values must be 0 or 1.
2941 ("true" is a fixed value perhaps depending on the language,
2942 but we don't handle values other than 1 correctly yet.) */
2943 return invert_truthvalue (arg0
);
2945 case TRUTH_ANDIF_EXPR
:
2946 /* Note that the operands of this must be ints
2947 and their values must be 0 or 1.
2948 ("true" is a fixed value perhaps depending on the language.) */
2949 /* If first arg is constant zero, return it. */
2950 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
2952 case TRUTH_AND_EXPR
:
2953 /* If either arg is constant true, drop it. */
2954 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
2955 return non_lvalue (arg1
);
2956 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
2957 return non_lvalue (arg0
);
2958 /* Both known to be zero => return zero. */
2959 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2963 /* Check for the possibility of merging component references. If our
2964 lhs is another similar operation, try to merge its rhs with our
2965 rhs. Then try to merge our lhs and rhs. */
2970 if (TREE_CODE (arg0
) == code
)
2972 tem
= merge_component_references (code
, type
,
2973 TREE_OPERAND (arg0
, 1), arg1
);
2975 return fold (build (code
, type
, TREE_OPERAND (arg0
, 0), tem
));
2978 tem
= merge_component_references (code
, type
, arg0
, arg1
);
2984 case TRUTH_ORIF_EXPR
:
2985 /* Note that the operands of this must be ints
2986 and their values must be 0 or true.
2987 ("true" is a fixed value perhaps depending on the language.) */
2988 /* If first arg is constant true, return it. */
2989 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
2992 /* If either arg is constant zero, drop it. */
2993 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
2994 return non_lvalue (arg1
);
2995 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
))
2996 return non_lvalue (arg0
);
2997 /* Both known to be true => return true. */
2998 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
3008 /* If one arg is a constant integer, put it last. */
3009 if (TREE_CODE (arg0
) == INTEGER_CST
3010 && TREE_CODE (arg1
) != INTEGER_CST
)
3012 TREE_OPERAND (t
, 0) = arg1
;
3013 TREE_OPERAND (t
, 1) = arg0
;
3014 arg0
= TREE_OPERAND (t
, 0);
3015 arg1
= TREE_OPERAND (t
, 1);
3031 TREE_SET_CODE (t
, code
);
3034 /* Convert foo++ == CONST into ++foo == CONST + INCR.
3035 First, see if one arg is constant; find the constant arg
3036 and the other one. */
3038 tree constop
= 0, varop
;
3041 if (TREE_CONSTANT (arg1
))
3042 constoploc
= &TREE_OPERAND (t
, 1), constop
= arg1
, varop
= arg0
;
3043 if (TREE_CONSTANT (arg0
))
3044 constoploc
= &TREE_OPERAND (t
, 0), constop
= arg0
, varop
= arg1
;
3046 if (constop
&& TREE_CODE (varop
) == POSTINCREMENT_EXPR
)
3049 = fold (build (PLUS_EXPR
, TREE_TYPE (varop
),
3050 constop
, TREE_OPERAND (varop
, 1)));
3051 /* This optimization is invalid for ordered comparisons
3052 if CONST+INCR overflows or if foo+incr might overflow.
3053 For pointer types we assume overflow doesn't happen. */
3054 if (TREE_CODE (TREE_TYPE (varop
)) == POINTER_TYPE
3055 || code
== EQ_EXPR
|| code
== NE_EXPR
)
3057 /* This optimization is invalid for floating point
3058 if adding one to the constant does not change it. */
3059 if (TREE_CODE (TREE_TYPE (newconst
)) != REAL_TYPE
3060 || !REAL_VALUES_EQUAL (TREE_REAL_CST (newconst
),
3061 TREE_REAL_CST (constop
)))
3063 TREE_SET_CODE (varop
, PREINCREMENT_EXPR
);
3064 *constoploc
= newconst
;
3069 else if (constop
&& TREE_CODE (varop
) == POSTDECREMENT_EXPR
)
3072 = fold (build (MINUS_EXPR
, TREE_TYPE (varop
),
3073 constop
, TREE_OPERAND (varop
, 1)));
3074 if (TREE_CODE (TREE_TYPE (varop
)) == POINTER_TYPE
3075 || code
== EQ_EXPR
|| code
== NE_EXPR
)
3077 if (TREE_CODE (TREE_TYPE (newconst
)) != REAL_TYPE
3078 || !REAL_VALUES_EQUAL (TREE_REAL_CST (newconst
),
3079 TREE_REAL_CST (constop
)))
3081 TREE_SET_CODE (varop
, PREDECREMENT_EXPR
);
3082 *constoploc
= newconst
;
3089 /* Change X >= CST to X > (CST - 1) if CST is positive. */
3090 if (TREE_CODE (arg1
) == INTEGER_CST
3091 && TREE_CODE (arg0
) != INTEGER_CST
3092 && ! tree_int_cst_lt (arg1
, integer_one_node
))
3094 switch (TREE_CODE (t
))
3098 TREE_SET_CODE (t
, code
);
3099 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
3100 TREE_OPERAND (t
, 1) = arg1
;
3105 TREE_SET_CODE (t
, code
);
3106 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
3107 TREE_OPERAND (t
, 1) = arg1
;
3111 /* If we are comparing the result of a comparison to a constant,
3112 we can often simplify this, since the comparison result is known to
3113 be either 0 or 1. We can ignore conversions if the LHS is a
3116 if (TREE_CODE (arg1
) == INTEGER_CST
)
3118 tree comparison
= arg0
;
3120 while (TREE_CODE (comparison
) == NOP_EXPR
3121 || TREE_CODE (comparison
) == CONVERT_EXPR
)
3122 comparison
= TREE_OPERAND (comparison
, 0);
3124 if (TREE_CODE_CLASS (TREE_CODE (comparison
)) == '<'
3125 || TREE_CODE (comparison
) == TRUTH_ANDIF_EXPR
3126 || TREE_CODE (comparison
) == TRUTH_ORIF_EXPR
3127 || TREE_CODE (comparison
) == TRUTH_AND_EXPR
3128 || TREE_CODE (comparison
) == TRUTH_OR_EXPR
3129 || TREE_CODE (comparison
) == TRUTH_NOT_EXPR
)
3131 /* We do different things depending on whether the
3132 constant being compared against is < 0, == 0, == 1, or > 1.
3133 Each of those cases, in order, corresponds to one
3134 character in a string. The value of the character is
3135 the result to return. A '0' or '1' means return always true
3136 or always false, respectively; 'c' means return the result
3137 of the comparison, and 'i' means return the result of the
3138 inverted comparison. */
3140 char *actions
, action
;
3164 if (tree_int_cst_lt (arg1
, integer_zero_node
))
3165 action
= actions
[0];
3166 else if (integer_zerop (arg1
))
3167 action
= actions
[1];
3168 else if (integer_onep (arg1
))
3169 action
= actions
[2];
3171 action
= actions
[3];
3176 return omit_one_operand (type
, integer_zero_node
,
3180 return omit_one_operand (type
, integer_one_node
, comparison
);
3183 return convert (type
, comparison
);
3186 return convert (type
, invert_truthvalue (comparison
));
3194 /* If this is an EQ or NE comparison with zero and ARG0 is
3195 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
3196 two operations, but the latter can be done in one less insn
3197 one machine that have only two-operand insns or on which a
3198 constant cannot be the first operand. */
3199 if (integer_zerop (arg1
) && (code
== EQ_EXPR
|| code
== NE_EXPR
)
3200 && TREE_CODE (arg0
) == BIT_AND_EXPR
)
3202 if (TREE_CODE (TREE_OPERAND (arg0
, 0)) == LSHIFT_EXPR
3203 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0)))
3205 fold (build (code
, type
,
3206 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
3208 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
3209 TREE_OPERAND (arg0
, 1),
3210 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1)),
3211 convert (TREE_TYPE (arg0
),
3214 else if (TREE_CODE (TREE_OPERAND (arg0
, 1)) == LSHIFT_EXPR
3215 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0
, 1), 0)))
3217 fold (build (code
, type
,
3218 build (BIT_AND_EXPR
, TREE_TYPE (arg0
),
3220 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3221 TREE_OPERAND (arg0
, 0),
3222 TREE_OPERAND (TREE_OPERAND (arg0
, 1), 1)),
3223 convert (TREE_TYPE (arg0
),
3228 /* If this is an NE comparison of zero with an AND of one, remove the
3229 comparison since the AND will give the correct value. */
3230 if (code
== NE_EXPR
&& integer_zerop (arg1
)
3231 && TREE_CODE (arg0
) == BIT_AND_EXPR
3232 && integer_onep (TREE_OPERAND (arg0
, 1)))
3233 return convert (type
, arg0
);
3235 /* If we have (A & C) == C where C is a power of 2, convert this into
3236 (A & C) != 0. Similarly for NE_EXPR. */
3237 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
3238 && TREE_CODE (arg0
) == BIT_AND_EXPR
3239 && integer_pow2p (TREE_OPERAND (arg0
, 1))
3240 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
3241 return build (code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
3242 arg0
, integer_zero_node
);
3244 /* Simplify comparison of an integer with itself.
3245 (This may not be safe with IEEE floats if they are nans.) */
3246 if (operand_equal_p (arg0
, arg1
, 0)
3247 && TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
)
3254 t
= build_int_2 (1, 0);
3255 TREE_TYPE (t
) = type
;
3260 t
= build_int_2 (0, 0);
3261 TREE_TYPE (t
) = type
;
3266 /* An unsigned comparison against 0 can be simplified. */
3267 if (integer_zerop (arg1
)
3268 && (TREE_CODE (TREE_TYPE (arg1
)) == INTEGER_TYPE
3269 || TREE_CODE (TREE_TYPE (arg1
)) == POINTER_TYPE
)
3270 && TREE_UNSIGNED (TREE_TYPE (arg1
)))
3272 switch (TREE_CODE (t
))
3275 TREE_SET_CODE (t
, NE_EXPR
);
3278 TREE_SET_CODE (t
, EQ_EXPR
);
3281 return omit_one_operand (integer_type_node
,
3282 integer_one_node
, arg0
);
3284 return omit_one_operand (integer_type_node
,
3285 integer_zero_node
, arg0
);
3289 /* To compute GT, swap the arguments and do LT.
3290 To compute GE, do LT and invert the result.
3291 To compute LE, swap the arguments, do LT and invert the result.
3292 To compute NE, do EQ and invert the result. */
3293 if (code
== LE_EXPR
|| code
== GT_EXPR
)
3295 register tree temp
= arg0
;
3300 /* Compute a result for LT or EQ if args permit;
3301 otherwise return T. */
3302 if (TREE_CODE (arg0
) == INTEGER_CST
3303 && TREE_CODE (arg1
) == INTEGER_CST
)
3305 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3307 (TREE_INT_CST_LOW (arg0
) == TREE_INT_CST_LOW (arg1
)
3308 && TREE_INT_CST_HIGH (arg0
) == TREE_INT_CST_HIGH (arg1
),
3311 t
= build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0
))
3312 ? INT_CST_LT_UNSIGNED (arg0
, arg1
)
3313 : INT_CST_LT (arg0
, arg1
)),
3316 /* Assume a nonexplicit constant cannot equal an explicit one,
3317 since such code would be undefined anyway.
3318 Exception: on sysvr4, using #pragma weak,
3319 a label can come out as 0. */
3320 else if (TREE_CODE (arg1
) == INTEGER_CST
3321 && !integer_zerop (arg1
)
3322 && TREE_CONSTANT (arg0
)
3323 && TREE_CODE (arg0
) == ADDR_EXPR
3324 && (code
== EQ_EXPR
|| code
== NE_EXPR
))
3326 t
= build_int_2 (0, 0);
3328 /* Two real constants can be compared explicitly. */
3329 else if (TREE_CODE (arg0
) == REAL_CST
3330 && TREE_CODE (arg1
) == REAL_CST
)
3332 if (code
== EQ_EXPR
|| code
== NE_EXPR
)
3333 t
= build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0
),
3334 TREE_REAL_CST (arg1
)),
3337 t
= build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0
),
3338 TREE_REAL_CST (arg1
)),
3341 else if ((TREE_CODE (arg0
) == COMPONENT_REF
3342 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
3343 && (code
== EQ_EXPR
|| code
== NE_EXPR
)
3344 /* Handle the constant case even without -O
3345 to make sure the warnings are given. */
3346 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
3348 tree tem
= optimize_bit_field_compare (code
, type
, arg0
, arg1
);
3349 return tem
? tem
: t
;
3352 /* If what we want is other than LT or EQ, invert the result. */
3353 if ((code
== GE_EXPR
|| code
== LE_EXPR
|| code
== NE_EXPR
)
3354 && TREE_CODE (t
) == INTEGER_CST
)
3355 TREE_INT_CST_LOW (t
) ^= 1;
3356 TREE_TYPE (t
) = type
;
3360 if (TREE_CODE (arg0
) == INTEGER_CST
)
3361 return TREE_OPERAND (t
, (integer_zerop (arg0
) ? 2 : 1));
3362 else if (operand_equal_p (arg1
, TREE_OPERAND (expr
, 2), 0))
3363 return omit_one_operand (type
, arg1
, arg0
);
3364 else if (integer_onep (TREE_OPERAND (t
, 1))
3365 && integer_zerop (TREE_OPERAND (t
, 2))
3366 /* If we try to convert TREE_OPERAND (t, 0) to our type, the
3367 call to fold will try to move the conversion inside
3368 a COND, which will recurse. In that case, the COND_EXPR
3369 is probably the best choice, so leave it alone. */
3370 && type
== TREE_TYPE (arg0
))
3372 else if (integer_zerop (arg1
) && integer_onep (TREE_OPERAND (t
, 2)))
3373 return convert (type
, invert_truthvalue (arg0
));
3375 /* If we have (a >= 0 ? a : -a) or the same with ">", this is an
3376 absolute value expression. */
3378 if ((TREE_CODE (arg0
) == GE_EXPR
|| TREE_CODE (arg0
) == GT_EXPR
)
3379 && integer_zerop (TREE_OPERAND (arg0
, 1))
3380 && TREE_CODE (TREE_OPERAND (t
, 2)) == NEGATE_EXPR
3381 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
3382 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (t
, 2), 0), arg1
, 0))
3383 return fold (build1 (ABS_EXPR
, type
, arg1
));
3385 /* Similarly for (a <= 0 ? -a : a). */
3387 if ((TREE_CODE (arg0
) == LE_EXPR
|| TREE_CODE (arg0
) == LT_EXPR
)
3388 && integer_zerop (TREE_OPERAND (arg0
, 1))
3389 && TREE_CODE (arg1
) == NEGATE_EXPR
3390 && operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (t
, 2), 0)
3391 && operand_equal_p (TREE_OPERAND (arg1
, 0), TREE_OPERAND (t
, 2), 0))
3392 return fold (build1 (ABS_EXPR
, type
, TREE_OPERAND (t
, 2)));
3394 /* If we have a GT, GE, LT, or LE comparison, this might be a MIN or
3395 MAX test. If so, make a MIN_EXPR or MAX_EXPR. */
3397 if (TREE_CODE (arg0
) == GT_EXPR
|| TREE_CODE (arg0
) == GE_EXPR
3398 || TREE_CODE (arg0
) == LT_EXPR
|| TREE_CODE (arg0
) == LE_EXPR
)
3400 tree hi_true
, lo_true
;
3402 if (TREE_CODE (arg0
) == GT_EXPR
|| TREE_CODE (arg0
) == GE_EXPR
)
3403 hi_true
= TREE_OPERAND (arg0
, 0), lo_true
= TREE_OPERAND (arg0
, 1);
3405 hi_true
= TREE_OPERAND (arg0
, 1), lo_true
= TREE_OPERAND (arg0
, 0);
3407 if (comparison_equiv_p (hi_true
, lo_true
, arg1
, TREE_OPERAND (t
, 2)))
3408 /* We use arg1 and the other arg because they must have the same
3409 type as the intended result.
3410 The values being compared might have a narrower type. */
3411 return fold (build (MAX_EXPR
, type
, arg1
, TREE_OPERAND (t
, 2)));
3412 else if (comparison_equiv_p (lo_true
, hi_true
,
3413 arg1
, TREE_OPERAND (t
, 2)))
3414 return fold (build (MIN_EXPR
, type
, arg1
, TREE_OPERAND (t
, 2)));
3417 /* Look for cases when we are comparing some expression A for equality
3418 with zero and the result is to be zero if A is zero. In that case,
3419 check to see if the value of A is the same as the value to be
3420 returned when A is non-zero.
3422 There are two cases: One is where we have (A ? A : 0) and the
3423 other is when a single bit is tested (e.g., A & 2 ? 2 : 0).
3424 In these cases, the result of the conditional is simply A.
3426 Start by setting ARG1 to be the true value and ARG0 to be the thing
3427 compared with zero. Then check for the two cases above. */
3429 if (integer_zerop (TREE_OPERAND (t
, 2))
3430 && TREE_CODE (arg0
) == NE_EXPR
3431 && integer_zerop (TREE_OPERAND (arg0
, 1))
3432 && ! TREE_SIDE_EFFECTS (arg1
))
3434 else if (integer_zerop (arg1
)
3435 && TREE_CODE (arg0
) == EQ_EXPR
3436 && integer_zerop (TREE_OPERAND (arg0
, 1))
3437 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
3438 arg1
= TREE_OPERAND (t
, 2);
3442 arg0
= TREE_OPERAND (arg0
, 0);
3445 if (operand_equal_p (arg0
, arg1
, 0)
3446 || (TREE_CODE (arg1
) == INTEGER_CST
3447 && integer_pow2p (arg1
)
3448 && TREE_CODE (arg0
) == BIT_AND_EXPR
3449 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0)))
3450 return convert (type
, arg0
);
3454 if (!TREE_SIDE_EFFECTS (arg0
))
3460 } /* switch (code) */
This page took 0.207033 seconds and 6 git commands to generate.