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.

Index: gcc/df-problems.c
===================================================================
--- gcc/df-problems.c	(revision 276598)
+++ gcc/df-problems.c	(working copy)
@@ -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));
Index: gcc/df-scan.c
===================================================================
--- gcc/df-scan.c	(revision 276598)
+++ gcc/df-scan.c	(working copy)
@@ -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);
Index: gcc/diagnostic-show-locus.c
===================================================================
--- gcc/diagnostic-show-locus.c	(revision 276598)
+++ gcc/diagnostic-show-locus.c	(working copy)
@@ -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);
 	}
Index: gcc/dse.c
===================================================================
--- gcc/dse.c	(revision 276598)
+++ gcc/dse.c	(working copy)
@@ -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;
Index: gcc/dwarf2cfi.c
===================================================================
--- gcc/dwarf2cfi.c	(revision 276598)
+++ gcc/dwarf2cfi.c	(working copy)
@@ -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;
Index: gcc/dwarf2out.c
===================================================================
--- gcc/dwarf2out.c	(revision 276598)
+++ gcc/dwarf2out.c	(working copy)
@@ -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.  */
Index: gcc/emit-rtl.c
===================================================================
--- gcc/emit-rtl.c	(revision 276598)
+++ gcc/emit-rtl.c	(working copy)
@@ -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;
Index: gcc/expmed.c
===================================================================
--- gcc/expmed.c	(revision 276598)
+++ gcc/expmed.c	(working copy)
@@ -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;
Index: gcc/final.c
===================================================================
--- gcc/final.c	(revision 276598)
+++ gcc/final.c	(working copy)
@@ -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);
     }
 }
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c	(revision 276598)
+++ gcc/fold-const.c	(working copy)
@@ -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)
Index: gcc/function.c
===================================================================
--- gcc/function.c	(revision 276598)
+++ gcc/function.c	(working copy)
@@ -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;
Index: gcc/fwprop.c
===================================================================
--- gcc/fwprop.c	(revision 276598)
+++ gcc/fwprop.c	(working copy)
@@ -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));
 	}
