start killing bitmap_clear

26 files changed, 92 insertions, 118 deletions

diff --git a/gcc/bitmap.c b/gcc/bitmap.c
index f647fca77a4..63a4c71bd5d 100644
--- a/gcc/bitmap.c
+++ b/gcc/bitmap.c
@@ -307,12 +307,12 @@ bitmap_elt_clear_from (bitmap head, bitmap_element *elt)
 /* Clear a bitmap by freeing the linked list.  */
 
 void
-bitmap_clear (bitmap head)
+bitmap_head::clear ()
 {
-  if (head->first)
-    bitmap_elt_clear_from (head, head->first);
+  if (first)
+    bitmap_elt_clear_from (this, first);
 
-  head->first = NULL;
+  first = NULL;
 }
 
 /* Initialize a bitmap obstack.  If BIT_OBSTACK is NULL, initialize
@@ -407,7 +407,7 @@ bitmap_obstack_free (bitmap map)
 {
   if (map)
     {
-      bitmap_clear (map);
+      map->clear ();
       map->first = (bitmap_element *) map->obstack->heads;
 
       if (GATHER_STATISTICS)
@@ -534,7 +534,7 @@ bitmap_copy (bitmap to, const_bitmap from)
   const bitmap_element *from_ptr;
   bitmap_element *to_ptr = 0;
 
-  bitmap_clear (to);
+  to->clear ();
 
   /* Copy elements in forward direction one at a time.  */
   for (from_ptr = from->first; from_ptr; from_ptr = from_ptr->next)
@@ -1053,7 +1053,7 @@ bitmap_and_compl (bitmap dst, const_bitmap a, const_bitmap b)
   if (a == b)
     {
       changed = !dst->is_empty ();
-      bitmap_clear (dst);
+      dst->clear ();
       return changed;
     }
 
@@ -1165,7 +1165,7 @@ bitmap_and_compl_into (bitmap a, const_bitmap b)
 	return false;
       else
 	{
-	  bitmap_clear (a);
+	  a->clear ();
 	  return true;
 	}
     }
@@ -1448,7 +1448,7 @@ bitmap_compl_and_into (bitmap a, const_bitmap b)
     }
   if (b->is_empty ())
     {
-      bitmap_clear (a);
+      a->clear ();
       return;
     }
 
@@ -1657,7 +1657,7 @@ bitmap_xor (bitmap dst, const_bitmap a, const_bitmap b)
   gcc_assert (dst != a && dst != b);
   if (a == b)
     {
-      bitmap_clear (dst);
+      dst->clear ();
       return;
     }
 
@@ -1732,7 +1732,7 @@ bitmap_xor_into (bitmap a, const_bitmap b)
 
   if (a == b)
     {
-      bitmap_clear (a);
+      a->clear ();
       return;
     }
 
diff --git a/gcc/bitmap.h b/gcc/bitmap.h
index 2f0112e80cf..f00e86027ad 100644
--- a/gcc/bitmap.h
+++ b/gcc/bitmap.h
@@ -179,9 +179,6 @@ struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) bitmap_element {
 extern bitmap_element bitmap_zero_bits;	/* Zero bitmap element */
 extern bitmap_obstack bitmap_default_obstack;   /* Default bitmap obstack */
 
-/* Clear a bitmap by freeing up the linked list.  */
-extern void bitmap_clear (bitmap);
-
 static void bitmap_initialize_stat (bitmap head, bitmap_obstack *obstack MEM_STAT_DECL);
 
 /* Copy a bitmap to another bitmap.  */
@@ -197,7 +194,7 @@ struct GTY(()) bitmap_head {
     bitmap_initialize_stat (this, other.obstack PASS_MEM_STAT);
     bitmap_copy (this, &other);
   }
-  ~bitmap_head () { bitmap_clear (this); }
+  ~bitmap_head () { clear (); }
 
 /* Clear a single bit in a bitmap.  Return true if the bit changed.  */
   bool clear_bit (int);
@@ -207,6 +204,8 @@ struct GTY(()) bitmap_head {
   void clear_range (unsigned int, unsigned int);
   void set_range (unsigned int, unsigned int);
 
+  void clear ();
+
   /* Count the number of bits set in the bitmap.  */
   unsigned long count_bits () const;
 
@@ -725,4 +724,10 @@ bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
        bmp_iter_and_compl (&(ITER), &(BITNUM));				\
        bmp_iter_next (&(ITER), &(BITNUM)))
 
+static inline void
+bitmap_clear (bitmap_head *b)
+{
+  b->clear ();
+}
+
 #endif /* GCC_BITMAP_H */
diff --git a/gcc/function.c b/gcc/function.c
index 22e65acb0ad..57d7522ff4a 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -6113,7 +6113,7 @@ thread_prologue_and_epilogue_insns (void)
 	 a prologue to compute the bb_antic_flags bitmap.  Exclude
 	 tail blocks; They can be duplicated to be used on paths not
 	 needing a prologue.  */
-      bitmap_clear (&bb_on_list);
+      bb_on_list.clear ();
       bitmap_and_compl (&bb_antic_flags, &bb_flags, &bb_tail);
       FOR_EACH_BB_FN (bb, cfun)
 	{
diff --git a/gcc/gcse.c b/gcc/gcse.c
index af4204e4482..ae935bd7e3e 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -1651,8 +1651,8 @@ clear_modify_mem_tables (void)
       modify_mem_list[i].release ();
       canon_modify_mem_list[i].release ();
     }
-  bitmap_clear (modify_mem_list_set);
-  bitmap_clear (blocks_with_calls);
+  modify_mem_list_set->clear ();
+  blocks_with_calls->clear ();
 }
 
 /* Release memory used by modify_mem_list_set.  */
@@ -3397,7 +3397,7 @@ hoist_code (void)
 		}
 
 	      occrs_to_hoist.release ();
-	      bitmap_clear (&from_bbs);
+	      from_bbs.clear ();
 	    }
 	}
       domby.release ();
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index dd6009cf368..678a694dbee 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -1658,7 +1658,7 @@ inline_small_functions (void)
 	  reset_edge_caches (where);
           update_caller_keys (edge_heap, where,
 			      &updated_nodes, NULL);
-          bitmap_clear (&updated_nodes);
+          updated_nodes.clear ();
 	}
     }
 
@@ -1771,7 +1771,7 @@ inline_small_functions (void)
 	  if (flag_indirect_inlining)
 	    add_new_edges_to_heap (edge_heap, new_indirect_edges);
           update_callee_keys (edge_heap, where, &updated_nodes);
-	  bitmap_clear (&updated_nodes);
+	  updated_nodes.clear ();
 	}
       else
 	{
@@ -1825,7 +1825,7 @@ inline_small_functions (void)
 	 called by function we inlined (since number of it inlinable callers
 	 might change).  */
       update_caller_keys (edge_heap, where, &updated_nodes, NULL);
-      bitmap_clear (&updated_nodes);
+      updated_nodes.clear ();
 
       if (dump_file)
 	{
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 4f151a35d7b..97af14a76b8 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -484,7 +484,7 @@ analyze_function (struct cgraph_node *fn)
     }
 
   if (cgraph_node_cannot_return (fn))
-    bitmap_clear (local->statics_written);
+    local->statics_written->clear ();
 }
 
 
diff --git a/gcc/java/jcf-parse.c b/gcc/java/jcf-parse.c
index c854916ecaa..b2ec85b6d0f 100644
--- a/gcc/java/jcf-parse.c
+++ b/gcc/java/jcf-parse.c
@@ -1422,7 +1422,7 @@ jcf_parse (JCF* jcf)
 {
   int i, code;
 
-  bitmap_clear (field_offsets);
+  field_offsets->clear ();
 
   if (jcf_parse_preamble (jcf) != 0)
     fatal_error ("not a valid Java .class file");
diff --git a/gcc/reginfo.c b/gcc/reginfo.c
index aaf7e19707e..edd0b267d5c 100644
--- a/gcc/reginfo.c
+++ b/gcc/reginfo.c
@@ -1267,7 +1267,7 @@ init_subregs_of_mode (void)
       if (NONDEBUG_INSN_P (insn))
         find_subregs_of_mode (PATTERN (insn), &subregs_of_mode);
 
-  bitmap_clear (&subregs_of_mode);
+  subregs_of_mode.clear ();
   bitmap_obstack_release (&srom_obstack);
 }
 
diff --git a/gcc/regrename.c b/gcc/regrename.c
index d2804e6f22a..13185d4ad8b 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -182,7 +182,7 @@ free_chain_data (void)
   int i;
   du_head_p ptr;
   for (i = 0; id_to_chain.iterate (i, &ptr); i++)
-    bitmap_clear (&ptr->conflicts);
+    ptr->conflicts.clear ();
 
   id_to_chain.release ();
 }
@@ -541,7 +541,7 @@ init_rename_info (struct bb_rename_info *p, basic_block bb)
   bitmap_initialize (&p->incoming_open_chains_set, &bitmap_default_obstack);
 
   open_chains = NULL;
-  bitmap_clear (open_chains_set);
+  open_chains_set->clear ();
 
   CLEAR_HARD_REG_SET (live_in_chains);
   REG_SET_TO_HARD_REG_SET (live_hard_regs, df_get_live_in (bb));
@@ -720,7 +720,7 @@ regrename_analyze (bitmap bb_mask)
 	  bb1->aux = NULL;
 	  id_to_chain.truncate (old_length);
 	  current_id = old_length;
-	  bitmap_clear (&this_info->incoming_open_chains_set);
+	  this_info->incoming_open_chains_set.clear ();
 	  open_chains = NULL;
 	  if (insn_rr.exists ())
 	    {
diff --git a/gcc/regset.h b/gcc/regset.h
index d5a9fdd1830..525cf382ea1 100644
--- a/gcc/regset.h
+++ b/gcc/regset.h
@@ -49,7 +49,7 @@ typedef bitmap regset;
 #define INIT_REG_SET(HEAD) bitmap_initialize (HEAD, &reg_obstack)
 
 /* Clear a register set by freeing up the linked list.  */
-#define CLEAR_REG_SET(HEAD) bitmap_clear (HEAD)
+#define CLEAR_REG_SET(HEAD) (HEAD)->clear ()
 
 /* Copy a register set to another register set.  */
 #define COPY_REG_SET(TO, FROM) bitmap_copy (TO, FROM)
diff --git a/gcc/regstat.c b/gcc/regstat.c
index 20cd7d91f69..638eafd61be 100644
--- a/gcc/regstat.c
+++ b/gcc/regstat.c
@@ -116,7 +116,6 @@ size_t reg_info_p_size;
 
 static void
 regstat_bb_compute_ri (unsigned int bb_index,
-		       bitmap live, bitmap artificial_uses,
 		       bitmap local_live, bitmap local_processed,
 		       int *local_live_last_luid)
 {
@@ -128,12 +127,12 @@ regstat_bb_compute_ri (unsigned int bb_index,
   bitmap_iterator bi;
   unsigned int regno;
 
-  bitmap_copy (live, df_get_live_out (bb));
-  bitmap_clear (artificial_uses);
+  bitmap_head live (*df_get_live_out (bb));
+  bitmap_head artificial_uses (&df_bitmap_obstack);
 
   /* Process the regs live at the end of the block.  Mark them as
      not local to any one basic block.  */
-  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
+  EXECUTE_IF_SET_IN_BITMAP (&live, 0, regno, bi)
     REG_BASIC_BLOCK (regno) = REG_BLOCK_GLOBAL;
 
   /* Process the artificial defs and uses at the bottom of the block
@@ -142,7 +141,7 @@ regstat_bb_compute_ri (unsigned int bb_index,
     {
       df_ref def = *def_rec;
       if ((DF_REF_FLAGS (def) & DF_REF_AT_TOP) == 0)
-	live->clear_bit (DF_REF_REGNO (def));
+	live.clear_bit (DF_REF_REGNO (def));
     }
 
   for (use_rec = df_get_artificial_uses (bb_index); *use_rec; use_rec++)
@@ -151,8 +150,8 @@ regstat_bb_compute_ri (unsigned int bb_index,
       if ((DF_REF_FLAGS (use) & DF_REF_AT_TOP) == 0)
 	{
 	  regno = DF_REF_REGNO (use);
-	  live->set_bit (regno);
-	  artificial_uses->set_bit (regno);
+	  live.set_bit (regno);
+	  artificial_uses.set_bit (regno);
 	}
     }
 
@@ -181,7 +180,7 @@ regstat_bb_compute_ri (unsigned int bb_index,
 	{
 	  bool can_throw = can_throw_internal (insn);
 	  bool set_jump = (find_reg_note (insn, REG_SETJMP, NULL) != NULL);
-	  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
+	  EXECUTE_IF_SET_IN_BITMAP (&live, 0, regno, bi)
 	    {
 	      REG_N_CALLS_CROSSED (regno)++;
 	      REG_FREQ_CALLS_CROSSED (regno) += REG_FREQ_FROM_BB (bb);
@@ -218,8 +217,8 @@ regstat_bb_compute_ri (unsigned int bb_index,
 	      unsigned int r;
 
 	      for (r = mws->start_regno; r <= mws->end_regno; r++)
-		if (artificial_uses->bit (r)
-		    || live->bit (r))
+		if (artificial_uses.bit (r)
+		    || live.bit (r))
 		  {
 		    all_dead = false;
 		    break;
@@ -243,7 +242,7 @@ regstat_bb_compute_ri (unsigned int bb_index,
 	    {
 	      unsigned int dregno = DF_REF_REGNO (def);
 
-	      if (live->bit (dregno))
+	      if (live.bit (dregno))
 		{
 		  /* If we have seen a use of DREGNO somewhere before (i.e.
 		     later in this basic block), and DEF is not a subreg
@@ -279,10 +278,10 @@ regstat_bb_compute_ri (unsigned int bb_index,
 		     basic block.  This results in poor calculations of
 		     REG_LIVE_LENGTH in large basic blocks.  */
 		  if (!(DF_REF_FLAGS (def) & (DF_REF_PARTIAL | DF_REF_CONDITIONAL)))
-		    live->clear_bit (dregno);
+		    live.clear_bit (dregno);
 		}
 	      else if ((!(DF_REF_FLAGS (def) & DF_REF_MW_HARDREG))
-		       && (!artificial_uses->bit (dregno)))
+		       && (!artificial_uses.bit (dregno)))
 		{
 		  REG_LIVE_LENGTH (dregno)++;
 		}
@@ -318,7 +317,7 @@ regstat_bb_compute_ri (unsigned int bb_index,
 		REG_BASIC_BLOCK (uregno) = REG_BLOCK_GLOBAL;
 	    }
 
-	  if (live->set_bit (uregno))
+	  if (live.set_bit (uregno))
 	    {
 	      /* This register is now live.  Begin to process it locally.
 
@@ -342,12 +341,9 @@ regstat_bb_compute_ri (unsigned int bb_index,
 
   /* Add the length of the block to all of the registers that were not
      referenced, but still live in this block.  */
-  bitmap_and_compl_into (live, local_processed);
-  EXECUTE_IF_SET_IN_BITMAP (live, 0, regno, bi)
+  bitmap_and_compl_into (&live, local_processed);
+  EXECUTE_IF_SET_IN_BITMAP (&live, 0, regno, bi)
     REG_LIVE_LENGTH (regno) += luid;
-
-  bitmap_clear (local_processed);
-  bitmap_clear (local_live);
 }
 
 
@@ -357,9 +353,6 @@ regstat_compute_ri (void)
 {
   basic_block bb;
   bitmap_head live (&df_bitmap_obstack);
-  bitmap_head artificial_uses (&df_bitmap_obstack);
-  bitmap_head local_live (&df_bitmap_obstack);
-  bitmap_head local_processed (&df_bitmap_obstack);
   unsigned int regno;
   bitmap_iterator bi;
   int *local_live_last_luid;
@@ -377,8 +370,9 @@ regstat_compute_ri (void)
 
   FOR_EACH_BB_FN (bb, cfun)
     {
-      regstat_bb_compute_ri (bb->index, &live, &artificial_uses,
-			     &local_live, &local_processed,
+      bitmap_head local_live (&df_bitmap_obstack);
+      bitmap_head local_processed (&df_bitmap_obstack);
+      regstat_bb_compute_ri (bb->index, &local_live, &local_processed,
 			     local_live_last_luid);
     }
 
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index 1ebf763bb62..8d6407163fd 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -778,7 +778,7 @@ prune_unused_phi_nodes (bitmap phis, bitmap kills, bitmap uses)
 
   if (uses->is_empty ())
     {
-      bitmap_clear (phis);
+      phis->clear ();
       return;
     }
 
@@ -2209,26 +2209,11 @@ rewrite_blocks (basic_block entry, enum rewrite_mode what)
 class mark_def_dom_walker : public dom_walker
 {
 public:
-  mark_def_dom_walker (cdi_direction direction);
-  ~mark_def_dom_walker ();
+  mark_def_dom_walker (cdi_direction direction) : dom_walker (direction) {}
 
   virtual void before_dom_children (basic_block);
-
-private:
-  /* Notice that this bitmap is indexed using variable UIDs, so it must be
-     large enough to accommodate all the variables referenced in the
-     function, not just the ones we are renaming.  */
-  bitmap_head m_kills;
 };
 
-mark_def_dom_walker::mark_def_dom_walker (cdi_direction direction)
-  : dom_walker (direction)
-{
-}
-
-mark_def_dom_walker::~mark_def_dom_walker ()
-{
-}
 
 /* Block processing routine for mark_def_sites.  Clear the KILLS bitmap
    at the start of each block, and call mark_def_sites for each statement.  */
@@ -2238,9 +2223,12 @@ mark_def_dom_walker::before_dom_children (basic_block bb)
 {
   gimple_stmt_iterator gsi;
 
-  bitmap_clear (&m_kills);
+  /* Notice that this bitmap is indexed using variable UIDs, so it must be
+     large enough to accommodate all the variables referenced in the
+     function, not just the ones we are renaming.  */
+  bitmap_head kills;
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    mark_def_sites (bb, gsi_stmt (gsi), &m_kills);
+    mark_def_sites (bb, gsi_stmt (gsi), &kills);
 }
 
 /* Initialize internal data needed during renaming.  */
@@ -2292,8 +2280,6 @@ fini_ssa_renamer (void)
 static unsigned int
 rewrite_into_ssa (void)
 {
-  bitmap_head *dfs;
-  basic_block bb;
   unsigned i;
 
   /* Initialize operand data structures.  */
@@ -2309,9 +2295,7 @@ rewrite_into_ssa (void)
   bitmap_clear (interesting_blocks);
 
   /* Initialize dominance frontier.  */
-  dfs = XNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
-  FOR_EACH_BB_FN (bb, cfun)
-    bitmap_initialize (&dfs[bb->index], &bitmap_default_obstack);
+  bitmap_head *dfs = new bitmap_head [last_basic_block_for_fn (cfun)];
 
   /* 1- Compute dominance frontiers.  */
   calculate_dominance_info (CDI_DOMINATORS);
@@ -2327,9 +2311,7 @@ rewrite_into_ssa (void)
   rewrite_blocks (ENTRY_BLOCK_PTR_FOR_FN (cfun), REWRITE_ALL);
 
   /* Free allocated memory.  */
-  FOR_EACH_BB_FN (bb, cfun)
-    bitmap_clear (&dfs[bb->index]);
-  free (dfs);
+  delete[] dfs;
 
   sbitmap_free (interesting_blocks);
 
@@ -3253,11 +3235,9 @@ update_ssa (unsigned update_flags)
      and for symbols found.  */
   if (insert_phi_p)
     {
-      bitmap_head *dfs;
-
       /* If the caller requested PHI nodes to be added, compute
 	 dominance frontiers.  */
-      dfs = XNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
+      bitmap_head *dfs = new bitmap_head[last_basic_block_for_fn (cfun)];
       FOR_EACH_BB_FN (bb, cfun)
 	bitmap_initialize (&dfs[bb->index], &bitmap_default_obstack);
       compute_dominance_frontiers (dfs);
@@ -3284,9 +3264,7 @@ update_ssa (unsigned update_flags)
 	insert_updated_phi_nodes_for (sym, dfs, blocks_to_update,
 	                              update_flags);
 
-      FOR_EACH_BB_FN (bb, cfun)
-	bitmap_clear (&dfs[bb->index]);
-      free (dfs);
+      delete[] dfs;
 
       /* Insertion of PHI nodes may have added blocks to the region.
 	 We need to re-compute START_BB to include the newly added
diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c
index b142ac31bf7..086e8c7131f 100644
--- a/gcc/tree-ssa-coalesce.c
+++ b/gcc/tree-ssa-coalesce.c
@@ -692,7 +692,7 @@ live_track_add_partition (live_track_p ptr, int partition)
   /* If this base var wasn't live before, it is now.  Clear the element list
      since it was delayed until needed.  */
   if (ptr->live_base_var->set_bit (root))
-    bitmap_clear (ptr->live_base_partitions[root]);
+    ptr->live_base_partitions[root]->clear ();
   ptr->live_base_partitions[root]->set_bit (partition);
 
 }
@@ -798,7 +798,7 @@ live_track_clear_base_vars (live_track_p ptr)
   /* Simply clear the live base list.  Anything marked as live in the element
      lists will be cleared later if/when the base variable ever comes alive
      again.  */
-  bitmap_clear (ptr->live_base_var);
+  ptr->live_base_var->clear ();
 }
 
 
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index aedd13fa043..512ac6b486e 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -916,7 +916,7 @@ propagate_necessity (bool aggressive)
 	      && total_chain > nr_walks * 32)
 	    {
 	      chain_ovfl = true;
-	      bitmap_clear (&visited);
+	      visited.clear ();
 	    }
 	}
     }
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index 04b55c5c835..81cf3d7da37 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -915,7 +915,7 @@ tree_ssa_dominator_optimize (void)
 	}
 
       gimple_purge_all_dead_eh_edges (need_eh_cleanup);
-      bitmap_clear (need_eh_cleanup);
+      need_eh_cleanup->clear ();
     }
 
   statistics_counter_event (cfun, "Redundant expressions eliminated",
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 719736846b5..23cd79c4f95 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -1149,7 +1149,7 @@ calculate_live_on_exit (tree_live_info_p liveinfo)
 
   /* live on entry calculations used liveout vectors for defs, clear them.  */
   FOR_EACH_BB_FN (bb, cfun)
-    bitmap_clear (&liveinfo->liveout[bb->index]);
+    liveinfo->liveout[bb->index].clear ();
 
   /* Set all the live-on-exit bits for uses in PHIs.  */
   FOR_EACH_BB_FN (bb, cfun)
diff --git a/gcc/tree-ssa-live.h b/gcc/tree-ssa-live.h
index 1a433160c38..ad4c79a245f 100644
--- a/gcc/tree-ssa-live.h
+++ b/gcc/tree-ssa-live.h
@@ -311,7 +311,7 @@ live_merge_and_clear (tree_live_info_p live, int p1, int p2)
 {
   gcc_checking_assert (&live->livein[p1] && &live->livein[p2]);
   bitmap_ior_into (&live->livein[p1], &live->livein[p2]);
-  bitmap_clear (&live->livein[p2]);
+  live->livein[p2].clear ();
 }
 
 
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index bee4a930313..4ff904efc0e 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -4208,7 +4208,7 @@ get_computation_cost_at (struct ivopts_data *data,
           get_loop_invariant_expr_id (data, ubase, cbase, ratio, address_p);
       /* Clear depends on.  */
       if (*inv_expr_id != -1 && depends_on && *depends_on)
-        bitmap_clear (*depends_on);
+        (*depends_on)->clear ();
     }
 
   /* If we are after the increment, the value of the candidate is higher by
@@ -4829,7 +4829,7 @@ determine_use_iv_cost_condition (struct ivopts_data *data,
       if (depends_on_elim && depends_on_elim->count_bits () > 1)
 	{
 	  elim_inv_expr_id = get_expr_id (data, bound);
-	  bitmap_clear (depends_on_elim);
+	  depends_on_elim->clear ();
 	}
       /* The bound is a loop invariant, so it will be only computed
 	 once.  */
@@ -5045,7 +5045,7 @@ determine_use_iv_costs (struct ivopts_data *data)
 	  /* Remove the candidates for that the cost is infinite from
 	     the list of related candidates.  */
 	  bitmap_and_compl_into (use->related_cands, &to_clear);
-	  bitmap_clear (&to_clear);
+	  to_clear.clear ();
 	}
     }
 
@@ -6708,8 +6708,8 @@ free_loop_data (struct ivopts_data *data)
       info->preserve_biv = false;
       info->inv_id = 0;
     }
-  bitmap_clear (data->relevant);
-  bitmap_clear (data->important_candidates);
+  data->relevant->clear ();
+  data->important_candidates->clear ();
 
   for (i = 0; i < n_iv_uses (data); i++)
     {
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index e30f960732c..75a740274c2 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -703,8 +703,8 @@ bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
 static void
 bitmap_set_free (bitmap_set_t set)
 {
-  bitmap_clear (&set->expressions);
-  bitmap_clear (&set->values);
+  set->expressions.clear ();
+  set->values.clear ();
 }
 
 
diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c
index 8244a4f2b79..a334dcc7e28 100644
--- a/gcc/tree-ssa-sink.c
+++ b/gcc/tree-ssa-sink.c
@@ -140,7 +140,6 @@ all_immediate_uses_same_place (gimple stmt)
 static basic_block
 nearest_common_dominator_of_uses (gimple stmt, bool *debug_stmts)
 {
-  bitmap_head blocks;
   basic_block commondom;
   unsigned int j;
   bitmap_iterator bi;
@@ -149,7 +148,7 @@ nearest_common_dominator_of_uses (gimple stmt, bool *debug_stmts)
   use_operand_p use_p;
   tree var;
 
-  bitmap_clear (&blocks);
+  bitmap_head blocks;
   FOR_EACH_SSA_TREE_OPERAND (var, stmt, op_iter, SSA_OP_ALL_DEFS)
     {
       FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var)
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index d6817e4ac1c..98f9ef43bcd 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -6113,7 +6113,7 @@ find_what_var_points_to (varinfo_t orig_vi)
   else
     {
       pt->vars = result;
-      bitmap_clear (finished_solution);
+      finished_solution->clear ();
     }
 
   return *pt;
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index b483b1d75f9..96d030acb0d 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -612,9 +612,9 @@ same_succ_def::remove (same_succ e)
 static void
 same_succ_reset (same_succ same)
 {
-  bitmap_clear (&same->bbs);
-  bitmap_clear (&same->succs);
-  bitmap_clear (&same->inverse);
+  same->bbs.clear ();
+  same->succs.clear ();
+  same->inverse.clear ();
   same->succ_flags.truncate (0);
 }
 
@@ -858,7 +858,7 @@ update_worklist (void)
   same_succ same;
 
   bitmap_and_compl_into (deleted_bb_preds, deleted_bbs);
-  bitmap_clear (deleted_bbs);
+  deleted_bbs->clear ();
 
   deleted_bb_preds->clear_bit (ENTRY_BLOCK);
   same_succ_flush_bbs (deleted_bb_preds);
@@ -873,7 +873,7 @@ update_worklist (void)
 	same = new same_succ_def;
     }
   same_succ_def::remove (same);
-  bitmap_clear (deleted_bb_preds);
+  deleted_bb_preds->clear ();
 }
 
 /* Prints cluster C to FILE.  */
diff --git a/gcc/tree-ssa-ter.c b/gcc/tree-ssa-ter.c
index a6b7bf6cbd3..afd00a0e268 100644
--- a/gcc/tree-ssa-ter.c
+++ b/gcc/tree-ssa-ter.c
@@ -354,7 +354,7 @@ add_dependence (temp_expr_table_p tab, int version, tree var)
 	  bitmap_ior_into (&tab->partition_in_use,
 			   &tab->new_replaceable_dependencies);
 	  /* It is only necessary to add these once.  */
-	  bitmap_clear (&tab->new_replaceable_dependencies);
+	  tab->new_replaceable_dependencies.clear ();
 	}
     }
   else
@@ -702,7 +702,7 @@ find_replaceable_in_bb (temp_expr_table_p tab, basic_block bb)
 	process_replaceable (tab, stmt, cur_call_cnt);
 
       /* Free any unused dependency lists.  */
-      bitmap_clear (&tab->new_replaceable_dependencies);
+      tab->new_replaceable_dependencies.clear ();
 
       /* A V_{MAY,MUST}_DEF kills any expression using a virtual operand,
 	 including the current stmt.  */
diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c
index ed574b85fc9..68b83baecb6 100644
--- a/gcc/tree-ssa-threadedge.c
+++ b/gcc/tree-ssa-threadedge.c
@@ -1142,7 +1142,7 @@ thread_across_edge (gimple dummy_cond,
 	bitmap_copy (&dst_map, &dst_map_copy);
      
 	/* Avoid threading to any block we have already visited.  */
-	bitmap_clear (&visited);
+	visited.clear ();
 	visited.set_bit (e->src->index);
 	visited.set_bit (e->dest->index);
 	visited.set_bit (taken_edge->dest->index);
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index 4ba66bdff93..8100d08d81b 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -967,7 +967,6 @@ verify_ssa (bool check_modified_stmt)
   ssa_op_iter iter;
   tree op;
   enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
-  bitmap_head names_defined_in_bb;
 
   gcc_assert (!need_ssa_update_p (cfun));
 
@@ -1018,6 +1017,7 @@ verify_ssa (bool check_modified_stmt)
 	}
 
       /* Verify the arguments for every PHI node in the block.  */
+      bitmap_head names_defined_in_bb;
       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 	{
 	  phi = gsi_stmt (gsi);
@@ -1075,8 +1075,6 @@ verify_ssa (bool check_modified_stmt)
 	      names_defined_in_bb.set_bit (SSA_NAME_VERSION (op));
 	    }
 	}
-
-      bitmap_clear (&names_defined_in_bb);
     }
 
   free (definition_block);
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 95bed85146a..5f510f7be96 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -411,7 +411,7 @@ set_value_range_to_undefined (value_range_t *vr)
   vr->type = VR_UNDEFINED;
   vr->min = vr->max = NULL_TREE;
   if (vr->equiv)
-    bitmap_clear (vr->equiv);
+    vr->equiv->clear ();
 }
 
 
@@ -423,7 +423,7 @@ set_value_range_to_varying (value_range_t *vr)
   vr->type = VR_VARYING;
   vr->min = vr->max = NULL_TREE;
   if (vr->equiv)
-    bitmap_clear (vr->equiv);
+    vr->equiv->clear ();
 }
 
 
@@ -477,7 +477,7 @@ set_value_range (value_range_t *vr, enum value_range_type t, tree min,
       if (equiv && !equiv->is_empty ())
 	bitmap_copy (vr->equiv, equiv);
       else
-	bitmap_clear (vr->equiv);
+	vr->equiv->clear ();
     }
 }
 
@@ -8294,7 +8294,7 @@ vrp_meet_1 (value_range_t *vr0, value_range_t *vr1)
 	  /* Since this meet operation did not result from the meeting of
 	     two equivalent names, VR0 cannot have any equivalences.  */
 	  if (vr0->equiv)
-	    bitmap_clear (vr0->equiv);
+	    vr0->equiv->clear ();
 	  return;
 	}
 
@@ -8311,7 +8311,7 @@ vrp_meet_1 (value_range_t *vr0, value_range_t *vr1)
   if (vr0->equiv && vr1->equiv && vr0->equiv != vr1->equiv)
     bitmap_and_into (vr0->equiv, vr1->equiv);
   else if (vr0->equiv && !vr1->equiv)
-    bitmap_clear (vr0->equiv);
+    vr0->equiv->clear ();
 }
 
 static void