* cfg.c (dump_reg_info): Avoid C++ keywords.

	* dwarf2asm.c (dw2_force_const_mem,
	dw2_asm_output_encoded_addr_rtx): Likewise.
	* except.c (gen_eh_region, add_action_record, output_ttype):
	Likewise.
	* expmed.c (expand_shift): Likewise.
	* global.c (find_reg): Likewise.
	* graph.c (draw_edge): Likewise.
	* local-alloc.c (reg_meets_class_p, find_free_reg): Likewise.
	* optabs.c (expand_binop, expand_twoval_unop, expand_twoval_binop,
	widen_clz, widen_bswap, expand_parity, expand_unop,
	emit_cmp_and_jump_insn_1): Likewise.
	* postreload.c (reload_cse_simplify_operands): Likewise.
	* ra.h (add_neighbor): Likewise.
	* reg-stack.c (remove_regno_note, change_stack): Likewise.
	* regclass.c (memory_move_secondary_cost, dump_regclass, regclass,
	record_reg_classes, copy_cost, record_address_regs,
	invalid_mode_change_p): Likewise.
	* regrename.c (regrename_optimize, scan_rtx_reg,
	dump_def_use_chain, find_oldest_value_reg,
	replace_oldest_value_reg, copyprop_hardreg_forward_1): Likewise.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@137893 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 69 insertions, 69 deletions

diff --git a/gcc/regrename.c b/gcc/regrename.c
index 8e48ad58a94..0ed810e6393 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -222,13 +222,13 @@ regrename_optimize (void)
 	{
 	  int new_reg, best_new_reg;
 	  int n_uses;
-	  struct du_chain *this = all_chains;
+	  struct du_chain *this_du = all_chains;
 	  struct du_chain *tmp, *last;
 	  HARD_REG_SET this_unavailable;
-	  int reg = REGNO (*this->loc);
+	  int reg = REGNO (*this_du->loc);
 	  int i;
 
-	  all_chains = this->next_chain;
+	  all_chains = this_du->next_chain;
 
 	  best_new_reg = reg;
 
@@ -256,7 +256,7 @@ regrename_optimize (void)
 	     count number of uses, and narrow the set of registers we can
 	     use for renaming.  */
 	  n_uses = 0;
-	  for (last = this; last->next_use; last = last->next_use)
+	  for (last = this_du; last->next_use; last = last->next_use)
 	    {
 	      n_uses++;
 	      IOR_COMPL_HARD_REG_SET (this_unavailable,
@@ -268,16 +268,16 @@ regrename_optimize (void)
 	  IOR_COMPL_HARD_REG_SET (this_unavailable,
 				  reg_class_contents[last->cl]);
 
-	  if (this->need_caller_save_reg)
+	  if (this_du->need_caller_save_reg)
 	    IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
 
-	  merge_overlapping_regs (bb, &this_unavailable, this);
+	  merge_overlapping_regs (bb, &this_unavailable, this_du);
 
 	  /* Now potential_regs is a reasonable approximation, let's
 	     have a closer look at each register still in there.  */
 	  for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
 	    {
-	      int nregs = hard_regno_nregs[new_reg][GET_MODE (*this->loc)];
+	      int nregs = hard_regno_nregs[new_reg][GET_MODE (*this_du->loc)];
 
 	      for (i = nregs - 1; i >= 0; --i)
 	        if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
@@ -302,7 +302,7 @@ regrename_optimize (void)
 
 	      /* See whether it accepts all modes that occur in
 		 definition and uses.  */
-	      for (tmp = this; tmp; tmp = tmp->next_use)
+	      for (tmp = this_du; tmp; tmp = tmp->next_use)
 		if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc))
 		    || (tmp->need_caller_save_reg
 			&& ! (HARD_REGNO_CALL_PART_CLOBBERED
@@ -333,7 +333,7 @@ regrename_optimize (void)
 	      continue;
 	    }
 
-	  do_replace (this, best_new_reg);
+	  do_replace (this_du, best_new_reg);
 	  tick[best_new_reg] = ++this_tick;
 	  df_set_regs_ever_live (best_new_reg, true);
 
@@ -385,15 +385,15 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
     {
       if (type == OP_OUT)
 	{
-	  struct du_chain *this = XOBNEW (&rename_obstack, struct du_chain);
-	  this->next_use = 0;
-	  this->next_chain = open_chains;
-	  this->loc = loc;
-	  this->insn = insn;
-	  this->cl = cl;
-	  this->need_caller_save_reg = 0;
-	  this->earlyclobber = earlyclobber;
-	  open_chains = this;
+	  struct du_chain *this_du = XOBNEW (&rename_obstack, struct du_chain);
+	  this_du->next_use = 0;
+	  this_du->next_chain = open_chains;
+	  this_du->loc = loc;
+	  this_du->insn = insn;
+	  this_du->cl = cl;
+	  this_du->need_caller_save_reg = 0;
+	  this_du->earlyclobber = earlyclobber;
+	  open_chains = this_du;
 	}
       return;
     }
@@ -403,7 +403,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 
   for (p = &open_chains; *p;)
     {
-      struct du_chain *this = *p;
+      struct du_chain *this_du = *p;
 
       /* Check if the chain has been terminated if it has then skip to
 	 the next chain.
@@ -412,18 +412,18 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 	 the chain in Step 3, but are trying to hide in-out operands
 	 from terminate_write in Step 5.  */
 
-      if (*this->loc == cc0_rtx)
-	p = &this->next_chain;
+      if (*this_du->loc == cc0_rtx)
+	p = &this_du->next_chain;
       else
 	{
-	  int regno = REGNO (*this->loc);
-	  int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)];
+	  int regno = REGNO (*this_du->loc);
+	  int nregs = hard_regno_nregs[regno][GET_MODE (*this_du->loc)];
 	  int exact_match = (regno == this_regno && nregs == this_nregs);
 
 	  if (regno + nregs <= this_regno
 	      || this_regno + this_nregs <= regno)
 	    {
-	      p = &this->next_chain;
+	      p = &this_du->next_chain;
 	      continue;
 	    }
 
@@ -437,23 +437,23 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 		 be replaced with, terminate the chain.  */
 	      if (cl != NO_REGS)
 		{
-		  this = XOBNEW (&rename_obstack, struct du_chain);
-		  this->next_use = 0;
-		  this->next_chain = (*p)->next_chain;
-		  this->loc = loc;
-		  this->insn = insn;
-		  this->cl = cl;
-		  this->need_caller_save_reg = 0;
+		  this_du = XOBNEW (&rename_obstack, struct du_chain);
+		  this_du->next_use = 0;
+		  this_du->next_chain = (*p)->next_chain;
+		  this_du->loc = loc;
+		  this_du->insn = insn;
+		  this_du->cl = cl;
+		  this_du->need_caller_save_reg = 0;
 		  while (*p)
 		    p = &(*p)->next_use;
-		  *p = this;
+		  *p = this_du;
 		  return;
 		}
 	    }
 
 	  if (action != terminate_overlapping_read || ! exact_match)
 	    {
-	      struct du_chain *next = this->next_chain;
+	      struct du_chain *next = this_du->next_chain;
 
 	      /* Whether the terminated chain can be used for renaming
 	         depends on the action and this being an exact match.
@@ -462,12 +462,12 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 	      if ((action == terminate_dead || action == terminate_write)
 		  && exact_match)
 		{
-		  this->next_chain = closed_chains;
-		  closed_chains = this;
+		  this_du->next_chain = closed_chains;
+		  closed_chains = this_du;
 		  if (dump_file)
 		    fprintf (dump_file,
 			     "Closing chain %s at insn %d (%s)\n",
-			     reg_names[REGNO (*this->loc)], INSN_UID (insn),
+			     reg_names[REGNO (*this_du->loc)], INSN_UID (insn),
 			     scan_actions_name[(int) action]);
 		}
 	      else
@@ -475,13 +475,13 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 		  if (dump_file)
 		    fprintf (dump_file,
 			     "Discarding chain %s at insn %d (%s)\n",
-			     reg_names[REGNO (*this->loc)], INSN_UID (insn),
+			     reg_names[REGNO (*this_du->loc)], INSN_UID (insn),
 			     scan_actions_name[(int) action]);
 		}
 	      *p = next;
 	    }
 	  else
-	    p = &this->next_chain;
+	    p = &this_du->next_chain;
 	}
     }
 }
@@ -976,15 +976,15 @@ dump_def_use_chain (struct du_chain *chains)
 {
   while (chains)
     {
-      struct du_chain *this = chains;
-      int r = REGNO (*this->loc);
-      int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
+      struct du_chain *this_du = chains;
+      int r = REGNO (*this_du->loc);
+      int nregs = hard_regno_nregs[r][GET_MODE (*this_du->loc)];
       fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
-      while (this)
+      while (this_du)
 	{
-	  fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
-		   reg_class_names[this->cl]);
-	  this = this->next_use;
+	  fprintf (dump_file, " %d [%s]", INSN_UID (this_du->insn),
+		   reg_class_names[this_du->cl]);
+	  this_du = this_du->next_use;
 	}
       fprintf (dump_file, "\n");
       chains = chains->next_chain;
@@ -1365,17 +1365,17 @@ find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
   for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
     {
       enum machine_mode oldmode = vd->e[i].mode;
-      rtx new;
+      rtx new_rtx;
 
       if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
 	return NULL_RTX;
 
-      new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
-      if (new)
+      new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
+      if (new_rtx)
 	{
-	  ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
-	  REG_ATTRS (new) = REG_ATTRS (reg);
-	  return new;
+	  ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
+	  REG_ATTRS (new_rtx) = REG_ATTRS (reg);
+	  return new_rtx;
 	}
     }
 
@@ -1389,14 +1389,14 @@ static bool
 replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
 			  struct value_data *vd)
 {
-  rtx new = find_oldest_value_reg (cl, *loc, vd);
-  if (new)
+  rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
+  if (new_rtx)
     {
       if (dump_file)
 	fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
-		 INSN_UID (insn), REGNO (*loc), REGNO (new));
+		 INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
 
-      validate_change (insn, loc, new, 1);
+      validate_change (insn, loc, new_rtx, 1);
       return true;
     }
   return false;
@@ -1634,7 +1634,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	  unsigned int regno = REGNO (src);
 	  enum machine_mode mode = GET_MODE (src);
 	  unsigned int i;
-	  rtx new;
+	  rtx new_rtx;
 
 	  /* If we are accessing SRC in some mode other that what we
 	     set it in, make sure that the replacement is valid.  */
@@ -1649,13 +1649,13 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	     register in the same class.  */
 	  if (REG_P (SET_DEST (set)))
 	    {
-	      new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
-	      if (new && validate_change (insn, &SET_SRC (set), new, 0))
+	      new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
+	      if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
 		{
 		  if (dump_file)
 		    fprintf (dump_file,
 			     "insn %u: replaced reg %u with %u\n",
-			     INSN_UID (insn), regno, REGNO (new));
+			     INSN_UID (insn), regno, REGNO (new_rtx));
 		  changed = true;
 		  goto did_replacement;
 		}
@@ -1665,18 +1665,18 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	  for (i = vd->e[regno].oldest_regno; i != regno;
 	       i = vd->e[i].next_regno)
 	    {
-	      new = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
+	      new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
 				       mode, i, regno);
-	      if (new != NULL_RTX)
+	      if (new_rtx != NULL_RTX)
 		{
-		  if (validate_change (insn, &SET_SRC (set), new, 0))
+		  if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
 		    {
-		      ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src);
-		      REG_ATTRS (new) = REG_ATTRS (src);
+		      ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
+		      REG_ATTRS (new_rtx) = REG_ATTRS (src);
 		      if (dump_file)
 			fprintf (dump_file,
 				 "insn %u: replaced reg %u with %u\n",
-				 INSN_UID (insn), regno, REGNO (new));
+				 INSN_UID (insn), regno, REGNO (new_rtx));
 		      changed = true;
 		      goto did_replacement;
 		    }
@@ -1729,13 +1729,13 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	  if (replaced[i])
 	    {
 	      int j;
-	      rtx new;
+	      rtx new_rtx;
 
-	      new = *recog_data.operand_loc[i];
-	      recog_data.operand[i] = new;
+	      new_rtx = *recog_data.operand_loc[i];
+	      recog_data.operand[i] = new_rtx;
 	      for (j = 0; j < recog_data.n_dups; j++)
 		if (recog_data.dup_num[j] == i)
-		  validate_unshare_change (insn, recog_data.dup_loc[j], new, 1);
+		  validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 1);
 
 	      any_replacements = true;
 	    }