2019-10-05 Bernd Edlinger <bernd.edlinger@hotmail.de>
* df-problems.c (df_rd_transfer_function): Remove shadowing local vars.
(df_word_lr_local_compute, df_md_local_compute): Rename local var.
* df-scan.c (df_insn_rescan): Remove shadowing local var.
* diagnostic-show-locus.c (layout::print_leading_fixits): Rename local
var.
* dse.c (check_mem_read_use, get_call_args): Rename local var.
* dwarf2cfi.c (change_cfi_row): Remove shadowing local var.
(create_trace_edges): Rename local var. Remove shadowing local var.
* dwarf2out.c (build_abbrev_table): Remove shadowing local var.
(output_die): Rename local vars.
(loc_descriptor): Remove shadowing local var.
* emit-rtl.c (widen_memory_access, find_auto_inc): Rename local var.
* expmed.c (extract_integral_bit_field,
expand_divmod): Remove shadowing local var.
(emit_cstore): Rename local var.
* final.c (shorten_branches): Remove shadowing local vars.
Rename local var.
(final_scan_insn_1): Rename local vars. Remove shadowing local var.
(mark_symbol_refs_as_used): Rename local var.
* fold-const.c (fold_unary_loc, fold_comparison, fold_binary_loc,
fold_ternary_loc): Remove shadowing local var. Rename local var.
* function.c (instantiate_virtual_regs_in_rtx): Rename local var.
* fwprop.c (forward_propagate_and_simplify): Remove shadowing
local var.
===================================================================
@@ -529,11 +529,9 @@ df_rd_transfer_function (int bb_index)
basic block, and mask out DEFs of registers that are not live.
Computing the mask looks costly, but the benefit of the pruning
outweighs the cost. */
- class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+ bb_info = df_rd_get_bb_info (bb_index);
bitmap regs_live_out = &df_lr_get_bb_info (bb_index)->out;
bitmap live_defs = BITMAP_ALLOC (&df_bitmap_obstack);
- unsigned int regno;
- bitmap_iterator bi;
EXECUTE_IF_SET_IN_BITMAP (regs_live_out, 0, regno, bi)
bitmap_set_range (live_defs,
@@ -2902,9 +2900,9 @@ df_word_lr_local_compute (bitmap all_blocks ATTRIB
if (bb_index == EXIT_BLOCK)
{
unsigned regno;
- bitmap_iterator bi;
+ bitmap_iterator bi1;
EXECUTE_IF_SET_IN_BITMAP (df->exit_block_uses, FIRST_PSEUDO_REGISTER,
- regno, bi)
+ regno, bi1)
gcc_unreachable ();
}
else
@@ -4554,7 +4552,7 @@ df_md_local_compute (bitmap all_blocks)
bitmap kill = &df_md_get_bb_info (bb_index)->kill;
EXECUTE_IF_SET_IN_BITMAP (&frontiers[bb_index], 0, df_bb_index, bi2)
{
- basic_block bb = BASIC_BLOCK_FOR_FN (cfun, df_bb_index);
+ bb = BASIC_BLOCK_FOR_FN (cfun, df_bb_index);
if (bitmap_bit_p (all_blocks, df_bb_index))
bitmap_ior_and_into (&df_md_get_bb_info (df_bb_index)->init, kill,
df_get_live_in (bb));
===================================================================
@@ -1083,7 +1083,7 @@ df_insn_rescan (rtx_insn *insn)
}
else
{
- struct df_insn_info *insn_info = df_insn_create_insn_record (insn);
+ insn_info = df_insn_create_insn_record (insn);
df_insn_refs_collect (&collection_rec, bb, insn_info);
if (dump_file)
fprintf (dump_file, "scanning new insn with uid = %d.\n", uid);
===================================================================
@@ -1625,8 +1625,8 @@ layout::print_leading_fixits (linenum_type row)
/* Print all but the trailing newline of the fix-it hint.
We have to print the newline separately to avoid
getting additional pp prefixes printed. */
- for (size_t i = 0; i < hint->get_length () - 1; i++)
- pp_character (m_pp, hint->get_string ()[i]);
+ for (size_t j = 0; j < hint->get_length () - 1; j++)
+ pp_character (m_pp, hint->get_string ()[j]);
m_colorizer.set_normal_text ();
pp_newline (m_pp);
}
===================================================================
@@ -2312,9 +2312,9 @@ check_mem_read_use (rtx *loc, void *data)
subrtx_ptr_iterator::array_type array;
FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
{
- rtx *loc = *iter;
- if (MEM_P (*loc))
- check_mem_read_rtx (loc, (bb_info_t) data);
+ rtx *loc1 = *iter;
+ if (MEM_P (*loc1))
+ check_mem_read_rtx (loc1, (bb_info_t) data);
}
}
@@ -2344,8 +2344,8 @@ get_call_args (rtx call_insn, tree fn, rtx *args,
if (!is_int_mode (TYPE_MODE (TREE_VALUE (arg)), &mode))
return false;
- function_arg_info arg (mode, /*named=*/true);
- reg = targetm.calls.function_arg (args_so_far, arg);
+ function_arg_info arg_info (mode, /*named=*/true);
+ reg = targetm.calls.function_arg (args_so_far, arg_info);
if (!reg || !REG_P (reg) || GET_MODE (reg) != mode)
return false;
@@ -2377,7 +2377,7 @@ get_call_args (rtx call_insn, tree fn, rtx *args,
if (tmp)
args[idx] = tmp;
- targetm.calls.function_arg_advance (args_so_far, arg);
+ targetm.calls.function_arg_advance (args_so_far, arg_info);
}
if (arg != void_list_node || idx != nargs)
return false;
===================================================================
@@ -2216,8 +2216,7 @@ change_cfi_row (dw_cfi_row *old_row, dw_cfi_row *n
if (!old_row->window_save && new_row->window_save)
{
- dw_cfi_ref cfi = new_cfi ();
-
+ cfi = new_cfi ();
cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
add_cfi (cfi);
}
@@ -2456,8 +2455,8 @@ create_trace_edges (rtx_insn *insn)
else if (computed_jump_p (insn))
{
rtx_insn *temp;
- unsigned int i;
- FOR_EACH_VEC_SAFE_ELT (forced_labels, i, temp)
+ unsigned int k;
+ FOR_EACH_VEC_SAFE_ELT (forced_labels, k, temp)
maybe_record_trace_start (temp, insn);
}
else if (returnjump_p (insn))
@@ -2494,7 +2493,7 @@ create_trace_edges (rtx_insn *insn)
}
else if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (PATTERN (insn)))
{
- int i, n = seq->len ();
+ n = seq->len ();
for (i = 0; i < n; ++i)
create_trace_edges (seq->insn (i));
return;
===================================================================
@@ -9098,7 +9098,6 @@ build_abbrev_table (dw_die_ref die, external_ref_h
FOR_EACH_VEC_SAFE_ELT (abbrev_die_table, abbrev_id, abbrev)
{
dw_attr_node *die_a, *abbrev_a;
- unsigned ix;
bool ok = true;
if (abbrev_id == 0)
@@ -10804,7 +10803,7 @@ output_die (dw_die_ref die)
else
{
const char *sym = AT_ref (a)->die_id.die_symbol;
- int size;
+ int asize;
gcc_assert (sym);
/* In DWARF2, DW_FORM_ref_addr is sized by target address
@@ -10811,9 +10810,9 @@ output_die (dw_die_ref die)
length, whereas in DWARF3 it's always sized as an
offset. */
if (dwarf_version == 2)
- size = DWARF2_ADDR_SIZE;
+ asize = DWARF2_ADDR_SIZE;
else
- size = DWARF_OFFSET_SIZE;
+ asize = DWARF_OFFSET_SIZE;
/* ??? We cannot unconditionally output die_offset if
non-zero - others might create references to those
DIEs via symbols.
@@ -10823,10 +10822,10 @@ output_die (dw_die_ref die)
would be the correct thing to do).
??? This is the reason for the with_offset flag. */
if (AT_ref (a)->with_offset)
- dw2_asm_output_offset (size, sym, AT_ref (a)->die_offset,
+ dw2_asm_output_offset (asize, sym, AT_ref (a)->die_offset,
debug_info_section, "%s", name);
else
- dw2_asm_output_offset (size, sym, debug_info_section, "%s",
+ dw2_asm_output_offset (asize, sym, debug_info_section, "%s",
name);
}
}
@@ -10937,10 +10936,10 @@ output_die (dw_die_ref die)
case dw_val_class_discr_list:
{
dw_discr_list_ref list = AT_discr_list (a);
- const int size = size_of_discr_list (list);
+ const int csize = size_of_discr_list (list);
/* This is a block, so output its length first. */
- dw2_asm_output_data (constant_size (size), size,
+ dw2_asm_output_data (constant_size (csize), csize,
"%s: block size", name);
for (; list != NULL; list = list->dw_discr_next)
@@ -16667,7 +16666,6 @@ loc_descriptor (rtx rtl, machine_mode mode,
{
rtvec par_elems = XVEC (rtl, 0);
int num_elem = GET_NUM_ELEM (par_elems);
- machine_mode mode;
int i, size;
/* Create the first one, so we have something to add to. */
===================================================================
@@ -2624,7 +2624,7 @@ widen_memory_access (rtx memref, machine_mode mode
if (TREE_CODE (attrs.expr) == COMPONENT_REF)
{
tree field = TREE_OPERAND (attrs.expr, 1);
- tree offset = component_ref_field_offset (attrs.expr);
+ tree offset1 = component_ref_field_offset (attrs.expr);
if (! DECL_SIZE_UNIT (field))
{
@@ -2640,7 +2640,7 @@ widen_memory_access (rtx memref, machine_mode mode
break;
poly_uint64 suboffset;
- if (!poly_int_tree_p (offset, &suboffset))
+ if (!poly_int_tree_p (offset1, &suboffset))
{
attrs.expr = NULL_TREE;
break;
@@ -3813,9 +3813,9 @@ find_auto_inc (const_rtx x, const_rtx reg)
subrtx_iterator::array_type array;
FOR_EACH_SUBRTX (iter, array, x, NONCONST)
{
- const_rtx x = *iter;
- if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC
- && rtx_equal_p (reg, XEXP (x, 0)))
+ const_rtx y = *iter;
+ if (GET_RTX_CLASS (GET_CODE (y)) == RTX_AUTOINC
+ && rtx_equal_p (reg, XEXP (y, 0)))
return true;
}
return false;
===================================================================
@@ -1909,7 +1909,7 @@ extract_integral_bit_field (rtx op0, opt_scalar_in
need to be zero'd out. */
if (target_size > nwords * UNITS_PER_WORD)
{
- unsigned int i, total_words;
+ unsigned int total_words;
total_words = target_size / UNITS_PER_WORD;
for (i = nwords; i < total_words; i++)
@@ -5105,7 +5105,6 @@ expand_divmod (int rem_flag, enum tree_code code,
remainder = gen_reg_rtx (int_mode);
if (expand_twoval_binop (udivmod_optab, op0, op1, quotient, remainder, 1) == 0)
{
- rtx tem;
quotient = expand_binop (int_mode, udiv_optab, op0, op1,
quotient, 1, OPTAB_LIB_WIDEN);
tem = expand_mult (int_mode, quotient, op1, NULL_RTX, 1);
@@ -5130,7 +5129,6 @@ expand_divmod (int rem_flag, enum tree_code code,
remainder = gen_reg_rtx (int_mode);
if (expand_twoval_binop (sdivmod_optab, op0, op1, quotient, remainder, 0) == 0)
{
- rtx tem;
quotient = expand_binop (int_mode, sdiv_optab, op0, op1,
quotient, 0, OPTAB_LIB_WIDEN);
tem = expand_mult (int_mode, quotient, op1, NULL_RTX, 0);
@@ -5479,8 +5477,8 @@ emit_cstore (rtx target, enum insn_code icode, enu
gcc_assert (GET_MODE_PRECISION (result_mode) != 1
|| STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1);
- bool unsignedp = (STORE_FLAG_VALUE >= 0);
- convert_move (target, subtarget, unsignedp);
+ bool unsigned_cvt = (STORE_FLAG_VALUE >= 0);
+ convert_move (target, subtarget, unsigned_cvt);
op0 = target;
result_mode = int_target_mode;
===================================================================
@@ -893,7 +893,7 @@ shorten_branches (rtx_insn *first)
rtx_jump_table_data *table = jump_table_for_label (label);
if (!table)
{
- align_flags alignment = LABEL_ALIGN (label);
+ alignment = LABEL_ALIGN (label);
max_alignment = align_flags::max (max_alignment, alignment);
}
/* ADDR_VECs only take room if read-only data goes into the text
@@ -902,7 +902,7 @@ shorten_branches (rtx_insn *first)
|| readonly_data_section == text_section)
&& table)
{
- align_flags alignment = align_flags (ADDR_VEC_ALIGN (table));
+ alignment = align_flags (ADDR_VEC_ALIGN (table));
max_alignment = align_flags::max (max_alignment, alignment);
}
LABEL_TO_ALIGNMENT (label) = max_alignment;
@@ -910,11 +910,11 @@ shorten_branches (rtx_insn *first)
}
else if (BARRIER_P (insn))
{
- rtx_insn *label;
+ rtx_insn *label1;
- for (label = insn; label && ! INSN_P (label);
- label = NEXT_INSN (label))
- if (LABEL_P (label))
+ for (label1 = insn; label1 && ! INSN_P (label1);
+ label1 = NEXT_INSN (label1))
+ if (LABEL_P (label1))
{
align_flags alignment
= align_flags (LABEL_ALIGN_AFTER_BARRIER (insn));
@@ -947,8 +947,9 @@ shorten_branches (rtx_insn *first)
seq = get_last_insn ();
for (; seq; seq = PREV_INSN (seq))
{
- int uid = INSN_UID (seq);
int log;
+
+ uid = INSN_UID (seq);
log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq).levels[0].log : 0);
uid_align[uid] = align_tab[0];
if (log)
@@ -980,7 +981,7 @@ shorten_branches (rtx_insn *first)
for (insn = first; insn != 0; insn = NEXT_INSN (insn))
{
rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
- int len, i, min, max, insn_shuid;
+ int len, min, max, insn_shuid;
int min_align;
addr_diff_vec_flags flags;
@@ -1075,7 +1076,6 @@ shorten_branches (rtx_insn *first)
insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
else if (rtx_sequence *body_seq = dyn_cast <rtx_sequence *> (body))
{
- int i;
int const_delay_slots;
if (DELAY_SLOTS)
const_delay_slots = const_num_delay_slots (body_seq->insn (0));
@@ -1200,7 +1200,7 @@ shorten_branches (rtx_insn *first)
&& GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
{
rtx_jump_table_data *table = as_a <rtx_jump_table_data *> (insn);
- rtx body = PATTERN (insn);
+ body = PATTERN (insn);
int old_length = insn_lengths[uid];
rtx_insn *rel_lab =
safe_as_a <rtx_insn *> (XEXP (XEXP (body, 0), 0));
@@ -1317,8 +1317,6 @@ shorten_branches (rtx_insn *first)
if (NONJUMP_INSN_P (insn)
&& GET_CODE (PATTERN (insn)) == SEQUENCE)
{
- int i;
-
body = PATTERN (insn);
for (i = 0; i < XVECLEN (body, 0); i++)
{
@@ -1339,7 +1337,6 @@ shorten_branches (rtx_insn *first)
if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
{
rtx_sequence *seqn = as_a <rtx_sequence *> (PATTERN (insn));
- int i;
body = PATTERN (insn);
new_length = 0;
@@ -2751,13 +2748,13 @@ final_scan_insn_1 (rtx_insn *insn, FILE *file, int
for (i = 1; i < seq->len (); i++)
{
- rtx_insn *insn = seq->insn (i);
- rtx_insn *next = NEXT_INSN (insn);
+ rtx_insn *insn1 = seq->insn (i);
+ rtx_insn *next1 = NEXT_INSN (insn1);
/* We loop in case any instruction in a delay slot gets
split. */
do
- insn = final_scan_insn (insn, file, 0, 1, seen);
- while (insn != next);
+ insn1 = final_scan_insn (insn1, file, 0, 1, seen);
+ while (insn1 != next1);
}
#ifdef DBR_OUTPUT_SEQEND
DBR_OUTPUT_SEQEND (file);
@@ -2960,7 +2957,7 @@ final_scan_insn_1 (rtx_insn *insn, FILE *file, int
if (HAVE_peephole && optimize_p && !flag_no_peephole && !nopeepholes)
{
- rtx_insn *next = peephole (insn);
+ next = peephole (insn);
/* When peepholing, if there were notes within the peephole,
emit them before the peephole. */
if (next != 0 && next != NEXT_INSN (insn))
@@ -4023,9 +4020,9 @@ mark_symbol_refs_as_used (rtx x)
subrtx_iterator::array_type array;
FOR_EACH_SUBRTX (iter, array, x, ALL)
{
- const_rtx x = *iter;
- if (GET_CODE (x) == SYMBOL_REF)
- if (tree t = SYMBOL_REF_DECL (x))
+ const_rtx y = *iter;
+ if (GET_CODE (y) == SYMBOL_REF)
+ if (tree t = SYMBOL_REF_DECL (y))
assemble_external (t);
}
}
===================================================================
@@ -7824,7 +7824,7 @@ fold_unary_loc (location_t loc, enum tree_code cod
if (CONSTANT_CLASS_P (arg0))
{
- tree tem = const_unop (code, type, arg0);
+ tem = const_unop (code, type, arg0);
if (tem)
{
if (TREE_TYPE (tem) != type)
@@ -8586,11 +8586,11 @@ fold_comparison (location_t loc, enum tree_code co
TREE_OPERAND (arg0, 1));
if (poly_int_tree_p (offset0))
{
- poly_offset_int tem = wi::sext (wi::to_poly_offset (offset0),
- TYPE_PRECISION (sizetype));
- tem <<= LOG2_BITS_PER_UNIT;
- tem += bitpos0;
- if (tem.to_shwi (&bitpos0))
+ poly_offset_int tem0 = wi::sext (wi::to_poly_offset (offset0),
+ TYPE_PRECISION (sizetype));
+ tem0 <<= LOG2_BITS_PER_UNIT;
+ tem0 += bitpos0;
+ if (tem0.to_shwi (&bitpos0))
offset0 = NULL_TREE;
}
}
@@ -8629,11 +8629,11 @@ fold_comparison (location_t loc, enum tree_code co
TREE_OPERAND (arg1, 1));
if (poly_int_tree_p (offset1))
{
- poly_offset_int tem = wi::sext (wi::to_poly_offset (offset1),
- TYPE_PRECISION (sizetype));
- tem <<= LOG2_BITS_PER_UNIT;
- tem += bitpos1;
- if (tem.to_shwi (&bitpos1))
+ poly_offset_int tem1 = wi::sext (wi::to_poly_offset (offset1),
+ TYPE_PRECISION (sizetype));
+ tem1 <<= LOG2_BITS_PER_UNIT;
+ tem1 += bitpos1;
+ if (tem1.to_shwi (&bitpos1))
offset1 = NULL_TREE;
}
}
@@ -9561,7 +9561,7 @@ fold_binary_loc (location_t loc, enum tree_code co
&& TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
&& (!FLOAT_TYPE_P (type) || flag_associative_math))
{
- tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
+ tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
if (tem)
return tem;
}
@@ -9986,11 +9986,10 @@ fold_binary_loc (location_t loc, enum tree_code co
&& TREE_CODE (arg1) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
{
- tree tem = fold_addr_of_array_ref_difference (loc, type,
- TREE_OPERAND (arg0, 0),
- TREE_OPERAND (arg1, 0),
- code
- == POINTER_DIFF_EXPR);
+ tem = fold_addr_of_array_ref_difference (loc, type,
+ TREE_OPERAND (arg0, 0),
+ TREE_OPERAND (arg1, 0),
+ code == POINTER_DIFF_EXPR);
if (tem)
return tem;
}
@@ -10074,7 +10073,7 @@ fold_binary_loc (location_t loc, enum tree_code co
&& TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
&& (!FLOAT_TYPE_P (type) || flag_associative_math))
{
- tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
+ tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
if (tem)
return tem;
}
@@ -10676,10 +10675,10 @@ fold_binary_loc (location_t loc, enum tree_code co
if (TREE_CODE (arg00) == LSHIFT_EXPR
&& integer_onep (TREE_OPERAND (arg00, 0)))
{
- tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
- arg01, TREE_OPERAND (arg00, 1));
+ tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
+ arg01, TREE_OPERAND (arg00, 1));
tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
- build_int_cst (TREE_TYPE (arg0), 1));
+ build_int_cst (TREE_TYPE (arg0), 1));
return fold_build2_loc (loc, code, type,
fold_convert_loc (loc, TREE_TYPE (arg1), tem),
arg1);
@@ -10687,10 +10686,10 @@ fold_binary_loc (location_t loc, enum tree_code co
else if (TREE_CODE (arg01) == LSHIFT_EXPR
&& integer_onep (TREE_OPERAND (arg01, 0)))
{
- tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
- arg00, TREE_OPERAND (arg01, 1));
+ tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
+ arg00, TREE_OPERAND (arg01, 1));
tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
- build_int_cst (TREE_TYPE (arg0), 1));
+ build_int_cst (TREE_TYPE (arg0), 1));
return fold_build2_loc (loc, code, type,
fold_convert_loc (loc, TREE_TYPE (arg1), tem),
arg1);
@@ -11603,7 +11602,7 @@ fold_ternary_loc (location_t loc, enum tree_code c
&& integer_zerop (op2)
&& integer_pow2p (arg1))
{
- tree tem = TREE_OPERAND (arg0, 0);
+ tem = TREE_OPERAND (arg0, 0);
STRIP_NOPS (tem);
if (TREE_CODE (tem) == RSHIFT_EXPR
&& tree_fits_uhwi_p (TREE_OPERAND (tem, 1))
@@ -11800,13 +11799,13 @@ fold_ternary_loc (location_t loc, enum tree_code c
{
unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
unsigned bitsize = TYPE_PRECISION (TREE_TYPE (arg1));
- wide_int tem = (wi::to_wide (arg0)
- & wi::shifted_mask (bitpos, bitsize, true,
- TYPE_PRECISION (type)));
+ wide_int tem1 = (wi::to_wide (arg0)
+ & wi::shifted_mask (bitpos, bitsize, true,
+ TYPE_PRECISION (type)));
wide_int tem2
= wi::lshift (wi::zext (wi::to_wide (arg1, TYPE_PRECISION (type)),
bitsize), bitpos);
- return wide_int_to_tree (type, wi::bit_or (tem, tem2));
+ return wide_int_to_tree (type, wi::bit_or (tem1, tem2));
}
else if (TREE_CODE (arg0) == VECTOR_CST
&& CONSTANT_CLASS_P (arg1)
===================================================================
@@ -1486,8 +1486,8 @@ instantiate_virtual_regs_in_rtx (rtx *loc)
subrtx_ptr_iterator::array_type array;
FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
{
- rtx *loc = *iter;
- if (rtx x = *loc)
+ rtx *loc1 = *iter;
+ if (rtx x = *loc1)
{
rtx new_rtx;
poly_int64 offset;
@@ -1497,7 +1497,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc)
new_rtx = instantiate_new_reg (x, &offset);
if (new_rtx)
{
- *loc = plus_constant (GET_MODE (x), new_rtx, offset);
+ *loc1 = plus_constant (GET_MODE (x), new_rtx, offset);
changed = true;
}
iter.skip_subrtxes ();
@@ -1508,7 +1508,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc)
if (new_rtx)
{
XEXP (x, 0) = new_rtx;
- *loc = plus_constant (GET_MODE (x), x, offset, true);
+ *loc1 = plus_constant (GET_MODE (x), x, offset, true);
changed = true;
iter.skip_subrtxes ();
break;
===================================================================
@@ -1361,7 +1361,7 @@ forward_propagate_and_simplify (df_ref use, rtx_in
{
rtx note = find_reg_note (use_insn, REG_EQUAL, NULL_RTX);
rtx old_rtx = note ? XEXP (note, 0) : SET_SRC (use_set);
- rtx new_rtx = simplify_replace_rtx (old_rtx, src, x);
+ new_rtx = simplify_replace_rtx (old_rtx, src, x);
if (old_rtx != new_rtx)
set_unique_reg_note (use_insn, REG_EQUAL, copy_rtx (new_rtx));
}