49a50
> #include "rtl.h"
52,54d52
< /* Handle floating overflow for `const_binop'. */
< static jmp_buf float_error;
<
97a96,98
> static int count_cond PROTO((tree, int));
> static void const_binop_1 PROTO((PTR));
> static void fold_convert_1 PROTO((PTR));
380c381
< int prec;
---
> int prec ATTRIBUTE_UNUSED;
531c532
< if (hden == 0 && lden < BASE)
---
> if (hden == 0 && lden < (HOST_WIDE_INT) BASE)
886a888
> jmp_buf float_error;
965a968,1196
>
>
> /* Convert C9X hexadecimal floating point string constant S. Return
> real value type in mode MODE. This function uses the host computer's
> fp arithmetic when there is no REAL_ARITHMETIC. */
>
> REAL_VALUE_TYPE
> real_hex_to_f (s, mode)
> char *s;
> enum machine_mode mode;
> {
> REAL_VALUE_TYPE ip;
> char *p = s;
> unsigned HOST_WIDE_INT low, high;
> int frexpon, expon, shcount, nrmcount, k;
> int sign, expsign, decpt, isfloat, isldouble, gotp, lost;
> char c;
>
> isldouble = 0;
> isfloat = 0;
> frexpon = 0;
> expon = 0;
> expsign = 1;
> ip = 0.0;
>
> while (*p == ' ' || *p == '\t')
> ++p;
>
> /* Sign, if any, comes first. */
> sign = 1;
> if (*p == '-')
> {
> sign = -1;
> ++p;
> }
>
> /* The string is supposed to start with 0x or 0X . */
> if (*p == '0')
> {
> ++p;
> if (*p == 'x' || *p == 'X')
> ++p;
> else
> abort ();
> }
> else
> abort ();
>
> while (*p == '0')
> ++p;
>
> high = 0;
> low = 0;
> lost = 0; /* Nonzero low order bits shifted out and discarded. */
> frexpon = 0; /* Bits after the decimal point. */
> expon = 0; /* Value of exponent. */
> decpt = 0; /* How many decimal points. */
> gotp = 0; /* How many P's. */
> shcount = 0;
> while ((c = *p) != '\0')
> {
> if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
> || (c >= 'a' && c <= 'f'))
> {
> k = c & 0x7f;
> if (k >= 'a')
> k = k - 'a' + 10;
> else if (k >= 'A')
> k = k - 'A' + 10;
> else
> k = k - '0';
>
> if ((high & 0xf0000000) == 0)
> {
> high = (high << 4) + ((low >> 28) & 15);
> low = (low << 4) + k;
> shcount += 4;
> if (decpt)
> frexpon += 4;
> }
> else
> {
> /* Record nonzero lost bits. */
> lost |= k;
> if (!decpt)
> frexpon -= 4;
> }
> ++p;
> }
> else if ( c == '.')
> {
> ++decpt;
> ++p;
> }
> else if (c == 'p' || c == 'P')
> {
> ++gotp;
> ++p;
> /* Sign of exponent. */
> if (*p == '-')
> {
> expsign = -1;
> ++p;
> }
> /* Value of exponent.
> The exponent field is a decimal integer. */
> while (isdigit(*p))
> {
> k = (*p++ & 0x7f) - '0';
> expon = 10 * expon + k;
> }
> expon *= expsign;
> /* F suffix is ambiguous in the significand part
> so it must appear after the decimal exponent field. */
> if (*p == 'f' || *p == 'F')
> {
> isfloat = 1;
> ++p;
> break;
> }
> }
> else if (c == 'l' || c == 'L')
> {
> isldouble = 1;
> ++p;
> break;
> }
> else
> break;
> }
> /* Abort if last character read was not legitimate. */
> c = *p;
> if ((c != '\0' && c != ' ' && c != '\n' && c != '\r') || (decpt > 1))
> abort ();
> /* There must be either one decimal point or one p. */
> if (decpt == 0 && gotp == 0)
> abort ();
> shcount -= 4;
> if ((high == 0) && (low == 0))
> {
> return dconst0;
> }
>
> /* Normalize. */
> nrmcount = 0;
> if (high == 0)
> {
> high = low;
> low = 0;
> nrmcount += 32;
> }
> /* Leave a high guard bit for carry-out. */
> if ((high & 0x80000000) != 0)
> {
> lost |= low & 1;
> low = (low >> 1) | (high << 31);
> high = high >> 1;
> nrmcount -= 1;
> }
> if ((high & 0xffff8000) == 0)
> {
> high = (high << 16) + ((low >> 16) & 0xffff);
> low = low << 16;
> nrmcount += 16;
> }
> while ((high & 0xc0000000) == 0)
> {
> high = (high << 1) + ((low >> 31) & 1);
> low = low << 1;
> nrmcount += 1;
> }
> if (isfloat || GET_MODE_SIZE(mode) == UNITS_PER_WORD)
> {
> /* Keep 24 bits precision, bits 0x7fffff80.
> Rounding bit is 0x40. */
> lost = lost | low | (high & 0x3f);
> low = 0;
> if (high & 0x40)
> {
> if ((high & 0x80) || lost)
> high += 0x40;
> }
> high &= 0xffffff80;
> }
> else
> {
> /* We need real.c to do long double formats, so here default
> to double precision. */
> #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
> /* IEEE double.
> Keep 53 bits precision, bits 0x7fffffff fffffc00.
> Rounding bit is low word 0x200. */
> lost = lost | (low & 0x1ff);
> if (low & 0x200)
> {
> if ((low & 0x400) || lost)
> {
> low = (low + 0x200) & 0xfffffc00;
> if (low == 0)
> high += 1;
> }
> }
> low &= 0xfffffc00;
> #else
> /* Assume it's a VAX with 56-bit significand,
> bits 0x7fffffff ffffff80. */
> lost = lost | (low & 0x7f);
> if (low & 0x40)
> {
> if ((low & 0x80) || lost)
> {
> low = (low + 0x40) & 0xffffff80;
> if (low == 0)
> high += 1;
> }
> }
> low &= 0xffffff80;
> #endif
> }
> ip = (double) high;
> ip = REAL_VALUE_LDEXP (ip, 32) + (double) low;
> /* Apply shifts and exponent value as power of 2. */
> ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
>
> if (sign < 0)
> ip = -ip;
> return ip;
> }
>
1249a1481,1541
> struct cb_args
> {
> /* Input */
> tree arg1;
> REAL_VALUE_TYPE d1, d2;
> enum tree_code code;
> /* Output */
> tree t;
> };
>
> static void
> const_binop_1 (data)
> PTR data;
> {
> struct cb_args * args = (struct cb_args *) data;
> REAL_VALUE_TYPE value;
>
> #ifdef REAL_ARITHMETIC
> REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
> #else
> switch (args->code)
> {
> case PLUS_EXPR:
> value = args->d1 + args->d2;
> break;
>
> case MINUS_EXPR:
> value = args->d1 - args->d2;
> break;
>
> case MULT_EXPR:
> value = args->d1 * args->d2;
> break;
>
> case RDIV_EXPR:
> #ifndef REAL_INFINITY
> if (args->d2 == 0)
> abort ();
> #endif
>
> value = args->d1 / args->d2;
> break;
>
> case MIN_EXPR:
> value = MIN (args->d1, args->d2);
> break;
>
> case MAX_EXPR:
> value = MAX (args->d1, args->d2);
> break;
>
> default:
> abort ();
> }
> #endif /* no REAL_ARITHMETIC */
> args->t =
> build_real (TREE_TYPE (args->arg1),
> real_value_truncate (TYPE_MODE (TREE_TYPE (args->arg1)),
> value));
> }
>
1274d1565
< REAL_VALUE_TYPE value;
1275a1567
> struct cb_args args;
1286c1578,1585
< else if (setjmp (float_error))
---
>
> /* Setup input for const_binop_1() */
> args.arg1 = arg1;
> args.d1 = d1;
> args.d2 = d2;
> args.code = code;
>
> if (do_float_handler (const_binop_1, (PTR) &args))
1287a1587,1592
> /* Receive output from const_binop_1() */
> t = args.t;
> }
> else
> {
> /* We got an exception from const_binop_1() */
1290d1594
< goto got_float;
1293,1337d1596
< set_float_handler (float_error);
<
< #ifdef REAL_ARITHMETIC
< REAL_ARITHMETIC (value, code, d1, d2);
< #else
< switch (code)
< {
< case PLUS_EXPR:
< value = d1 + d2;
< break;
<
< case MINUS_EXPR:
< value = d1 - d2;
< break;
<
< case MULT_EXPR:
< value = d1 * d2;
< break;
<
< case RDIV_EXPR:
< #ifndef REAL_INFINITY
< if (d2 == 0)
< abort ();
< #endif
<
< value = d1 / d2;
< break;
<
< case MIN_EXPR:
< value = MIN (d1, d2);
< break;
<
< case MAX_EXPR:
< value = MAX (d1, d2);
< break;
<
< default:
< abort ();
< }
< #endif /* no REAL_ARITHMETIC */
< t = build_real (TREE_TYPE (arg1),
< real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
< got_float:
< set_float_handler (NULL_PTR);
<
1526a1786,1804
> struct fc_args
> {
> /* Input */
> tree arg1, type;
> /* Output */
> tree t;
> };
>
> static void
> fold_convert_1 (data)
> PTR data;
> {
> struct fc_args * args = (struct fc_args *) data;
>
> args->t = build_real (args->type,
> real_value_truncate (TYPE_MODE (args->type),
> TREE_REAL_CST (args->arg1)));
> }
>
1651a1930,1931
> struct fc_args args;
>
1658c1938,1943
< else if (setjmp (float_error))
---
>
> /* Setup input for fold_convert_1() */
> args.arg1 = arg1;
> args.type = type;
>
> if (do_float_handler (fold_convert_1, (PTR) &args))
1659a1945,1950
> /* Receive output from fold_convert_1() */
> t = args.t;
> }
> else
> {
> /* We got an exception from fold_convert_1() */
1662d1952
< goto got_it;
1664d1953
< set_float_handler (float_error);
1666,1670d1954
< t = build_real (type, real_value_truncate (TYPE_MODE (type),
< TREE_REAL_CST (arg1)));
< set_float_handler (NULL_PTR);
<
< got_it:
1682,1683c1966
< /* Return an expr equal to X but certainly not valid as an lvalue.
< Also make sure it is not valid as an null pointer constant. */
---
> /* Return an expr equal to X but certainly not valid as an lvalue. */
1697,1708c1980
< {
< if (TREE_CODE (x) == INTEGER_CST && integer_zerop (x))
< {
< /* Use NOP_EXPR instead of NON_LVALUE_EXPR
< so convert_for_assignment won't strip it.
< This is so this 0 won't be treated as a null pointer constant. */
< result = build1 (NOP_EXPR, TREE_TYPE (x), x);
< TREE_CONSTANT (result) = TREE_CONSTANT (x);
< return result;
< }
< return x;
< }
---
> return x;
1930a2203,2207
>
> case 'e':
> if (TREE_CODE (arg0) == RTL_EXPR)
> return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
> return 0;
2154c2431
< /* fall through (???) */
---
> /* fall through - ??? */
2239c2516
< && code != NE_EXPR && code != EQ_EXPR)
---
> && !flag_fast_math && code != NE_EXPR && code != EQ_EXPR)
2540,2541c2817,2818
< warning ("comparison is always %s due to width of bitfield",
< code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d due to width of bitfield",
> code == NE_EXPR);
2553,2554c2830,2831
< warning ("comparison is always %s due to width of bitfield",
< code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d due to width of bitfield",
> code == NE_EXPR);
2835c3112
< tree arg0, arg1, type = NULL_TREE;
---
> tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
2865a3143,3147
> /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
> lose a cast by accident. */
> if (type != NULL_TREE && orig_type == NULL_TREE)
> orig_type = type;
>
2984,2985d3265
< if (orig_type == NULL_TREE)
< orig_type = type;
3333d3612
<
3434c3713
< tree type, result;
---
> tree lntype, rntype, result;
3530,3538c3809,3813
< if (ll_unsignedp || tree_log2 (ll_mask) + 1 < ll_bitsize)
< l_const = ll_mask;
< else
< /* Since ll_arg is a single bit bit mask, we can sign extend
< it appropriately with a NEGATE_EXPR.
< l_const is made a signed value here, but since for l_const != NULL
< lr_unsignedp is not used, we don't need to clear the latter. */
< l_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (ll_arg),
< convert (TREE_TYPE (ll_arg), ll_mask)));
---
> /* Make the left operand unsigned, since we are only interested
> in the value of one bit. Otherwise we are doing the wrong
> thing below. */
> ll_unsignedp = 1;
> l_const = ll_mask;
3543a3819
> /* This is analogous to the code for l_const above. */
3548,3553c3824,3825
< if (rl_unsignedp || tree_log2 (rl_mask) + 1 < rl_bitsize)
< r_const = rl_mask;
< else
< /* This is analogous to the code for l_const above. */
< r_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (rl_arg),
< convert (TREE_TYPE (rl_arg), rl_mask)));
---
> rl_unsignedp = 1;
> r_const = rl_mask;
3572c3844
< type = type_for_size (lnbitsize, 1);
---
> lntype = type_for_size (lnbitsize, 1);
3581c3853
< ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
---
> ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3583c3855
< rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
---
> rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3588c3860
< l_const = convert (type, l_const);
---
> l_const = convert (lntype, l_const);
3593c3865
< type, ll_mask)),
---
> lntype, ll_mask)),
3596,3597c3868
< warning ("comparison is always %s",
< wanted_code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d", wanted_code == NE_EXPR);
3606c3877
< r_const = convert (type, r_const);
---
> r_const = convert (lntype, r_const);
3611c3882
< type, rl_mask)),
---
> lntype, rl_mask)),
3614,3616c3885,3886
< warning ("comparison is always %s",
< wanted_code == NE_EXPR ? "one" : "zero");
<
---
> warning ("comparison is always %d", wanted_code == NE_EXPR);
>
3644a3915
> rntype = type_for_size (rnbitsize, 1);
3653c3924
< lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
---
> lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
3655c3926
< rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
---
> rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
3659,3660c3930,3932
< Do this for both items being compared. If the masks agree,
< we can do this by masking both and comparing the masked
---
> Do this for both items being compared. If the operands are the
> same size and the bits being compared are in the same position
> then we can do this by masking both and comparing the masked
3664c3936
< if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
---
> if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
3666c3938
< lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
---
> lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3668,3669d3939
< rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
< lr_unsignedp || rr_unsignedp);
3671,3674c3941,3947
< {
< lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
< rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
< }
---
> lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
>
> rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
> lr_unsignedp || rr_unsignedp);
> if (! all_ones_mask_p (lr_mask, rnbitsize))
> rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
>
3680c3953,3957
< field containing them both. */
---
> field containing them both.
>
> Note that we still must mask the lhs/rhs expressions. Furthermore,
> the mask must be shifted to account for the shift done by
> make_bit_field_ref. */
3685,3693c3962,3963
< return build (wanted_code, truth_type,
< make_bit_field_ref (ll_inner, type,
< ll_bitsize + rl_bitsize,
< MIN (ll_bitpos, rl_bitpos),
< ll_unsignedp),
< make_bit_field_ref (lr_inner, type,
< lr_bitsize + rr_bitsize,
< MIN (lr_bitpos, rr_bitpos),
< lr_unsignedp));
---
> {
> tree type;
3694a3965,4001
> lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
> MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
> rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
> MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
>
> ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
> size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
> lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
> size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
>
> /* Convert to the smaller type before masking out unwanted bits. */
> type = lntype;
> if (lntype != rntype)
> {
> if (lnbitsize > rnbitsize)
> {
> lhs = convert (rntype, lhs);
> ll_mask = convert (rntype, ll_mask);
> type = rntype;
> }
> else if (lnbitsize < rnbitsize)
> {
> rhs = convert (lntype, rhs);
> lr_mask = convert (lntype, lr_mask);
> type = lntype;
> }
> }
>
> if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
> lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
>
> if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
> rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
>
> return build (wanted_code, truth_type, lhs, rhs);
> }
>
3714c4021
< warning ("`and' of mutually exclusive equal-tests is always zero");
---
> warning ("`and' of mutually exclusive equal-tests is always 0");
3723c4030
< result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
---
> result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3728c4035
< result = build (BIT_AND_EXPR, type, result, ll_mask);
---
> result = build (BIT_AND_EXPR, lntype, result, ll_mask);
3790a4098,4118
> /* Utility function for the following routine, to see how complex a nesting of
> COND_EXPRs can be. EXPR is the expression and LIMIT is a count beyond which
> we don't care (to avoid spending too much time on complex expressions.). */
>
> static int
> count_cond (expr, lim)
> tree expr;
> int lim;
> {
> int true, false;
>
> if (TREE_CODE (expr) != COND_EXPR)
> return 0;
> else if (lim <= 0)
> return 0;
>
> true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
> false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
> return MIN (lim, 1 + true + false);
> }
>
4013a4342,4343
> && (TREE_CODE (arg0) != COND_EXPR
> || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4086a4417,4418
> && (TREE_CODE (arg1) != COND_EXPR
> || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4428,4430c4760,4763
< /* (A * C) + (B * C) -> (A+B) * C. Since we are most concerned
< about the case where C is a constant, just try one of the
< four possibilities. */
---
> if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
> {
> tree arg00, arg01, arg10, arg11;
> tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
4432,4439c4765,4789
< if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
< && operand_equal_p (TREE_OPERAND (arg0, 1),
< TREE_OPERAND (arg1, 1), 0))
< return fold (build (MULT_EXPR, type,
< fold (build (PLUS_EXPR, type,
< TREE_OPERAND (arg0, 0),
< TREE_OPERAND (arg1, 0))),
< TREE_OPERAND (arg0, 1)));
---
> /* (A * C) + (B * C) -> (A+B) * C.
> We are most concerned about the case where C is a constant,
> but other combinations show up during loop reduction. Since
> it is not difficult, try all four possibilities. */
>
> arg00 = TREE_OPERAND (arg0, 0);
> arg01 = TREE_OPERAND (arg0, 1);
> arg10 = TREE_OPERAND (arg1, 0);
> arg11 = TREE_OPERAND (arg1, 1);
> same = NULL_TREE;
>
> if (operand_equal_p (arg01, arg11, 0))
> same = arg01, alt0 = arg00, alt1 = arg10;
> else if (operand_equal_p (arg00, arg10, 0))
> same = arg00, alt0 = arg01, alt1 = arg11;
> else if (operand_equal_p (arg00, arg11, 0))
> same = arg00, alt0 = arg01, alt1 = arg10;
> else if (operand_equal_p (arg01, arg10, 0))
> same = arg01, alt0 = arg00, alt1 = arg11;
>
> if (same)
> return fold (build (MULT_EXPR, type,
> fold (build (PLUS_EXPR, type, alt0, alt1)),
> same));
> }
4692a5043,5044
> STRIP_NOPS (tree01);
> STRIP_NOPS (tree11);
4703,4718c5055,5088
< else if (code11 == MINUS_EXPR
< && TREE_CODE (TREE_OPERAND (tree11, 0)) == INTEGER_CST
< && TREE_INT_CST_HIGH (TREE_OPERAND (tree11, 0)) == 0
< && TREE_INT_CST_LOW (TREE_OPERAND (tree11, 0))
< == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
< && operand_equal_p (tree01, TREE_OPERAND (tree11, 1), 0))
< return build (code0 == LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
< type, TREE_OPERAND (arg0, 0), tree01);
< else if (code01 == MINUS_EXPR
< && TREE_CODE (TREE_OPERAND (tree01, 0)) == INTEGER_CST
< && TREE_INT_CST_HIGH (TREE_OPERAND (tree01, 0)) == 0
< && TREE_INT_CST_LOW (TREE_OPERAND (tree01, 0))
< == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
< && operand_equal_p (tree11, TREE_OPERAND (tree01, 1), 0))
< return build (code0 != LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
< type, TREE_OPERAND (arg0, 0), tree11);
---
> else if (code11 == MINUS_EXPR)
> {
> tree tree110, tree111;
> tree110 = TREE_OPERAND (tree11, 0);
> tree111 = TREE_OPERAND (tree11, 1);
> STRIP_NOPS (tree110);
> STRIP_NOPS (tree111);
> if (TREE_CODE (tree110) == INTEGER_CST
> && TREE_INT_CST_HIGH (tree110) == 0
> && (TREE_INT_CST_LOW (tree110)
> == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
> && operand_equal_p (tree01, tree111, 0))
> return build ((code0 == LSHIFT_EXPR
> ? LROTATE_EXPR
> : RROTATE_EXPR),
> type, TREE_OPERAND (arg0, 0), tree01);
> }
> else if (code01 == MINUS_EXPR)
> {
> tree tree010, tree011;
> tree010 = TREE_OPERAND (tree01, 0);
> tree011 = TREE_OPERAND (tree01, 1);
> STRIP_NOPS (tree010);
> STRIP_NOPS (tree011);
> if (TREE_CODE (tree010) == INTEGER_CST
> && TREE_INT_CST_HIGH (tree010) == 0
> && (TREE_INT_CST_LOW (tree010)
> == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
> && operand_equal_p (tree11, tree011, 0))
> return build ((code0 != LSHIFT_EXPR
> ? LROTATE_EXPR
> : RROTATE_EXPR),
> type, TREE_OPERAND (arg0, 0), tree11);
> }
5827c6197,6198
< arg1 = TREE_OPERAND (t, 2);
---
> /* arg1 should be the first argument of the new T. */
> arg1 = TREE_OPERAND (t, 1);
5864a6236,6237
> if (TREE_UNSIGNED (TREE_TYPE (arg1)))
> arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
5869a6243,6244
> if (TREE_UNSIGNED (TREE_TYPE (arg1)))
> arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6016c6391,6392
< arg1 = TREE_OPERAND (t, 2);
---
> /* arg1 should be the first argument of the new T. */
> arg1 = TREE_OPERAND (t, 1);
6052c6428
< return non_lvalue (arg1);
---
> return build1 (NOP_EXPR, TREE_TYPE (arg1), arg1);
> #include "rtl.h"
52,54d52
< /* Handle floating overflow for `const_binop'. */
< static jmp_buf float_error;
<
97a96,98
> static int count_cond PROTO((tree, int));
> static void const_binop_1 PROTO((PTR));
> static void fold_convert_1 PROTO((PTR));
380c381
< int prec;
---
> int prec ATTRIBUTE_UNUSED;
531c532
< if (hden == 0 && lden < BASE)
---
> if (hden == 0 && lden < (HOST_WIDE_INT) BASE)
886a888
> jmp_buf float_error;
965a968,1196
>
>
> /* Convert C9X hexadecimal floating point string constant S. Return
> real value type in mode MODE. This function uses the host computer's
> fp arithmetic when there is no REAL_ARITHMETIC. */
>
> REAL_VALUE_TYPE
> real_hex_to_f (s, mode)
> char *s;
> enum machine_mode mode;
> {
> REAL_VALUE_TYPE ip;
> char *p = s;
> unsigned HOST_WIDE_INT low, high;
> int frexpon, expon, shcount, nrmcount, k;
> int sign, expsign, decpt, isfloat, isldouble, gotp, lost;
> char c;
>
> isldouble = 0;
> isfloat = 0;
> frexpon = 0;
> expon = 0;
> expsign = 1;
> ip = 0.0;
>
> while (*p == ' ' || *p == '\t')
> ++p;
>
> /* Sign, if any, comes first. */
> sign = 1;
> if (*p == '-')
> {
> sign = -1;
> ++p;
> }
>
> /* The string is supposed to start with 0x or 0X . */
> if (*p == '0')
> {
> ++p;
> if (*p == 'x' || *p == 'X')
> ++p;
> else
> abort ();
> }
> else
> abort ();
>
> while (*p == '0')
> ++p;
>
> high = 0;
> low = 0;
> lost = 0; /* Nonzero low order bits shifted out and discarded. */
> frexpon = 0; /* Bits after the decimal point. */
> expon = 0; /* Value of exponent. */
> decpt = 0; /* How many decimal points. */
> gotp = 0; /* How many P's. */
> shcount = 0;
> while ((c = *p) != '\0')
> {
> if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F')
> || (c >= 'a' && c <= 'f'))
> {
> k = c & 0x7f;
> if (k >= 'a')
> k = k - 'a' + 10;
> else if (k >= 'A')
> k = k - 'A' + 10;
> else
> k = k - '0';
>
> if ((high & 0xf0000000) == 0)
> {
> high = (high << 4) + ((low >> 28) & 15);
> low = (low << 4) + k;
> shcount += 4;
> if (decpt)
> frexpon += 4;
> }
> else
> {
> /* Record nonzero lost bits. */
> lost |= k;
> if (!decpt)
> frexpon -= 4;
> }
> ++p;
> }
> else if ( c == '.')
> {
> ++decpt;
> ++p;
> }
> else if (c == 'p' || c == 'P')
> {
> ++gotp;
> ++p;
> /* Sign of exponent. */
> if (*p == '-')
> {
> expsign = -1;
> ++p;
> }
> /* Value of exponent.
> The exponent field is a decimal integer. */
> while (isdigit(*p))
> {
> k = (*p++ & 0x7f) - '0';
> expon = 10 * expon + k;
> }
> expon *= expsign;
> /* F suffix is ambiguous in the significand part
> so it must appear after the decimal exponent field. */
> if (*p == 'f' || *p == 'F')
> {
> isfloat = 1;
> ++p;
> break;
> }
> }
> else if (c == 'l' || c == 'L')
> {
> isldouble = 1;
> ++p;
> break;
> }
> else
> break;
> }
> /* Abort if last character read was not legitimate. */
> c = *p;
> if ((c != '\0' && c != ' ' && c != '\n' && c != '\r') || (decpt > 1))
> abort ();
> /* There must be either one decimal point or one p. */
> if (decpt == 0 && gotp == 0)
> abort ();
> shcount -= 4;
> if ((high == 0) && (low == 0))
> {
> return dconst0;
> }
>
> /* Normalize. */
> nrmcount = 0;
> if (high == 0)
> {
> high = low;
> low = 0;
> nrmcount += 32;
> }
> /* Leave a high guard bit for carry-out. */
> if ((high & 0x80000000) != 0)
> {
> lost |= low & 1;
> low = (low >> 1) | (high << 31);
> high = high >> 1;
> nrmcount -= 1;
> }
> if ((high & 0xffff8000) == 0)
> {
> high = (high << 16) + ((low >> 16) & 0xffff);
> low = low << 16;
> nrmcount += 16;
> }
> while ((high & 0xc0000000) == 0)
> {
> high = (high << 1) + ((low >> 31) & 1);
> low = low << 1;
> nrmcount += 1;
> }
> if (isfloat || GET_MODE_SIZE(mode) == UNITS_PER_WORD)
> {
> /* Keep 24 bits precision, bits 0x7fffff80.
> Rounding bit is 0x40. */
> lost = lost | low | (high & 0x3f);
> low = 0;
> if (high & 0x40)
> {
> if ((high & 0x80) || lost)
> high += 0x40;
> }
> high &= 0xffffff80;
> }
> else
> {
> /* We need real.c to do long double formats, so here default
> to double precision. */
> #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
> /* IEEE double.
> Keep 53 bits precision, bits 0x7fffffff fffffc00.
> Rounding bit is low word 0x200. */
> lost = lost | (low & 0x1ff);
> if (low & 0x200)
> {
> if ((low & 0x400) || lost)
> {
> low = (low + 0x200) & 0xfffffc00;
> if (low == 0)
> high += 1;
> }
> }
> low &= 0xfffffc00;
> #else
> /* Assume it's a VAX with 56-bit significand,
> bits 0x7fffffff ffffff80. */
> lost = lost | (low & 0x7f);
> if (low & 0x40)
> {
> if ((low & 0x80) || lost)
> {
> low = (low + 0x40) & 0xffffff80;
> if (low == 0)
> high += 1;
> }
> }
> low &= 0xffffff80;
> #endif
> }
> ip = (double) high;
> ip = REAL_VALUE_LDEXP (ip, 32) + (double) low;
> /* Apply shifts and exponent value as power of 2. */
> ip = REAL_VALUE_LDEXP (ip, expon - (nrmcount + frexpon));
>
> if (sign < 0)
> ip = -ip;
> return ip;
> }
>
1249a1481,1541
> struct cb_args
> {
> /* Input */
> tree arg1;
> REAL_VALUE_TYPE d1, d2;
> enum tree_code code;
> /* Output */
> tree t;
> };
>
> static void
> const_binop_1 (data)
> PTR data;
> {
> struct cb_args * args = (struct cb_args *) data;
> REAL_VALUE_TYPE value;
>
> #ifdef REAL_ARITHMETIC
> REAL_ARITHMETIC (value, args->code, args->d1, args->d2);
> #else
> switch (args->code)
> {
> case PLUS_EXPR:
> value = args->d1 + args->d2;
> break;
>
> case MINUS_EXPR:
> value = args->d1 - args->d2;
> break;
>
> case MULT_EXPR:
> value = args->d1 * args->d2;
> break;
>
> case RDIV_EXPR:
> #ifndef REAL_INFINITY
> if (args->d2 == 0)
> abort ();
> #endif
>
> value = args->d1 / args->d2;
> break;
>
> case MIN_EXPR:
> value = MIN (args->d1, args->d2);
> break;
>
> case MAX_EXPR:
> value = MAX (args->d1, args->d2);
> break;
>
> default:
> abort ();
> }
> #endif /* no REAL_ARITHMETIC */
> args->t =
> build_real (TREE_TYPE (args->arg1),
> real_value_truncate (TYPE_MODE (TREE_TYPE (args->arg1)),
> value));
> }
>
1274d1565
< REAL_VALUE_TYPE value;
1275a1567
> struct cb_args args;
1286c1578,1585
< else if (setjmp (float_error))
---
>
> /* Setup input for const_binop_1() */
> args.arg1 = arg1;
> args.d1 = d1;
> args.d2 = d2;
> args.code = code;
>
> if (do_float_handler (const_binop_1, (PTR) &args))
1287a1587,1592
> /* Receive output from const_binop_1() */
> t = args.t;
> }
> else
> {
> /* We got an exception from const_binop_1() */
1290d1594
< goto got_float;
1293,1337d1596
< set_float_handler (float_error);
<
< #ifdef REAL_ARITHMETIC
< REAL_ARITHMETIC (value, code, d1, d2);
< #else
< switch (code)
< {
< case PLUS_EXPR:
< value = d1 + d2;
< break;
<
< case MINUS_EXPR:
< value = d1 - d2;
< break;
<
< case MULT_EXPR:
< value = d1 * d2;
< break;
<
< case RDIV_EXPR:
< #ifndef REAL_INFINITY
< if (d2 == 0)
< abort ();
< #endif
<
< value = d1 / d2;
< break;
<
< case MIN_EXPR:
< value = MIN (d1, d2);
< break;
<
< case MAX_EXPR:
< value = MAX (d1, d2);
< break;
<
< default:
< abort ();
< }
< #endif /* no REAL_ARITHMETIC */
< t = build_real (TREE_TYPE (arg1),
< real_value_truncate (TYPE_MODE (TREE_TYPE (arg1)), value));
< got_float:
< set_float_handler (NULL_PTR);
<
1526a1786,1804
> struct fc_args
> {
> /* Input */
> tree arg1, type;
> /* Output */
> tree t;
> };
>
> static void
> fold_convert_1 (data)
> PTR data;
> {
> struct fc_args * args = (struct fc_args *) data;
>
> args->t = build_real (args->type,
> real_value_truncate (TYPE_MODE (args->type),
> TREE_REAL_CST (args->arg1)));
> }
>
1651a1930,1931
> struct fc_args args;
>
1658c1938,1943
< else if (setjmp (float_error))
---
>
> /* Setup input for fold_convert_1() */
> args.arg1 = arg1;
> args.type = type;
>
> if (do_float_handler (fold_convert_1, (PTR) &args))
1659a1945,1950
> /* Receive output from fold_convert_1() */
> t = args.t;
> }
> else
> {
> /* We got an exception from fold_convert_1() */
1662d1952
< goto got_it;
1664d1953
< set_float_handler (float_error);
1666,1670d1954
< t = build_real (type, real_value_truncate (TYPE_MODE (type),
< TREE_REAL_CST (arg1)));
< set_float_handler (NULL_PTR);
<
< got_it:
1682,1683c1966
< /* Return an expr equal to X but certainly not valid as an lvalue.
< Also make sure it is not valid as an null pointer constant. */
---
> /* Return an expr equal to X but certainly not valid as an lvalue. */
1697,1708c1980
< {
< if (TREE_CODE (x) == INTEGER_CST && integer_zerop (x))
< {
< /* Use NOP_EXPR instead of NON_LVALUE_EXPR
< so convert_for_assignment won't strip it.
< This is so this 0 won't be treated as a null pointer constant. */
< result = build1 (NOP_EXPR, TREE_TYPE (x), x);
< TREE_CONSTANT (result) = TREE_CONSTANT (x);
< return result;
< }
< return x;
< }
---
> return x;
1930a2203,2207
>
> case 'e':
> if (TREE_CODE (arg0) == RTL_EXPR)
> return rtx_equal_p (RTL_EXPR_RTL (arg0), RTL_EXPR_RTL (arg1));
> return 0;
2154c2431
< /* fall through (???) */
---
> /* fall through - ??? */
2239c2516
< && code != NE_EXPR && code != EQ_EXPR)
---
> && !flag_fast_math && code != NE_EXPR && code != EQ_EXPR)
2540,2541c2817,2818
< warning ("comparison is always %s due to width of bitfield",
< code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d due to width of bitfield",
> code == NE_EXPR);
2553,2554c2830,2831
< warning ("comparison is always %s due to width of bitfield",
< code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d due to width of bitfield",
> code == NE_EXPR);
2835c3112
< tree arg0, arg1, type = NULL_TREE;
---
> tree arg0 = NULL_TREE, arg1 = NULL_TREE, type = NULL_TREE;
2865a3143,3147
> /* Set ORIG_TYPE as soon as TYPE is non-null so that we do not
> lose a cast by accident. */
> if (type != NULL_TREE && orig_type == NULL_TREE)
> orig_type = type;
>
2984,2985d3265
< if (orig_type == NULL_TREE)
< orig_type = type;
3333d3612
<
3434c3713
< tree type, result;
---
> tree lntype, rntype, result;
3530,3538c3809,3813
< if (ll_unsignedp || tree_log2 (ll_mask) + 1 < ll_bitsize)
< l_const = ll_mask;
< else
< /* Since ll_arg is a single bit bit mask, we can sign extend
< it appropriately with a NEGATE_EXPR.
< l_const is made a signed value here, but since for l_const != NULL
< lr_unsignedp is not used, we don't need to clear the latter. */
< l_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (ll_arg),
< convert (TREE_TYPE (ll_arg), ll_mask)));
---
> /* Make the left operand unsigned, since we are only interested
> in the value of one bit. Otherwise we are doing the wrong
> thing below. */
> ll_unsignedp = 1;
> l_const = ll_mask;
3543a3819
> /* This is analogous to the code for l_const above. */
3548,3553c3824,3825
< if (rl_unsignedp || tree_log2 (rl_mask) + 1 < rl_bitsize)
< r_const = rl_mask;
< else
< /* This is analogous to the code for l_const above. */
< r_const = fold (build1 (NEGATE_EXPR, TREE_TYPE (rl_arg),
< convert (TREE_TYPE (rl_arg), rl_mask)));
---
> rl_unsignedp = 1;
> r_const = rl_mask;
3572c3844
< type = type_for_size (lnbitsize, 1);
---
> lntype = type_for_size (lnbitsize, 1);
3581c3853
< ll_mask = const_binop (LSHIFT_EXPR, convert (type, ll_mask),
---
> ll_mask = const_binop (LSHIFT_EXPR, convert (lntype, ll_mask),
3583c3855
< rl_mask = const_binop (LSHIFT_EXPR, convert (type, rl_mask),
---
> rl_mask = const_binop (LSHIFT_EXPR, convert (lntype, rl_mask),
3588c3860
< l_const = convert (type, l_const);
---
> l_const = convert (lntype, l_const);
3593c3865
< type, ll_mask)),
---
> lntype, ll_mask)),
3596,3597c3868
< warning ("comparison is always %s",
< wanted_code == NE_EXPR ? "one" : "zero");
---
> warning ("comparison is always %d", wanted_code == NE_EXPR);
3606c3877
< r_const = convert (type, r_const);
---
> r_const = convert (lntype, r_const);
3611c3882
< type, rl_mask)),
---
> lntype, rl_mask)),
3614,3616c3885,3886
< warning ("comparison is always %s",
< wanted_code == NE_EXPR ? "one" : "zero");
<
---
> warning ("comparison is always %d", wanted_code == NE_EXPR);
>
3644a3915
> rntype = type_for_size (rnbitsize, 1);
3653c3924
< lr_mask = const_binop (LSHIFT_EXPR, convert (type, lr_mask),
---
> lr_mask = const_binop (LSHIFT_EXPR, convert (rntype, lr_mask),
3655c3926
< rr_mask = const_binop (LSHIFT_EXPR, convert (type, rr_mask),
---
> rr_mask = const_binop (LSHIFT_EXPR, convert (rntype, rr_mask),
3659,3660c3930,3932
< Do this for both items being compared. If the masks agree,
< we can do this by masking both and comparing the masked
---
> Do this for both items being compared. If the operands are the
> same size and the bits being compared are in the same position
> then we can do this by masking both and comparing the masked
3664c3936
< if (operand_equal_p (ll_mask, lr_mask, 0) && lnbitsize == rnbitsize)
---
> if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
3666c3938
< lhs = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
---
> lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3668,3669d3939
< rhs = make_bit_field_ref (lr_inner, type, rnbitsize, rnbitpos,
< lr_unsignedp || rr_unsignedp);
3671,3674c3941,3947
< {
< lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
< rhs = build (BIT_AND_EXPR, type, rhs, ll_mask);
< }
---
> lhs = build (BIT_AND_EXPR, lntype, lhs, ll_mask);
>
> rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
> lr_unsignedp || rr_unsignedp);
> if (! all_ones_mask_p (lr_mask, rnbitsize))
> rhs = build (BIT_AND_EXPR, rntype, rhs, lr_mask);
>
3680c3953,3957
< field containing them both. */
---
> field containing them both.
>
> Note that we still must mask the lhs/rhs expressions. Furthermore,
> the mask must be shifted to account for the shift done by
> make_bit_field_ref. */
3685,3693c3962,3963
< return build (wanted_code, truth_type,
< make_bit_field_ref (ll_inner, type,
< ll_bitsize + rl_bitsize,
< MIN (ll_bitpos, rl_bitpos),
< ll_unsignedp),
< make_bit_field_ref (lr_inner, type,
< lr_bitsize + rr_bitsize,
< MIN (lr_bitpos, rr_bitpos),
< lr_unsignedp));
---
> {
> tree type;
3694a3965,4001
> lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
> MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
> rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
> MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
>
> ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
> size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
> lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
> size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
>
> /* Convert to the smaller type before masking out unwanted bits. */
> type = lntype;
> if (lntype != rntype)
> {
> if (lnbitsize > rnbitsize)
> {
> lhs = convert (rntype, lhs);
> ll_mask = convert (rntype, ll_mask);
> type = rntype;
> }
> else if (lnbitsize < rnbitsize)
> {
> rhs = convert (lntype, rhs);
> lr_mask = convert (lntype, lr_mask);
> type = lntype;
> }
> }
>
> if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
> lhs = build (BIT_AND_EXPR, type, lhs, ll_mask);
>
> if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
> rhs = build (BIT_AND_EXPR, type, rhs, lr_mask);
>
> return build (wanted_code, truth_type, lhs, rhs);
> }
>
3714c4021
< warning ("`and' of mutually exclusive equal-tests is always zero");
---
> warning ("`and' of mutually exclusive equal-tests is always 0");
3723c4030
< result = make_bit_field_ref (ll_inner, type, lnbitsize, lnbitpos,
---
> result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
3728c4035
< result = build (BIT_AND_EXPR, type, result, ll_mask);
---
> result = build (BIT_AND_EXPR, lntype, result, ll_mask);
3790a4098,4118
> /* Utility function for the following routine, to see how complex a nesting of
> COND_EXPRs can be. EXPR is the expression and LIMIT is a count beyond which
> we don't care (to avoid spending too much time on complex expressions.). */
>
> static int
> count_cond (expr, lim)
> tree expr;
> int lim;
> {
> int true, false;
>
> if (TREE_CODE (expr) != COND_EXPR)
> return 0;
> else if (lim <= 0)
> return 0;
>
> true = count_cond (TREE_OPERAND (expr, 1), lim - 1);
> false = count_cond (TREE_OPERAND (expr, 2), lim - 1 - true);
> return MIN (lim, 1 + true + false);
> }
>
4013a4342,4343
> && (TREE_CODE (arg0) != COND_EXPR
> || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4086a4417,4418
> && (TREE_CODE (arg1) != COND_EXPR
> || count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
4428,4430c4760,4763
< /* (A * C) + (B * C) -> (A+B) * C. Since we are most concerned
< about the case where C is a constant, just try one of the
< four possibilities. */
---
> if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
> {
> tree arg00, arg01, arg10, arg11;
> tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
4432,4439c4765,4789
< if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR
< && operand_equal_p (TREE_OPERAND (arg0, 1),
< TREE_OPERAND (arg1, 1), 0))
< return fold (build (MULT_EXPR, type,
< fold (build (PLUS_EXPR, type,
< TREE_OPERAND (arg0, 0),
< TREE_OPERAND (arg1, 0))),
< TREE_OPERAND (arg0, 1)));
---
> /* (A * C) + (B * C) -> (A+B) * C.
> We are most concerned about the case where C is a constant,
> but other combinations show up during loop reduction. Since
> it is not difficult, try all four possibilities. */
>
> arg00 = TREE_OPERAND (arg0, 0);
> arg01 = TREE_OPERAND (arg0, 1);
> arg10 = TREE_OPERAND (arg1, 0);
> arg11 = TREE_OPERAND (arg1, 1);
> same = NULL_TREE;
>
> if (operand_equal_p (arg01, arg11, 0))
> same = arg01, alt0 = arg00, alt1 = arg10;
> else if (operand_equal_p (arg00, arg10, 0))
> same = arg00, alt0 = arg01, alt1 = arg11;
> else if (operand_equal_p (arg00, arg11, 0))
> same = arg00, alt0 = arg01, alt1 = arg10;
> else if (operand_equal_p (arg01, arg10, 0))
> same = arg01, alt0 = arg00, alt1 = arg11;
>
> if (same)
> return fold (build (MULT_EXPR, type,
> fold (build (PLUS_EXPR, type, alt0, alt1)),
> same));
> }
4692a5043,5044
> STRIP_NOPS (tree01);
> STRIP_NOPS (tree11);
4703,4718c5055,5088
< else if (code11 == MINUS_EXPR
< && TREE_CODE (TREE_OPERAND (tree11, 0)) == INTEGER_CST
< && TREE_INT_CST_HIGH (TREE_OPERAND (tree11, 0)) == 0
< && TREE_INT_CST_LOW (TREE_OPERAND (tree11, 0))
< == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
< && operand_equal_p (tree01, TREE_OPERAND (tree11, 1), 0))
< return build (code0 == LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
< type, TREE_OPERAND (arg0, 0), tree01);
< else if (code01 == MINUS_EXPR
< && TREE_CODE (TREE_OPERAND (tree01, 0)) == INTEGER_CST
< && TREE_INT_CST_HIGH (TREE_OPERAND (tree01, 0)) == 0
< && TREE_INT_CST_LOW (TREE_OPERAND (tree01, 0))
< == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))
< && operand_equal_p (tree11, TREE_OPERAND (tree01, 1), 0))
< return build (code0 != LSHIFT_EXPR ? LROTATE_EXPR : RROTATE_EXPR,
< type, TREE_OPERAND (arg0, 0), tree11);
---
> else if (code11 == MINUS_EXPR)
> {
> tree tree110, tree111;
> tree110 = TREE_OPERAND (tree11, 0);
> tree111 = TREE_OPERAND (tree11, 1);
> STRIP_NOPS (tree110);
> STRIP_NOPS (tree111);
> if (TREE_CODE (tree110) == INTEGER_CST
> && TREE_INT_CST_HIGH (tree110) == 0
> && (TREE_INT_CST_LOW (tree110)
> == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
> && operand_equal_p (tree01, tree111, 0))
> return build ((code0 == LSHIFT_EXPR
> ? LROTATE_EXPR
> : RROTATE_EXPR),
> type, TREE_OPERAND (arg0, 0), tree01);
> }
> else if (code01 == MINUS_EXPR)
> {
> tree tree010, tree011;
> tree010 = TREE_OPERAND (tree01, 0);
> tree011 = TREE_OPERAND (tree01, 1);
> STRIP_NOPS (tree010);
> STRIP_NOPS (tree011);
> if (TREE_CODE (tree010) == INTEGER_CST
> && TREE_INT_CST_HIGH (tree010) == 0
> && (TREE_INT_CST_LOW (tree010)
> == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0))))
> && operand_equal_p (tree11, tree011, 0))
> return build ((code0 != LSHIFT_EXPR
> ? LROTATE_EXPR
> : RROTATE_EXPR),
> type, TREE_OPERAND (arg0, 0), tree11);
> }
5827c6197,6198
< arg1 = TREE_OPERAND (t, 2);
---
> /* arg1 should be the first argument of the new T. */
> arg1 = TREE_OPERAND (t, 1);
5864a6236,6237
> if (TREE_UNSIGNED (TREE_TYPE (arg1)))
> arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
5869a6243,6244
> if (TREE_UNSIGNED (TREE_TYPE (arg1)))
> arg1 = convert (signed_type (TREE_TYPE (arg1)), arg1);
6016c6391,6392
< arg1 = TREE_OPERAND (t, 2);
---
> /* arg1 should be the first argument of the new T. */
> arg1 = TREE_OPERAND (t, 1);
6052c6428
< return non_lvalue (arg1);
---
> return build1 (NOP_EXPR, TREE_TYPE (arg1), arg1);