1 files changed, 63 insertions, 63 deletions

diff --git a/gcc/ira.c b/gcc/ira.c
index cfce99b304d..53f049dcee3 100644
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -2950,16 +2950,16 @@ mark_elimination (int from, int to)
       r = DF_LR_IN (bb);
       if (bitmap_bit_p (r, from))
 	{
-	  bitmap_clear_bit (r, from);
-	  bitmap_set_bit (r, to);
+	  r->clear_bit (from);
+	  r->set_bit (to);
 	}
       if (! df_live)
         continue;
       r = DF_LIVE_IN (bb);
       if (bitmap_bit_p (r, from))
 	{
-	  bitmap_clear_bit (r, from);
-	  bitmap_set_bit (r, to);
+	  r->clear_bit (from);
+	  r->set_bit (to);
 	}
     }
 }
@@ -3855,7 +3855,7 @@ update_equiv_regs (void)
 			= XEXP (reg_equiv[regno].init_insns, 1);
 
 		      ira_reg_equiv[regno].init_insns = NULL_RTX;
-		      bitmap_set_bit (&cleared_regs, regno);
+		      cleared_regs.set_bit (regno);
 		    }
 		  /* Move the initialization of the register to just before
 		     INSN.  Update the flow information.  */
@@ -3889,14 +3889,14 @@ update_equiv_regs (void)
 
 		      ira_reg_equiv[regno].init_insns
 			= gen_rtx_INSN_LIST (VOIDmode, new_insn, NULL_RTX);
-		      bitmap_set_bit (&cleared_regs, regno);
+		      cleared_regs.set_bit (regno);
 		    }
 		}
 	    }
 	}
     }
 
-  if (!bitmap_empty_p (&cleared_regs))
+  if (!cleared_regs.is_empty ())
     {
       FOR_EACH_BB (bb)
 	{
@@ -4090,7 +4090,7 @@ init_live_subregs (bool init_value, sbitmap *live_subregs,
   else
     bitmap_clear (live_subregs[allocnum]);
 
-  bitmap_set_bit (live_subregs_used, allocnum);
+  live_subregs_used->set_bit (allocnum);
 }
 
 /* Walk the insns of the current function and build reload_insn_chain,
@@ -4117,27 +4117,27 @@ build_insn_chain (void)
 
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     if (TEST_HARD_REG_BIT (eliminable_regset, i))
-      bitmap_set_bit (&elim_regset, i);
+      elim_regset.set_bit (i);
   FOR_EACH_BB_REVERSE (bb)
     {
       bitmap_iterator bi;
       rtx insn;
 
       CLEAR_REG_SET (&live_relevant_regs);
-      bitmap_clear (&live_subregs_used);
+      live_subregs_used.clear ();
 
       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb), 0, i, bi)
 	{
 	  if (i >= FIRST_PSEUDO_REGISTER)
 	    break;
-	  bitmap_set_bit (&live_relevant_regs, i);
+	  live_relevant_regs.set_bit (i);
 	}
 
       EXECUTE_IF_SET_IN_BITMAP (df_get_live_out (bb),
 				FIRST_PSEUDO_REGISTER, i, bi)
 	{
 	  if (pseudo_for_reload_consideration_p (i))
-	    bitmap_set_bit (&live_relevant_regs, i);
+	    live_relevant_regs.set_bit (i);
 	}
 
       FOR_BB_INSNS_REVERSE (bb, insn)
@@ -4171,10 +4171,10 @@ build_insn_chain (void)
 			if (regno < FIRST_PSEUDO_REGISTER)
 			  {
 			    if (!fixed_regs[regno])
-			      bitmap_set_bit (&c->dead_or_set, regno);
+			      c->dead_or_set.set_bit (regno);
 			  }
 			else if (pseudo_for_reload_consideration_p (regno))
-			  bitmap_set_bit (&c->dead_or_set, regno);
+			  c->dead_or_set.set_bit (regno);
 		      }
 
 		    if ((regno < FIRST_PSEUDO_REGISTER
@@ -4220,14 +4220,14 @@ build_insn_chain (void)
 
 			    if (bitmap_empty_p (live_subregs[regno]))
 			      {
-				bitmap_clear_bit (&live_subregs_used, regno);
-				bitmap_clear_bit (&live_relevant_regs, regno);
+				live_subregs_used.clear_bit (regno);
+				live_relevant_regs.clear_bit (regno);
 			      }
 			    else
 			      /* Set live_relevant_regs here because
 				 that bit has to be true to get us to
 				 look at the live_subregs fields.  */
-			      bitmap_set_bit (&live_relevant_regs, regno);
+			      live_relevant_regs.set_bit (regno);
 			  }
 			else
 			  {
@@ -4238,8 +4238,8 @@ build_insn_chain (void)
 			       modeling the def as a killing def.  */
 			    if (!DF_REF_FLAGS_IS_SET (def, DF_REF_PARTIAL))
 			      {
-				bitmap_clear_bit (&live_subregs_used, regno);
-				bitmap_clear_bit (&live_relevant_regs, regno);
+				live_subregs_used.clear_bit (regno);
+				live_relevant_regs.clear_bit (regno);
 			      }
 			  }
 		      }
@@ -4272,10 +4272,10 @@ build_insn_chain (void)
 			if (regno < FIRST_PSEUDO_REGISTER)
 			  {
 			    if (!fixed_regs[regno])
-			      bitmap_set_bit (&c->dead_or_set, regno);
+			      c->dead_or_set.set_bit (regno);
 			  }
 			else if (pseudo_for_reload_consideration_p (regno))
-			  bitmap_set_bit (&c->dead_or_set, regno);
+			  c->dead_or_set.set_bit (regno);
 		      }
 
 		    if (regno < FIRST_PSEUDO_REGISTER
@@ -4309,8 +4309,8 @@ build_insn_chain (void)
 			     effectively saying do not use the subregs
 			     because we are reading the whole
 			     pseudo.  */
-			  bitmap_clear_bit (&live_subregs_used, regno);
-			bitmap_set_bit (&live_relevant_regs, regno);
+			  live_subregs_used.clear_bit (regno);
+			live_relevant_regs.set_bit (regno);
 		      }
 		  }
 	    }
@@ -4527,10 +4527,10 @@ find_moveable_pseudos (void)
       bitmap_copy (&live, df_get_live_out (bb));
       bitmap_and_into (&live, df_get_live_in (bb));
       bitmap_copy (transp, &live);
-      bitmap_clear (moveable);
-      bitmap_clear (&live);
-      bitmap_clear (&used);
-      bitmap_clear (&set);
+      moveable->clear ();
+      live.clear ();
+      used.clear ();
+      set.clear ();
       FOR_BB_INSNS (bb, insn)
 	if (NONDEBUG_INSN_P (insn))
 	  {
@@ -4547,35 +4547,35 @@ find_moveable_pseudos (void)
 		&& rtx_moveable_p (&PATTERN (insn), OP_IN))
 	      {
 		unsigned regno = DF_REF_REGNO (*u_rec);
-		bitmap_set_bit (moveable, regno);
-		bitmap_set_bit (&set, regno);
-		bitmap_set_bit (&used, regno);
-		bitmap_clear_bit (transp, regno);
+		moveable->set_bit (regno);
+		set.set_bit (regno);
+		used.set_bit (regno);
+		transp->clear_bit (regno);
 		continue;
 	      }
 	    while (*u_rec)
 	      {
 		unsigned regno = DF_REF_REGNO (*u_rec);
-		bitmap_set_bit (&used, regno);
-		if (bitmap_clear_bit (moveable, regno))
-		  bitmap_clear_bit (transp, regno);
+		used.set_bit (regno);
+		if (moveable->clear_bit (regno))
+		  transp->clear_bit (regno);
 		u_rec++;
 	      }
 
 	    while (*d_rec)
 	      {
 		unsigned regno = DF_REF_REGNO (*d_rec);
-		bitmap_set_bit (&set, regno);
-		bitmap_clear_bit (transp, regno);
-		bitmap_clear_bit (moveable, regno);
+		set.set_bit (regno);
+		transp->clear_bit (regno);
+		moveable->clear_bit (regno);
 		d_rec++;
 	      }
 	  }
     }
 
-  bitmap_clear (&live);
-  bitmap_clear (&used);
-  bitmap_clear (&set);
+  live.clear ();
+  used.clear ();
+  set.clear ();
 
   FOR_EACH_BB (bb)
     {
@@ -4618,7 +4618,7 @@ find_moveable_pseudos (void)
 		if (dump_file)
 		  fprintf (dump_file, "Ignoring reg %d, has equiv memory\n",
 			   regno);
-		bitmap_set_bit (&unusable_as_input, regno);
+		unusable_as_input.set_bit (regno);
 		continue;
 	      }
 
@@ -4660,7 +4660,7 @@ find_moveable_pseudos (void)
 		continue;
 	      }
 	    if (all_local)
-	      bitmap_set_bit (local, regno);
+	      local->set_bit (regno);
 	    if (closest_use == const0_rtx || closest_use == NULL
 		|| next_nonnote_nondebug_insn (def_insn) == closest_use)
 	      {
@@ -4679,7 +4679,7 @@ find_moveable_pseudos (void)
 		continue;
 	      }
 #endif
-	    bitmap_set_bit (&interesting, regno);
+	    interesting.set_bit (regno);
 	    closest_uses[regno] = closest_use;
 
 	    if (dump_file && (all_local || all_dominated))
@@ -4808,12 +4808,12 @@ find_moveable_pseudos (void)
   
   FOR_EACH_BB (bb)
     {
-      bitmap_clear (bb_local + bb->index);
-      bitmap_clear (bb_transp_live + bb->index);
-      bitmap_clear (bb_moveable_reg_sets + bb->index);
+      bb_local[bb->index].clear ();
+      bb_transp_live[bb->index].clear ();
+      bb_moveable_reg_sets[bb->index].clear ();
     }
-  bitmap_clear (&interesting);
-  bitmap_clear (&unusable_as_input);
+  interesting.clear ();
+  unusable_as_input.clear ();
   free (uid_luid);
   free (closest_uses);
   free (bb_local);
@@ -4870,22 +4870,22 @@ split_live_ranges_for_shrink_wrap (void)
 	{
 	  if (bb == first)
 	    {
-	      bitmap_clear (&need_new);
-	      bitmap_clear (&reachable);
+	      need_new.clear ();
+	      reachable.clear ();
 	      queue.release ();
 	      return false;
 	    }
 
-	  bitmap_set_bit (&need_new, bb->index);
-	  bitmap_set_bit (&reachable, bb->index);
+	  need_new.set_bit (bb->index);
+	  reachable.set_bit (bb->index);
 	  queue.quick_push (bb);
 	  break;
 	}
 
   if (queue.is_empty ())
     {
-      bitmap_clear (&need_new);
-      bitmap_clear (&reachable);
+      need_new.clear ();
+      reachable.clear ();
       queue.release ();
       return false;
     }
@@ -4898,7 +4898,7 @@ split_live_ranges_for_shrink_wrap (void)
       bb = queue.pop ();
       FOR_EACH_EDGE (e, ei, bb->succs)
 	if (e->dest != EXIT_BLOCK_PTR
-	    && bitmap_set_bit (&reachable, e->dest->index))
+	    && reachable.set_bit (e->dest->index))
 	  queue.quick_push (e->dest);
     }
   queue.release ();
@@ -4911,8 +4911,8 @@ split_live_ranges_for_shrink_wrap (void)
 
       if (DF_REG_DEF_COUNT (REGNO (dest)) > 1)
 	{
-	  bitmap_clear (&need_new);
-	  bitmap_clear (&reachable);
+	  need_new.clear ();
+	  reachable.clear ();
 	  return false;
 	}
 
@@ -4926,27 +4926,27 @@ split_live_ranges_for_shrink_wrap (void)
 	      /* This is necessary to avoid hitting an assert at
 		 postreload.c:2294 in libstc++ testcases on x86_64-linux.  I'm
 		 not really sure what the probblem actually is there.  */
-	      bitmap_clear (&need_new);
-	      bitmap_clear (&reachable);
+	      need_new.clear ();
+	      reachable.clear ();
 	      return false;
 	    }
 
 	  int ubbi = DF_REF_BB (use)->index;
 	  if (bitmap_bit_p (&reachable, ubbi))
-	    bitmap_set_bit (&need_new, ubbi);
+	    need_new.set_bit (ubbi);
 	}
       last_interesting_insn = insn;
     }
 
-  bitmap_clear (&reachable);
+  reachable.clear ();
   if (!last_interesting_insn)
     {
-      bitmap_clear (&need_new);
+      need_new.clear ();
       return false;
     }
 
   call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, &need_new);
-  bitmap_clear (&need_new);
+  need_new.clear ();
   if (call_dom == first)
     return false;