aboutsummaryrefslogtreecommitdiff
path: root/gcc/combine.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc/combine.c')
-rw-r--r--gcc/combine.c220
1 files changed, 111 insertions, 109 deletions
diff --git a/gcc/combine.c b/gcc/combine.c
index e85e9d1c477..c6736ac23ea 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -340,10 +340,12 @@ static int nonzero_sign_valid;
/* Record one modification to rtl structure
to be undone by storing old_contents into *where. */
+enum undo_kind { UNDO_RTX, UNDO_INT, UNDO_MODE };
+
struct undo
{
struct undo *next;
- enum { UNDO_RTX, UNDO_INT, UNDO_MODE } kind;
+ enum undo_kind kind;
union { rtx r; int i; enum machine_mode m; } old_contents;
union { rtx *r; int *i; } where;
};
@@ -1642,7 +1644,7 @@ struct likely_spilled_retval_info
static void
likely_spilled_retval_1 (rtx x, rtx set, void *data)
{
- struct likely_spilled_retval_info *info = data;
+ struct likely_spilled_retval_info *info = (struct likely_spilled_retval_info *) data;
unsigned regno, nregs;
unsigned new_mask;
@@ -1734,7 +1736,7 @@ adjust_for_new_dest (rtx insn)
/* The new insn will have a destination that was previously the destination
of an insn just above it. Call distribute_links to make a LOG_LINK from
the next use of that destination. */
- distribute_links (gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX));
+ distribute_links (gen_rtx_INSN_LIST (REG_DEP_TRUE, insn, NULL_RTX));
}
/* Return TRUE if combine can reuse reg X in mode MODE.
@@ -3873,7 +3875,7 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
enum machine_mode op0_mode = VOIDmode;
const char *fmt;
int len, i;
- rtx new;
+ rtx tmp;
/* Two expressions are equal if they are identical copies of a shared
RTX or if they are both registers with the same register number
@@ -3928,14 +3930,14 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
&& GET_CODE (XVECEXP (x, 0, 0)) == SET
&& GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
{
- new = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
+ tmp = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
/* If this substitution failed, this whole thing fails. */
- if (GET_CODE (new) == CLOBBER
- && XEXP (new, 0) == const0_rtx)
- return new;
+ if (GET_CODE (tmp) == CLOBBER
+ && XEXP (tmp, 0) == const0_rtx)
+ return tmp;
- SUBST (XVECEXP (x, 0, 0), new);
+ SUBST (XVECEXP (x, 0, 0), tmp);
for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
{
@@ -3945,14 +3947,14 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
&& GET_CODE (dest) != CC0
&& GET_CODE (dest) != PC)
{
- new = subst (dest, from, to, 0, unique_copy);
+ tmp = subst (dest, from, to, 0, unique_copy);
/* If this substitution failed, this whole thing fails. */
- if (GET_CODE (new) == CLOBBER
- && XEXP (new, 0) == const0_rtx)
- return new;
+ if (GET_CODE (tmp) == CLOBBER
+ && XEXP (tmp, 0) == const0_rtx)
+ return tmp;
- SUBST (SET_DEST (XVECEXP (x, 0, i)), new);
+ SUBST (SET_DEST (XVECEXP (x, 0, i)), tmp);
}
}
}
@@ -3985,33 +3987,33 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
{
if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
{
- new = (unique_copy && n_occurrences
+ tmp = (unique_copy && n_occurrences
? copy_rtx (to) : to);
n_occurrences++;
}
else
{
- new = subst (XVECEXP (x, i, j), from, to, 0,
+ tmp = subst (XVECEXP (x, i, j), from, to, 0,
unique_copy);
/* If this substitution failed, this whole thing
fails. */
- if (GET_CODE (new) == CLOBBER
- && XEXP (new, 0) == const0_rtx)
- return new;
+ if (GET_CODE (tmp) == CLOBBER
+ && XEXP (tmp, 0) == const0_rtx)
+ return tmp;
}
- SUBST (XVECEXP (x, i, j), new);
+ SUBST (XVECEXP (x, i, j), tmp);
}
}
else if (fmt[i] == 'e')
{
/* If this is a register being set, ignore it. */
- new = XEXP (x, i);
+ tmp = XEXP (x, i);
if (in_dest
&& i == 0
&& (((code == SUBREG || code == ZERO_EXTRACT)
- && REG_P (new))
+ && REG_P (tmp))
|| code == STRICT_LOW_PART))
;
@@ -4052,7 +4054,7 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
#endif
- new = (unique_copy && n_occurrences ? copy_rtx (to) : to);
+ tmp = (unique_copy && n_occurrences ? copy_rtx (to) : to);
n_occurrences++;
}
else
@@ -4064,7 +4066,7 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
things aside from REG and MEM that should appear in a
SET_DEST. */
- new = subst (XEXP (x, i), from, to,
+ tmp = subst (XEXP (x, i), from, to,
(((in_dest
&& (code == SUBREG || code == STRICT_LOW_PART
|| code == ZERO_EXTRACT))
@@ -4077,30 +4079,30 @@ subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
well as prevent accidents where two CLOBBERs are considered
to be equal, thus producing an incorrect simplification. */
- if (GET_CODE (new) == CLOBBER && XEXP (new, 0) == const0_rtx)
- return new;
+ if (GET_CODE (tmp) == CLOBBER && XEXP (tmp, 0) == const0_rtx)
+ return tmp;
if (GET_CODE (x) == SUBREG
- && (GET_CODE (new) == CONST_INT
- || GET_CODE (new) == CONST_DOUBLE))
+ && (GET_CODE (tmp) == CONST_INT
+ || GET_CODE (tmp) == CONST_DOUBLE))
{
enum machine_mode mode = GET_MODE (x);
- x = simplify_subreg (GET_MODE (x), new,
+ x = simplify_subreg (GET_MODE (x), tmp,
GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
if (! x)
x = gen_rtx_CLOBBER (mode, const0_rtx);
}
- else if (GET_CODE (new) == CONST_INT
+ else if (GET_CODE (tmp) == CONST_INT
&& GET_CODE (x) == ZERO_EXTEND)
{
x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
- new, GET_MODE (XEXP (x, 0)));
+ tmp, GET_MODE (XEXP (x, 0)));
gcc_assert (x);
}
else
- SUBST (XEXP (x, i), new);
+ SUBST (XEXP (x, i), tmp);
}
}
}
@@ -5214,9 +5216,9 @@ simplify_set (rtx x)
/* Attempt to simplify CC user. */
if (GET_CODE (pat) == SET)
{
- rtx new = simplify_rtx (SET_SRC (pat));
- if (new != NULL_RTX)
- SUBST (SET_SRC (pat), new);
+ rtx tmp = simplify_rtx (SET_SRC (pat));
+ if (tmp != NULL_RTX)
+ SUBST (SET_SRC (pat), tmp);
}
/* Convert X into a no-op move. */
@@ -5949,7 +5951,7 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
enum machine_mode pos_mode = word_mode;
enum machine_mode extraction_mode = word_mode;
enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
- rtx new = 0;
+ rtx tmp = 0;
rtx orig_pos_rtx = pos_rtx;
HOST_WIDE_INT orig_pos;
@@ -5973,11 +5975,11 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
(ashift X (const_int C)), where LEN > C. Extract the
least significant (LEN - C) bits of X, giving an rtx
whose mode is MODE, then shift it left C times. */
- new = make_extraction (mode, XEXP (inner, 0),
+ tmp = make_extraction (mode, XEXP (inner, 0),
0, 0, len - INTVAL (XEXP (inner, 1)),
unsignedp, in_dest, in_compare);
- if (new != 0)
- return gen_rtx_ASHIFT (mode, new, XEXP (inner, 1));
+ if (tmp != 0)
+ return gen_rtx_ASHIFT (mode, tmp, XEXP (inner, 1));
}
inner_mode = GET_MODE (inner);
@@ -6033,7 +6035,7 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
else
offset = pos / BITS_PER_UNIT;
- new = adjust_address_nv (inner, tmode, offset);
+ tmp = adjust_address_nv (inner, tmode, offset);
}
else if (REG_P (inner))
{
@@ -6063,16 +6065,16 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
if (!validate_subreg (tmode, inner_mode, inner, final_word))
return NULL_RTX;
- new = gen_rtx_SUBREG (tmode, inner, final_word);
+ tmp = gen_rtx_SUBREG (tmode, inner, final_word);
}
else
- new = gen_lowpart (tmode, inner);
+ tmp = gen_lowpart (tmode, inner);
}
else
- new = inner;
+ tmp = inner;
}
else
- new = force_to_mode (inner, tmode,
+ tmp = force_to_mode (inner, tmode,
len >= HOST_BITS_PER_WIDE_INT
? ~(unsigned HOST_WIDE_INT) 0
: ((unsigned HOST_WIDE_INT) 1 << len) - 1,
@@ -6082,30 +6084,30 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
make a STRICT_LOW_PART unless we made a MEM. */
if (in_dest)
- return (MEM_P (new) ? new
- : (GET_CODE (new) != SUBREG
+ return (MEM_P (tmp) ? tmp
+ : (GET_CODE (tmp) != SUBREG
? gen_rtx_CLOBBER (tmode, const0_rtx)
- : gen_rtx_STRICT_LOW_PART (VOIDmode, new)));
+ : gen_rtx_STRICT_LOW_PART (VOIDmode, tmp)));
if (mode == tmode)
- return new;
+ return tmp;
- if (GET_CODE (new) == CONST_INT)
- return gen_int_mode (INTVAL (new), mode);
+ if (GET_CODE (tmp) == CONST_INT)
+ return gen_int_mode (INTVAL (tmp), mode);
/* If we know that no extraneous bits are set, and that the high
bit is not set, convert the extraction to the cheaper of
sign and zero extension, that are equivalent in these cases. */
if (flag_expensive_optimizations
&& (GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
- && ((nonzero_bits (new, tmode)
+ && ((nonzero_bits (tmp, tmode)
& ~(((unsigned HOST_WIDE_INT)
GET_MODE_MASK (tmode))
>> 1))
== 0)))
{
- rtx temp = gen_rtx_ZERO_EXTEND (mode, new);
- rtx temp1 = gen_rtx_SIGN_EXTEND (mode, new);
+ rtx temp = gen_rtx_ZERO_EXTEND (mode, tmp);
+ rtx temp1 = gen_rtx_SIGN_EXTEND (mode, tmp);
/* Prefer ZERO_EXTENSION, since it gives more information to
backends. */
@@ -6118,7 +6120,7 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
proper mode. */
return (gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
- mode, new));
+ mode, tmp));
}
/* Unless this is a COMPARE or we have a funny memory reference,
@@ -6322,12 +6324,12 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
pos_rtx = GEN_INT (pos);
/* Make the required operation. See if we can use existing rtx. */
- new = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
+ tmp = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
extraction_mode, inner, GEN_INT (len), pos_rtx);
if (! in_dest)
- new = gen_lowpart (mode, new);
+ tmp = gen_lowpart (mode, tmp);
- return new;
+ return tmp;
}
/* See if X contains an ASHIFT of COUNT or more bits that can be commuted
@@ -6403,7 +6405,7 @@ make_compound_operation (rtx x, enum rtx_code in_code)
rtx rhs, lhs;
enum rtx_code next_code;
int i;
- rtx new = 0;
+ rtx tmp = 0;
rtx tem;
const char *fmt;
@@ -6428,8 +6430,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
&& INTVAL (XEXP (x, 1)) >= 0)
{
- new = make_compound_operation (XEXP (x, 0), next_code);
- new = gen_rtx_MULT (mode, new,
+ tmp = make_compound_operation (XEXP (x, 0), next_code);
+ tmp = gen_rtx_MULT (mode, tmp,
GEN_INT ((HOST_WIDE_INT) 1
<< INTVAL (XEXP (x, 1))));
}
@@ -6446,8 +6448,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
&& (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
{
- new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
- new = make_extraction (mode, new, 0, XEXP (XEXP (x, 0), 1), i, 1,
+ tmp = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
+ tmp = make_extraction (mode, tmp, 0, XEXP (XEXP (x, 0), 1), i, 1,
0, in_code == COMPARE);
}
@@ -6457,9 +6459,9 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
&& (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
{
- new = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
+ tmp = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
next_code);
- new = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new, 0,
+ tmp = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), tmp, 0,
XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
0, in_code == COMPARE);
}
@@ -6471,12 +6473,12 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
{
/* Apply the distributive law, and then try to make extractions. */
- new = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
+ tmp = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
XEXP (x, 1)),
gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
XEXP (x, 1)));
- new = make_compound_operation (new, in_code);
+ tmp = make_compound_operation (tmp, in_code);
}
/* If we are have (and (rotate X C) M) and C is larger than the number
@@ -6487,8 +6489,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0
&& i <= INTVAL (XEXP (XEXP (x, 0), 1)))
{
- new = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
- new = make_extraction (mode, new,
+ tmp = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
+ tmp = make_extraction (mode, tmp,
(GET_MODE_BITSIZE (mode)
- INTVAL (XEXP (XEXP (x, 0), 1))),
NULL_RTX, i, 1, 0, in_code == COMPARE);
@@ -6521,7 +6523,7 @@ make_compound_operation (rtx x, enum rtx_code in_code)
If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
we are in a COMPARE. */
else if ((i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
- new = make_extraction (mode,
+ tmp = make_extraction (mode,
make_compound_operation (XEXP (x, 0),
next_code),
0, NULL_RTX, i, 1, 0, in_code == COMPARE);
@@ -6530,7 +6532,7 @@ make_compound_operation (rtx x, enum rtx_code in_code)
convert this into the appropriate bit extract. */
else if (in_code == COMPARE
&& (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
- new = make_extraction (mode,
+ tmp = make_extraction (mode,
make_compound_operation (XEXP (x, 0),
next_code),
i, NULL_RTX, 1, 1, 0, 1);
@@ -6545,7 +6547,7 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& mode_width <= HOST_BITS_PER_WIDE_INT
&& (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
{
- new = gen_rtx_ASHIFTRT (mode,
+ tmp = gen_rtx_ASHIFTRT (mode,
make_compound_operation (XEXP (x, 0),
next_code),
XEXP (x, 1));
@@ -6565,8 +6567,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& GET_CODE (XEXP (lhs, 1)) == CONST_INT
&& INTVAL (rhs) >= INTVAL (XEXP (lhs, 1)))
{
- new = make_compound_operation (XEXP (lhs, 0), next_code);
- new = make_extraction (mode, new,
+ tmp = make_compound_operation (XEXP (lhs, 0), next_code);
+ tmp = make_extraction (mode, tmp,
INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
NULL_RTX, mode_width - INTVAL (rhs),
code == LSHIFTRT, 0, in_code == COMPARE);
@@ -6583,8 +6585,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
&& (OBJECT_P (SUBREG_REG (lhs))))
&& GET_CODE (rhs) == CONST_INT
&& INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
- && (new = extract_left_shift (lhs, INTVAL (rhs))) != 0)
- new = make_extraction (mode, make_compound_operation (new, next_code),
+ && (tmp = extract_left_shift (lhs, INTVAL (rhs))) != 0)
+ tmp = make_extraction (mode, make_compound_operation (tmp, next_code),
0, NULL_RTX, mode_width - INTVAL (rhs),
code == LSHIFTRT, 0, in_code == COMPARE);
@@ -6629,9 +6631,9 @@ make_compound_operation (rtx x, enum rtx_code in_code)
break;
}
- if (new)
+ if (tmp)
{
- x = gen_lowpart (mode, new);
+ x = gen_lowpart (mode, tmp);
code = GET_CODE (x);
}
@@ -6640,8 +6642,8 @@ make_compound_operation (rtx x, enum rtx_code in_code)
for (i = 0; i < GET_RTX_LENGTH (code); i++)
if (fmt[i] == 'e')
{
- new = make_compound_operation (XEXP (x, i), next_code);
- SUBST (XEXP (x, i), new);
+ tmp = make_compound_operation (XEXP (x, i), next_code);
+ SUBST (XEXP (x, i), tmp);
}
/* If this is a commutative operation, the changes to the operands
@@ -7650,16 +7652,16 @@ known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
else if (code == SUBREG)
{
enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
- rtx new, r = known_cond (SUBREG_REG (x), cond, reg, val);
+ rtx tmp, r = known_cond (SUBREG_REG (x), cond, reg, val);
if (SUBREG_REG (x) != r)
{
/* We must simplify subreg here, before we lose track of the
original inner_mode. */
- new = simplify_subreg (GET_MODE (x), r,
+ tmp = simplify_subreg (GET_MODE (x), r,
inner_mode, SUBREG_BYTE (x));
- if (new)
- return new;
+ if (tmp)
+ return tmp;
else
SUBST (SUBREG_REG (x), r);
}
@@ -7675,16 +7677,16 @@ known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
else if (code == ZERO_EXTEND)
{
enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
- rtx new, r = known_cond (XEXP (x, 0), cond, reg, val);
+ rtx tmp, r = known_cond (XEXP (x, 0), cond, reg, val);
if (XEXP (x, 0) != r)
{
/* We must simplify the zero_extend here, before we lose
track of the original inner_mode. */
- new = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
+ tmp = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
r, inner_mode);
- if (new)
- return new;
+ if (tmp)
+ return tmp;
else
SUBST (XEXP (x, 0), r);
}
@@ -8531,7 +8533,7 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
enum rtx_code outer_op = UNKNOWN;
HOST_WIDE_INT outer_const = 0;
int complement_p = 0;
- rtx new, x;
+ rtx tmp, x;
/* Make sure and truncate the "natural" shift on the way in. We don't
want to do this inside the loop as it makes it more difficult to
@@ -8653,10 +8655,10 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
case ZERO_EXTEND:
case SIGN_EXTRACT:
case ZERO_EXTRACT:
- new = expand_compound_operation (varop);
- if (new != varop)
+ tmp = expand_compound_operation (varop);
+ if (tmp != varop)
{
- varop = new;
+ varop = tmp;
continue;
}
break;
@@ -8671,12 +8673,12 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
&& (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
MODE_INT, 1)) != BLKmode)
{
- new = adjust_address_nv (varop, tmode,
+ tmp = adjust_address_nv (varop, tmode,
BYTES_BIG_ENDIAN ? 0
: count / BITS_PER_UNIT);
varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
- : ZERO_EXTEND, mode, new);
+ : ZERO_EXTEND, mode, tmp);
count = 0;
continue;
}
@@ -8897,10 +8899,10 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
&& GET_CODE (XEXP (varop, 0)) == CONST_INT
&& GET_CODE (XEXP (varop, 1)) != CONST_INT)
{
- rtx new = simplify_const_binary_operation (code, mode,
+ rtx tmp = simplify_const_binary_operation (code, mode,
XEXP (varop, 0),
GEN_INT (count));
- varop = gen_rtx_fmt_ee (code, mode, new, XEXP (varop, 1));
+ varop = gen_rtx_fmt_ee (code, mode, tmp, XEXP (varop, 1));
count = 0;
continue;
}
@@ -8951,12 +8953,12 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
&& !(code == ASHIFTRT && GET_CODE (varop) == XOR
&& 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
shift_mode))
- && (new = simplify_const_binary_operation (code, result_mode,
+ && (tmp = simplify_const_binary_operation (code, result_mode,
XEXP (varop, 1),
GEN_INT (count))) != 0
- && GET_CODE (new) == CONST_INT
+ && GET_CODE (tmp) == CONST_INT
&& merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
- INTVAL (new), result_mode, &complement_p))
+ INTVAL (tmp), result_mode, &complement_p))
{
varop = XEXP (varop, 0);
continue;
@@ -9079,12 +9081,12 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
/* (ashift (plus foo C) N) is (plus (ashift foo N) C'). */
if (code == ASHIFT
&& GET_CODE (XEXP (varop, 1)) == CONST_INT
- && (new = simplify_const_binary_operation (ASHIFT, result_mode,
+ && (tmp = simplify_const_binary_operation (ASHIFT, result_mode,
XEXP (varop, 1),
GEN_INT (count))) != 0
- && GET_CODE (new) == CONST_INT
+ && GET_CODE (tmp) == CONST_INT
&& merge_outer_ops (&outer_op, &outer_const, PLUS,
- INTVAL (new), result_mode, &complement_p))
+ INTVAL (tmp), result_mode, &complement_p))
{
varop = XEXP (varop, 0);
continue;
@@ -9098,12 +9100,12 @@ simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
if (code == LSHIFTRT
&& GET_CODE (XEXP (varop, 1)) == CONST_INT
&& mode_signbit_p (result_mode, XEXP (varop, 1))
- && (new = simplify_const_binary_operation (code, result_mode,
+ && (tmp = simplify_const_binary_operation (code, result_mode,
XEXP (varop, 1),
GEN_INT (count))) != 0
- && GET_CODE (new) == CONST_INT
+ && GET_CODE (tmp) == CONST_INT
&& merge_outer_ops (&outer_op, &outer_const, XOR,
- INTVAL (new), result_mode, &complement_p))
+ INTVAL (tmp), result_mode, &complement_p))
{
varop = XEXP (varop, 0);
continue;
@@ -10890,11 +10892,11 @@ record_value_for_reg (rtx reg, rtx insn, rtx value)
reg_stat[i].last_set = insn;
reg_stat[i].last_set_value = 0;
- reg_stat[i].last_set_mode = 0;
+ reg_stat[i].last_set_mode = VOIDmode;
reg_stat[i].last_set_nonzero_bits = 0;
reg_stat[i].last_set_sign_bit_copies = 0;
reg_stat[i].last_death = 0;
- reg_stat[i].truncated_to_mode = 0;
+ reg_stat[i].truncated_to_mode = VOIDmode;
}
/* Mark registers that are being referenced in this value. */
@@ -11031,11 +11033,11 @@ record_dead_and_set_regs (rtx insn)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
{
reg_stat[i].last_set_value = 0;
- reg_stat[i].last_set_mode = 0;
+ reg_stat[i].last_set_mode = VOIDmode;
reg_stat[i].last_set_nonzero_bits = 0;
reg_stat[i].last_set_sign_bit_copies = 0;
reg_stat[i].last_death = 0;
- reg_stat[i].truncated_to_mode = 0;
+ reg_stat[i].truncated_to_mode = VOIDmode;
}
last_call_cuid = mem_last_set = INSN_CUID (insn);
@@ -12427,7 +12429,7 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2,
REG_N_DEATHS (REGNO (XEXP (note, 0)))++;
REG_NOTES (place2) = gen_rtx_fmt_ee (GET_CODE (note),
- REG_NOTE_KIND (note),
+ (enum machine_mode) REG_NOTE_KIND (note),
XEXP (note, 0),
REG_NOTES (place2));
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-16 02:04:57 +0000