bitmap.h (BITMAP_XMALLOC, [...]): Remove.

	* bitmap.h (BITMAP_XMALLOC, BITMAP_XFREE): Remove.
	* bb-reorder.c (duplicate_computed_gotos): Use BITMAP_ALLOC and
	BITMAP_FREE.
	* bt-load.c (btr_def_live_range, combine_btr_defs,
	migrate_btr_def, migrate_btr_defs): Likewise.
	* cfgcleanup.c (thread_jump): Likewise.
	* cfgloop.c (get_loop_body_in_bfs_order): Likewise.
	* df.c (df_insn_table_realloc, df_bitmaps_alloc, df_bitmaps_free,
	df_alloc, df_free, df_du_chain_create, df_bb_rd_local_compute,
	df_rd_local_compute, df_reg_info_compute): Likewise.
	* dominance.c (init_dom_info, free_dom_info): Likewise.
	* flow.c (init_propagate_block_info,
	free_propagate_block_info): Likewise.
	* gcse.c (alloc_gcse_mem, free_gcse_mem): Likewise.
	* global.c (allocate_bb_info, free_bb_info, calculate_reg_pav,
	modify_reg_pav): Likewise.
	* loop-invariant.c (find_defs, find_invariant_insn,
	find_invariants, free_inv_motion_data): Likewise.
	* predict.c (tree_predict_by_opcode,
	estimate_bb_frequencies): Likewise.
	* stmt.c (expand_case): Likewise.
	* tree-cfg.c (tree_duplicate_sese_region): Likewise.
	* tree-dfa.c (mark_new_vars_to_rename): Likewise.
	* tree-if-conv.c (get_loop_body_in_if_conv_order): Likewise.
	* tree-into-ssa.c (insert_phi_nodes_for, def_blocks_free,
	get_def_blocks_for, mark_def_site_blocks, rewrite_into_ssa,
	rewrite_ssa_into_ssa): Likewise.
	* tree-optimize.c (tree_rest_of_compilation): Likewise.
	* tree-outof-ssa.c (new_temp_expr_table, free_temp_expr_table,
	analyze_edges_for_bb, perform_edge_inserts): Likewise.
	* tree-scalar-evolution.c (scev_initialize, scev_finalize): Likewise.
	* tree-sra.c (tree_sra): Likewise.
	* tree-ssa-alias.c (init_alias_info, delete_alias_info): Likewise.
	* tree-ssa-ccp.c (ccp_fold_builtin): Likewise.
	* tree-ssa-dce.c (tree_dce_init, tree_dce_done): Likewise.
	* tree-ssa-dom.c (tree_ssa_dominator_optimize): Likewise.
	* tree-ssa-dse.c (tree_ssa_dse): Likewise.
	* tree-ssa-forwprop.c (tree_ssa_forward_propagate_single_use_var):
	Likewise.
	* tree-ssa-live.c (new_tree_live_info, delete_tree_live_info,
	calculate_live_on_entry, calculate_live_on_exit,
	build_tree_conflict_graph): Likewise.
	* tree-ssa-loop-ivopts.c (tree_ssa_iv_optimize_init, record_use,
	record_important_candidates, set_use_iv_cost, find_depends,
	determine_use_iv_costs, iv_ca_new, iv_ca_free, free_loop_data,
	tree_ssa_iv_optimize_finalize): Likewise.
	* tree-ssa-loop-manip.c (add_exit_phis_var, get_loops_exit,
	find_uses_to_rename_use, rewrite_into_loop_closed_ssa,
	tree_duplicate_loop_to_header_edge): Likewise.
	* tree-ssa-pre.c (init_pre, fini_pre): Likewise.
	* tree-ssa.c (verify_flow_insensitive_alias_info,
	verify_name_tags, verify_ssa, init_tree_ssa,
	delete_tree_ssa): Likewise.
	* tree-ssanames.c (marked_ssa_names, init_ssanames,
	fini_ssanames): Likewise.
	* tree-vectorizer.c (slpeel_tree_peel_loop_to_edge): Likewise.

From-SVN: r95172

35 files changed, 264 insertions, 211 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d33deae..a5511cc 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,62 @@
+2005-02-17  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* bitmap.h (BITMAP_XMALLOC, BITMAP_XFREE): Remove.
+	* bb-reorder.c (duplicate_computed_gotos): Use BITMAP_ALLOC and
+	BITMAP_FREE.
+	* bt-load.c (btr_def_live_range, combine_btr_defs,
+	migrate_btr_def, migrate_btr_defs): Likewise.
+	* cfgcleanup.c (thread_jump): Likewise.
+	* cfgloop.c (get_loop_body_in_bfs_order): Likewise.
+	* df.c (df_insn_table_realloc, df_bitmaps_alloc, df_bitmaps_free,
+	df_alloc, df_free, df_du_chain_create, df_bb_rd_local_compute,
+	df_rd_local_compute, df_reg_info_compute): Likewise.
+	* dominance.c (init_dom_info, free_dom_info): Likewise.
+	* flow.c (init_propagate_block_info,
+	free_propagate_block_info): Likewise.
+	* gcse.c (alloc_gcse_mem, free_gcse_mem): Likewise.
+	* global.c (allocate_bb_info, free_bb_info, calculate_reg_pav,
+	modify_reg_pav): Likewise.
+	* loop-invariant.c (find_defs, find_invariant_insn,
+	find_invariants, free_inv_motion_data): Likewise.
+	* predict.c (tree_predict_by_opcode,
+	estimate_bb_frequencies): Likewise.
+	* stmt.c (expand_case): Likewise.
+	* tree-cfg.c (tree_duplicate_sese_region): Likewise.
+	* tree-dfa.c (mark_new_vars_to_rename): Likewise.
+	* tree-if-conv.c (get_loop_body_in_if_conv_order): Likewise.
+	* tree-into-ssa.c (insert_phi_nodes_for, def_blocks_free,
+	get_def_blocks_for, mark_def_site_blocks, rewrite_into_ssa,
+	rewrite_ssa_into_ssa): Likewise.
+	* tree-optimize.c (tree_rest_of_compilation): Likewise.
+	* tree-outof-ssa.c (new_temp_expr_table, free_temp_expr_table,
+	analyze_edges_for_bb, perform_edge_inserts): Likewise.
+	* tree-scalar-evolution.c (scev_initialize, scev_finalize): Likewise.
+	* tree-sra.c (tree_sra): Likewise.
+	* tree-ssa-alias.c (init_alias_info, delete_alias_info): Likewise.
+	* tree-ssa-ccp.c (ccp_fold_builtin): Likewise.
+	* tree-ssa-dce.c (tree_dce_init, tree_dce_done): Likewise.
+	* tree-ssa-dom.c (tree_ssa_dominator_optimize): Likewise.
+	* tree-ssa-dse.c (tree_ssa_dse): Likewise.
+	* tree-ssa-forwprop.c (tree_ssa_forward_propagate_single_use_var):
+	Likewise.
+	* tree-ssa-live.c (new_tree_live_info, delete_tree_live_info,
+	calculate_live_on_entry, calculate_live_on_exit,
+	build_tree_conflict_graph): Likewise.
+	* tree-ssa-loop-ivopts.c (tree_ssa_iv_optimize_init, record_use,
+	record_important_candidates, set_use_iv_cost, find_depends,
+	determine_use_iv_costs, iv_ca_new, iv_ca_free, free_loop_data,
+	tree_ssa_iv_optimize_finalize): Likewise.
+	* tree-ssa-loop-manip.c (add_exit_phis_var, get_loops_exit,
+	find_uses_to_rename_use, rewrite_into_loop_closed_ssa,
+	tree_duplicate_loop_to_header_edge): Likewise.
+	* tree-ssa-pre.c (init_pre, fini_pre): Likewise.
+	* tree-ssa.c (verify_flow_insensitive_alias_info,
+	verify_name_tags, verify_ssa, init_tree_ssa,
+	delete_tree_ssa): Likewise.
+	* tree-ssanames.c (marked_ssa_names, init_ssanames,
+	fini_ssanames): Likewise.
+	* tree-vectorizer.c (slpeel_tree_peel_loop_to_edge): Likewise.
+
 2005-02-17  Ralf Corsepius  <ralf.corsepius@rtems.org>
 
 	* config/rs6000/t-rtems: Completely reworked. 
diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
index d054ffd..23cdf09 100644
--- a/gcc/bb-reorder.c
+++ b/gcc/bb-reorder.c
@@ -2031,7 +2031,7 @@ duplicate_computed_gotos (void)
     uncond_jump_length = get_uncond_jump_length ();
 
   max_size = uncond_jump_length * PARAM_VALUE (PARAM_MAX_GOTO_DUPLICATION_INSNS);
-  candidates = BITMAP_XMALLOC ();
+  candidates = BITMAP_ALLOC (NULL);
 
   /* Build the reorder chain for the original order of blocks.
      Look for a computed jump while we are at it.  */
@@ -2094,7 +2094,7 @@ duplicate_computed_gotos (void)
 done:
   cfg_layout_finalize ();
 
-  BITMAP_XFREE (candidates);
+  BITMAP_FREE (candidates);
 
   timevar_pop (TV_REORDER_BLOCKS);
 }
diff --git a/gcc/bitmap.h b/gcc/bitmap.h
index 24e987f..2915623 100644
--- a/gcc/bitmap.h
+++ b/gcc/bitmap.h
@@ -159,16 +159,10 @@ extern unsigned bitmap_first_set_bit (bitmap);
 /* Allocate a gc'd bitmap.  */
 #define BITMAP_GGC_ALLOC() bitmap_gc_alloc ()
 
-/* Allocate a bitmap with xmalloc.  */
-#define BITMAP_XMALLOC() BITMAP_ALLOC (NULL)
-
 /* Do any cleanup needed on a bitmap when it is no longer used.  */
 #define BITMAP_FREE(BITMAP)			\
       	((void)(bitmap_obstack_free (BITMAP), (BITMAP) = NULL))
 
-/* Do any cleanup needed on an xmalloced bitmap when it is no longer used.  */
-#define BITMAP_XFREE(BITMAP) BITMAP_FREE (BITMAP)
-
 /* Iterator for bitmaps.  */
 
 typedef struct
diff --git a/gcc/bt-load.c b/gcc/bt-load.c
index c3bc3fa..3a02177 100644
--- a/gcc/bt-load.c
+++ b/gcc/bt-load.c
@@ -996,7 +996,7 @@ btr_def_live_range (btr_def def, HARD_REG_SET *btrs_live_in_range)
     {
       btr_user user;
 
-      def->live_range = BITMAP_XMALLOC ();
+      def->live_range = BITMAP_ALLOC (NULL);
 
       bitmap_set_bit (def->live_range, def->bb->index);
       COPY_HARD_REG_SET (*btrs_live_in_range,
@@ -1056,7 +1056,7 @@ combine_btr_defs (btr_def def, HARD_REG_SET *btrs_live_in_range)
 	     target registers live over the merged range.  */
 	  int btr;
 	  HARD_REG_SET combined_btrs_live;
-	  bitmap combined_live_range = BITMAP_XMALLOC ();
+	  bitmap combined_live_range = BITMAP_ALLOC (NULL);
 	  btr_user user;
 
 	  if (other_def->live_range == NULL)
@@ -1114,7 +1114,7 @@ combine_btr_defs (btr_def def, HARD_REG_SET *btrs_live_in_range)
 	      delete_insn (other_def->insn);
 
 	    }
-	  BITMAP_XFREE (combined_live_range);
+	  BITMAP_FREE (combined_live_range);
 	}
     }
 }
@@ -1287,7 +1287,7 @@ migrate_btr_def (btr_def def, int min_cost)
     }
 
   btr_def_live_range (def, &btrs_live_in_range);
-  live_range = BITMAP_XMALLOC ();
+  live_range = BITMAP_ALLOC (NULL);
   bitmap_copy (live_range, def->live_range);
 
 #ifdef INSN_SCHEDULING
@@ -1361,7 +1361,7 @@ migrate_btr_def (btr_def def, int min_cost)
       if (dump_file)
 	fprintf (dump_file, "failed to move\n");
     }
-  BITMAP_XFREE (live_range);
+  BITMAP_FREE (live_range);
   return !give_up;
 }
 
@@ -1420,7 +1420,7 @@ migrate_btr_defs (enum reg_class btr_class, int allow_callee_save)
 	    }
 	}
       else
-	BITMAP_XFREE (def->live_range);
+	BITMAP_FREE (def->live_range);
     }
 
   free (btrs_live);
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index bbe6807..4cf2577 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -353,7 +353,7 @@ thread_jump (int mode, edge e, basic_block b)
     if (INSN_P (insn))
       cselib_process_insn (insn);
 
-  nonequal = BITMAP_XMALLOC();
+  nonequal = BITMAP_ALLOC (NULL);
   CLEAR_REG_SET (nonequal);
 
   /* Now assume that we've continued by the edge E to B and continue
@@ -401,7 +401,7 @@ thread_jump (int mode, edge e, basic_block b)
   EXECUTE_IF_SET_IN_REG_SET (nonequal, 0, i, rsi)
     goto failed_exit;
 
-  BITMAP_XFREE (nonequal);
+  BITMAP_FREE (nonequal);
   cselib_finish ();
   if ((comparison_dominates_p (code1, code2) != 0)
       != (XEXP (SET_SRC (set2), 1) == pc_rtx))
@@ -410,7 +410,7 @@ thread_jump (int mode, edge e, basic_block b)
     return FALLTHRU_EDGE (b);
 
 failed_exit:
-  BITMAP_XFREE (nonequal);
+  BITMAP_FREE (nonequal);
   cselib_finish ();
   return NULL;
 }
diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c
index 26a9cde..dededd4 100644
--- a/gcc/cfgloop.c
+++ b/gcc/cfgloop.c
@@ -1103,7 +1103,7 @@ get_loop_body_in_bfs_order (const struct loop *loop)
   gcc_assert (loop->latch != EXIT_BLOCK_PTR);
 
   blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
-  visited = BITMAP_XMALLOC ();
+  visited = BITMAP_ALLOC (NULL);
 
   bb = loop->header;
   while (i < loop->num_nodes)
@@ -1135,7 +1135,7 @@ get_loop_body_in_bfs_order (const struct loop *loop)
       bb = blocks[vc++];
     }
   
-  BITMAP_XFREE (visited);
+  BITMAP_FREE (visited);
   return blocks;
 }
 
diff --git a/gcc/df.c b/gcc/df.c
index 1fe44f2..ad7852c 100644
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -320,7 +320,7 @@ df_insn_table_realloc (struct df *df, unsigned int size)
 
   if (! df->insns_modified)
     {
-      df->insns_modified = BITMAP_XMALLOC ();
+      df->insns_modified = BITMAP_ALLOC (NULL);
       bitmap_zero (df->insns_modified);
     }
 }
@@ -392,10 +392,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
 	  if (!bb_info->rd_in)
 	    {
 	      /* Allocate bitmaps for reaching definitions.  */
-	      bb_info->rd_kill = BITMAP_XMALLOC ();
-	      bb_info->rd_gen = BITMAP_XMALLOC ();
-	      bb_info->rd_in = BITMAP_XMALLOC ();
-	      bb_info->rd_out = BITMAP_XMALLOC ();
+	      bb_info->rd_kill = BITMAP_ALLOC (NULL);
+	      bb_info->rd_gen = BITMAP_ALLOC (NULL);
+	      bb_info->rd_in = BITMAP_ALLOC (NULL);
+	      bb_info->rd_out = BITMAP_ALLOC (NULL);
 	    }
 	  else
 	    {
@@ -411,10 +411,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
 	  if (!bb_info->ru_in)
 	    {
 	      /* Allocate bitmaps for upward exposed uses.  */
-	      bb_info->ru_kill = BITMAP_XMALLOC ();
-	      bb_info->ru_gen = BITMAP_XMALLOC ();
-	      bb_info->ru_in = BITMAP_XMALLOC ();
-	      bb_info->ru_out = BITMAP_XMALLOC ();
+	      bb_info->ru_kill = BITMAP_ALLOC (NULL);
+	      bb_info->ru_gen = BITMAP_ALLOC (NULL);
+	      bb_info->ru_in = BITMAP_ALLOC (NULL);
+	      bb_info->ru_out = BITMAP_ALLOC (NULL);
 	    }
 	  else
 	    {
@@ -430,10 +430,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
 	  if (!bb_info->lr_in)
 	    {
 	      /* Allocate bitmaps for live variables.  */
-	      bb_info->lr_def = BITMAP_XMALLOC ();
-	      bb_info->lr_use = BITMAP_XMALLOC ();
-	      bb_info->lr_in = BITMAP_XMALLOC ();
-	      bb_info->lr_out = BITMAP_XMALLOC ();
+	      bb_info->lr_def = BITMAP_ALLOC (NULL);
+	      bb_info->lr_use = BITMAP_ALLOC (NULL);
+	      bb_info->lr_in = BITMAP_ALLOC (NULL);
+	      bb_info->lr_out = BITMAP_ALLOC (NULL);
 	    }
 	  else
 	    {
@@ -463,39 +463,39 @@ df_bitmaps_free (struct df *df, int flags)
       if ((flags & DF_RD) && bb_info->rd_in)
 	{
 	  /* Free bitmaps for reaching definitions.  */
-	  BITMAP_XFREE (bb_info->rd_kill);
+	  BITMAP_FREE (bb_info->rd_kill);
 	  bb_info->rd_kill = NULL;
-	  BITMAP_XFREE (bb_info->rd_gen);
+	  BITMAP_FREE (bb_info->rd_gen);
 	  bb_info->rd_gen = NULL;
-	  BITMAP_XFREE (bb_info->rd_in);
+	  BITMAP_FREE (bb_info->rd_in);
 	  bb_info->rd_in = NULL;
-	  BITMAP_XFREE (bb_info->rd_out);
+	  BITMAP_FREE (bb_info->rd_out);
 	  bb_info->rd_out = NULL;
 	}
 
       if ((flags & DF_RU) && bb_info->ru_in)
 	{
 	  /* Free bitmaps for upward exposed uses.  */
-	  BITMAP_XFREE (bb_info->ru_kill);
+	  BITMAP_FREE (bb_info->ru_kill);
 	  bb_info->ru_kill = NULL;
-	  BITMAP_XFREE (bb_info->ru_gen);
+	  BITMAP_FREE (bb_info->ru_gen);
 	  bb_info->ru_gen = NULL;
-	  BITMAP_XFREE (bb_info->ru_in);
+	  BITMAP_FREE (bb_info->ru_in);
 	  bb_info->ru_in = NULL;
-	  BITMAP_XFREE (bb_info->ru_out);
+	  BITMAP_FREE (bb_info->ru_out);
 	  bb_info->ru_out = NULL;
 	}
 
       if ((flags & DF_LR) && bb_info->lr_in)
 	{
 	  /* Free bitmaps for live variables.  */
-	  BITMAP_XFREE (bb_info->lr_def);
+	  BITMAP_FREE (bb_info->lr_def);
 	  bb_info->lr_def = NULL;
-	  BITMAP_XFREE (bb_info->lr_use);
+	  BITMAP_FREE (bb_info->lr_use);
 	  bb_info->lr_use = NULL;
-	  BITMAP_XFREE (bb_info->lr_in);
+	  BITMAP_FREE (bb_info->lr_in);
 	  bb_info->lr_in = NULL;
-	  BITMAP_XFREE (bb_info->lr_out);
+	  BITMAP_FREE (bb_info->lr_out);
 	  bb_info->lr_out = NULL;
 	}
     }
@@ -538,14 +538,14 @@ df_alloc (struct df *df, int n_regs)
 
   df_reg_table_realloc (df, df->n_regs);
 
-  df->bbs_modified = BITMAP_XMALLOC ();
+  df->bbs_modified = BITMAP_ALLOC (NULL);
   bitmap_zero (df->bbs_modified);
 
   df->flags = 0;
 
   df->bbs = xcalloc (last_basic_block, sizeof (struct bb_info));
 
-  df->all_blocks = BITMAP_XMALLOC ();
+  df->all_blocks = BITMAP_ALLOC (NULL);
   FOR_EACH_BB (bb)
     bitmap_set_bit (df->all_blocks, bb->index);
 }
@@ -583,13 +583,13 @@ df_free (struct df *df)
   df->regs = 0;
   df->reg_size = 0;
 
-  BITMAP_XFREE (df->bbs_modified);
+  BITMAP_FREE (df->bbs_modified);
   df->bbs_modified = 0;
 
-  BITMAP_XFREE (df->insns_modified);
+  BITMAP_FREE (df->insns_modified);
   df->insns_modified = 0;
 
-  BITMAP_XFREE (df->all_blocks);
+  BITMAP_FREE (df->all_blocks);
   df->all_blocks = 0;
 
   free_alloc_pool (df_ref_pool);
@@ -1484,14 +1484,14 @@ df_du_chain_create (struct df *df, bitmap blocks)
   bitmap ru;
   basic_block bb;
 
-  ru = BITMAP_XMALLOC ();
+  ru = BITMAP_ALLOC (NULL);
 
   FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
     {
       df_bb_du_chain_create (df, bb, ru);
     });
 
-  BITMAP_XFREE (ru);
+  BITMAP_FREE (ru);
 }
 
 
@@ -1615,7 +1615,7 @@ df_bb_rd_local_compute (struct df *df, basic_block bb, bitmap call_killed_defs)
 {
   struct bb_info *bb_info = DF_BB_INFO (df, bb);
   rtx insn;
-  bitmap seen = BITMAP_XMALLOC ();
+  bitmap seen = BITMAP_ALLOC (NULL);
   bool call_seen = false;
 
   FOR_BB_INSNS_REVERSE (bb, insn)
@@ -1661,7 +1661,7 @@ df_bb_rd_local_compute (struct df *df, basic_block bb, bitmap call_killed_defs)
 	}
     }
 
-  BITMAP_XFREE (seen);
+  BITMAP_FREE (seen);
 }
 
 
@@ -1676,7 +1676,7 @@ df_rd_local_compute (struct df *df, bitmap blocks)
 
   if (df->flags & DF_HARD_REGS)
     {
-      killed_by_call = BITMAP_XMALLOC ();
+      killed_by_call = BITMAP_ALLOC (NULL);
       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 	{
 	  if (!TEST_HARD_REG_BIT (regs_invalidated_by_call, regno))
@@ -1695,7 +1695,7 @@ df_rd_local_compute (struct df *df, bitmap blocks)
   });
 
   if (df->flags & DF_HARD_REGS)
-    BITMAP_XFREE (killed_by_call);
+    BITMAP_FREE (killed_by_call);
 }
 
 
@@ -1872,14 +1872,14 @@ df_reg_info_compute (struct df *df, bitmap blocks)
   basic_block bb;
   bitmap live;
 
-  live = BITMAP_XMALLOC ();
+  live = BITMAP_ALLOC (NULL);
 
   FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
   {
     df_bb_reg_info_compute (df, bb, live);
   });
 
-  BITMAP_XFREE (live);
+  BITMAP_FREE (live);
 }
 
 
diff --git a/gcc/dominance.c b/gcc/dominance.c
index 7970e24..98067c4 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -170,7 +170,7 @@ init_dom_info (struct dom_info *di, enum cdi_direction dir)
   di->dfsnum = 1;
   di->nodes = 0;
 
-  di->fake_exit_edge = dir ? BITMAP_XMALLOC () : NULL;
+  di->fake_exit_edge = dir ? BITMAP_ALLOC (NULL) : NULL;
 }
 
 #undef init_ar
@@ -191,7 +191,7 @@ free_dom_info (struct dom_info *di)
   free (di->set_child);
   free (di->dfs_order);
   free (di->dfs_to_bb);
-  BITMAP_XFREE (di->fake_exit_edge);
+  BITMAP_FREE (di->fake_exit_edge);
 }
 
 /* The nonrecursive variant of creating a DFS tree.  DI is our working
diff --git a/gcc/flow.c b/gcc/flow.c
index f356a6e..503dc0d 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -1826,12 +1826,12 @@ init_propagate_block_info (basic_block bb, regset live, regset local_set,
   else
     pbi->reg_next_use = NULL;
 
-  pbi->new_set = BITMAP_XMALLOC ();
+  pbi->new_set = BITMAP_ALLOC (NULL);
 
 #ifdef HAVE_conditional_execution
   pbi->reg_cond_dead = splay_tree_new (splay_tree_compare_ints, NULL,
 				       free_reg_cond_life_info);
-  pbi->reg_cond_reg = BITMAP_XMALLOC ();
+  pbi->reg_cond_reg = BITMAP_ALLOC (NULL);
 
   /* If this block ends in a conditional branch, for each register
      live from one side of the branch and not the other, record the
@@ -1973,11 +1973,11 @@ free_propagate_block_info (struct propagate_block_info *pbi)
 {
   free_EXPR_LIST_list (&pbi->mem_set_list);
 
-  BITMAP_XFREE (pbi->new_set);
+  BITMAP_FREE (pbi->new_set);
 
 #ifdef HAVE_conditional_execution
   splay_tree_delete (pbi->reg_cond_dead);
-  BITMAP_XFREE (pbi->reg_cond_reg);
+  BITMAP_FREE (pbi->reg_cond_reg);
 #endif
 
   if (pbi->flags & PROP_REG_INFO)
diff --git a/gcc/gcse.c b/gcc/gcse.c
index cb26c0b..757f946 100644
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -962,7 +962,7 @@ alloc_gcse_mem (rtx f)
       CUID_INSN (i++) = insn;
 
   /* Allocate vars to track sets of regs.  */
-  reg_set_bitmap = BITMAP_XMALLOC ();
+  reg_set_bitmap = BITMAP_ALLOC (NULL);
 
   /* Allocate vars to track sets of regs, memory per block.  */
   reg_set_in_block = sbitmap_vector_alloc (last_basic_block, max_gcse_regno);
@@ -970,8 +970,8 @@ alloc_gcse_mem (rtx f)
      basic block.  */
   modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
   canon_modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
-  modify_mem_list_set = BITMAP_XMALLOC ();
-  blocks_with_calls = BITMAP_XMALLOC ();
+  modify_mem_list_set = BITMAP_ALLOC (NULL);
+  blocks_with_calls = BITMAP_ALLOC (NULL);
 }
 
 /* Free memory allocated by alloc_gcse_mem.  */
@@ -982,12 +982,12 @@ free_gcse_mem (void)
   free (uid_cuid);
   free (cuid_insn);
 
-  BITMAP_XFREE (reg_set_bitmap);
+  BITMAP_FREE (reg_set_bitmap);
 
   sbitmap_vector_free (reg_set_in_block);
   free_modify_mem_tables ();
-  BITMAP_XFREE (modify_mem_list_set);
-  BITMAP_XFREE (blocks_with_calls);
+  BITMAP_FREE (modify_mem_list_set);
+  BITMAP_FREE (blocks_with_calls);
 }
 
 /* Compute the local properties of each recorded expression.
diff --git a/gcc/global.c b/gcc/global.c
index 35fec4a..c94e2ad 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -2033,21 +2033,21 @@ allocate_bb_info (void)
   bitmap init;
 
   alloc_aux_for_blocks (sizeof (struct bb_info));
-  init = BITMAP_XMALLOC ();
+  init = BITMAP_ALLOC (NULL);
   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
     bitmap_set_bit (init, i);
   FOR_EACH_BB (bb)
     {
       bb_info = bb->aux;
-      bb_info->earlyclobber = BITMAP_XMALLOC ();
-      bb_info->avloc = BITMAP_XMALLOC ();
-      bb_info->killed = BITMAP_XMALLOC ();
-      bb_info->live_pavin = BITMAP_XMALLOC ();
-      bb_info->live_pavout = BITMAP_XMALLOC ();
+      bb_info->earlyclobber = BITMAP_ALLOC (NULL);
+      bb_info->avloc = BITMAP_ALLOC (NULL);
+      bb_info->killed = BITMAP_ALLOC (NULL);
+      bb_info->live_pavin = BITMAP_ALLOC (NULL);
+      bb_info->live_pavout = BITMAP_ALLOC (NULL);
       bitmap_copy (bb_info->live_pavin, init);
       bitmap_copy (bb_info->live_pavout, init);
     }
-  BITMAP_XFREE (init);
+  BITMAP_FREE (init);
 }
 
 /* The function frees the allocated info of all basic blocks.  */
@@ -2061,11 +2061,11 @@ free_bb_info (void)
   FOR_EACH_BB (bb)
     {
       bb_info = BB_INFO (bb);
-      BITMAP_XFREE (bb_info->live_pavout);
-      BITMAP_XFREE (bb_info->live_pavin);
-      BITMAP_XFREE (bb_info->killed);
-      BITMAP_XFREE (bb_info->avloc);
-      BITMAP_XFREE (bb_info->earlyclobber);
+      BITMAP_FREE (bb_info->live_pavout);
+      BITMAP_FREE (bb_info->live_pavin);
+      BITMAP_FREE (bb_info->killed);
+      BITMAP_FREE (bb_info->avloc);
+      BITMAP_FREE (bb_info->earlyclobber);
     }
   free_aux_for_blocks ();
 }
@@ -2297,7 +2297,7 @@ calculate_reg_pav (void)
 
   VARRAY_BB_INIT (bbs, n_basic_blocks, "basic blocks");
   VARRAY_BB_INIT (new_bbs, n_basic_blocks, "basic blocks for the next iter.");
-  temp_bitmap = BITMAP_XMALLOC ();
+  temp_bitmap = BITMAP_ALLOC (NULL);
   FOR_EACH_BB (bb)
     {
       VARRAY_PUSH_BB (bbs, bb);
@@ -2351,7 +2351,7 @@ calculate_reg_pav (void)
       VARRAY_POP_ALL (new_bbs);
     }
   sbitmap_free (wset);
-  BITMAP_XFREE (temp_bitmap);
+  BITMAP_FREE (temp_bitmap);
 }
 
 /* The function modifies partial availability information for two
@@ -2373,7 +2373,7 @@ modify_reg_pav (void)
   CLEAR_HARD_REG_SET (stack_hard_regs);
   for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
     SET_HARD_REG_BIT(stack_hard_regs, i);
-  stack_regs = BITMAP_XMALLOC ();
+  stack_regs = BITMAP_ALLOC (NULL);
   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
     {
       COPY_HARD_REG_SET (used, reg_class_contents[reg_preferred_class (i)]);
@@ -2405,7 +2405,7 @@ modify_reg_pav (void)
 #endif
     }
 #ifdef STACK_REGS
-  BITMAP_XFREE (stack_regs);
+  BITMAP_FREE (stack_regs);
 #endif
 }
 
diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index 03f8c67..92d8caa 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -296,13 +296,13 @@ static void
 find_defs (struct loop *loop, basic_block *body, struct df *df)
 {
   unsigned i;
-  bitmap blocks = BITMAP_XMALLOC ();
+  bitmap blocks = BITMAP_ALLOC (NULL);
 
   for (i = 0; i < loop->num_nodes; i++)
     bitmap_set_bit (blocks, body[i]->index);
 
   df_analyze_subcfg (df, blocks, DF_UD_CHAIN | DF_HARD_REGS | DF_EQUIV_NOTES);
-  BITMAP_XFREE (blocks);
+  BITMAP_FREE (blocks);
 }
 
 /* Creates a new invariant for definition DEF in INSN, depending on invariants
@@ -447,10 +447,10 @@ find_invariant_insn (rtx insn, bool always_reached, bool always_executed,
 	return;
     }
 
-  depends_on = BITMAP_XMALLOC ();
+  depends_on = BITMAP_ALLOC (NULL);
   if (!check_dependencies (insn, df, depends_on))
     {
-      BITMAP_XFREE (depends_on);
+      BITMAP_FREE (depends_on);
       return;
     }
 
@@ -557,10 +557,10 @@ find_invariants_body (struct loop *loop, basic_block *body,
 static void
 find_invariants (struct loop *loop, struct df *df)
 {
-  bitmap may_exit = BITMAP_XMALLOC ();
-  bitmap always_reached = BITMAP_XMALLOC ();
-  bitmap has_exit = BITMAP_XMALLOC ();
-  bitmap always_executed = BITMAP_XMALLOC ();
+  bitmap may_exit = BITMAP_ALLOC (NULL);
+  bitmap always_reached = BITMAP_ALLOC (NULL);
+  bitmap has_exit = BITMAP_ALLOC (NULL);
+  bitmap always_executed = BITMAP_ALLOC (NULL);
   basic_block *body = get_loop_body_in_dom_order (loop);
 
   find_exits (loop, body, may_exit, has_exit);
@@ -570,10 +570,10 @@ find_invariants (struct loop *loop, struct df *df)
   find_defs (loop, body, df);
   find_invariants_body (loop, body, always_reached, always_executed, df);
 
-  BITMAP_XFREE (always_reached);
-  BITMAP_XFREE (always_executed);
-  BITMAP_XFREE (may_exit);
-  BITMAP_XFREE (has_exit);
+  BITMAP_FREE (always_reached);
+  BITMAP_FREE (always_executed);
+  BITMAP_FREE (may_exit);
+  BITMAP_FREE (has_exit);
   free (body);
 }
 
@@ -863,7 +863,7 @@ free_inv_motion_data (struct df *df)
   for (i = 0; i < VARRAY_ACTIVE_SIZE (invariants); i++)
     {
       inv = VARRAY_GENERIC_PTR_NOGC (invariants, i);
-      BITMAP_XFREE (inv->depends_on);
+      BITMAP_FREE (inv->depends_on);
       free (inv);
     }
   VARRAY_POP_ALL (invariants);
diff --git a/gcc/predict.c b/gcc/predict.c
index 30ad0fe..9ecf1e3 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -1043,9 +1043,9 @@ tree_predict_by_opcode (basic_block bb)
     return;
   op0 = TREE_OPERAND (cond, 0);
   type = TREE_TYPE (op0);
-  visited = BITMAP_XMALLOC ();
+  visited = BITMAP_ALLOC (NULL);
   val = expr_expected_value (cond, visited);
-  BITMAP_XFREE (visited);
+  BITMAP_FREE (visited);
   if (val)
     {
       if (integer_zerop (val))
@@ -1819,7 +1819,7 @@ estimate_bb_frequencies (struct loops *loops)
       EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->probability = REG_BR_PROB_BASE;
 
       /* Set up block info for each basic block.  */
-      tovisit = BITMAP_XMALLOC ();
+      tovisit = BITMAP_ALLOC (NULL);
       alloc_aux_for_blocks (sizeof (struct block_info_def));
       alloc_aux_for_edges (sizeof (struct edge_info_def));
       FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
@@ -1857,7 +1857,7 @@ estimate_bb_frequencies (struct loops *loops)
 
       free_aux_for_blocks ();
       free_aux_for_edges ();
-      BITMAP_XFREE (tovisit);
+      BITMAP_FREE (tovisit);
     }
   compute_function_frequency ();
   if (flag_reorder_functions)
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 6e21b54..4f366c3 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -2359,7 +2359,7 @@ expand_case (tree exp)
 
       uniq = 0;
       count = 0;
-      label_bitmap = BITMAP_XMALLOC ();
+      label_bitmap = BITMAP_ALLOC (NULL);
       for (n = case_list; n; n = n->right)
 	{
 	  /* Count the elements and track the largest and smallest
@@ -2390,7 +2390,7 @@ expand_case (tree exp)
 	    }
 	}
 
-      BITMAP_XFREE (label_bitmap);
+      BITMAP_FREE (label_bitmap);
 
       /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
 	 destination, such as one with a default case only.  */
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index cade864..680262c 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -5079,7 +5079,7 @@ tree_duplicate_sese_region (edge entry, edge exit,
     free (region_copy);
 
   unmark_all_for_rewrite ();
-  BITMAP_XFREE (definitions);
+  BITMAP_FREE (definitions);
 
   return true;
 }
diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c
index 70bbd7a..b591ffb 100644
--- a/gcc/tree-dfa.c
+++ b/gcc/tree-dfa.c
@@ -956,7 +956,7 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
   int v_may_defs_before, v_may_defs_after;
   int v_must_defs_before, v_must_defs_after;
 
-  vars_in_vops_to_rename = BITMAP_XMALLOC ();
+  vars_in_vops_to_rename = BITMAP_ALLOC (NULL);
 
   /* Before re-scanning the statement for operands, mark the existing
      virtual operands to be renamed again.  We do this because when new
@@ -1005,7 +1005,7 @@ mark_new_vars_to_rename (tree stmt, bitmap vars_to_rename)
       || v_must_defs_before > v_must_defs_after)
     bitmap_ior_into (vars_to_rename, vars_in_vops_to_rename);
 
-  BITMAP_XFREE (vars_in_vops_to_rename);
+  BITMAP_FREE (vars_in_vops_to_rename);
 }
 
 /* Find all variables within the gimplified statement that were not previously
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index fbcbe1c..73fba3f 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -1017,7 +1017,7 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
   gcc_assert (loop->latch != EXIT_BLOCK_PTR);
 
   blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
-  visited = BITMAP_XMALLOC ();
+  visited = BITMAP_ALLOC (NULL);
 
   blocks_in_bfs_order = get_loop_body_in_bfs_order (loop);
 
@@ -1029,7 +1029,7 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
       if (bb->flags & BB_IRREDUCIBLE_LOOP)
 	{
 	  free (blocks_in_bfs_order);
-	  BITMAP_XFREE (visited);
+	  BITMAP_FREE (visited);
 	  free (blocks);
 	  return NULL;
 	}
@@ -1052,7 +1052,7 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
 	}
     }
   free (blocks_in_bfs_order);
-  BITMAP_XFREE (visited);
+  BITMAP_FREE (visited);
   return blocks;
 }
 
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index c6124e2..0c4f80a 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -1023,7 +1023,7 @@ insert_phi_nodes_for (tree var, bitmap *dfs, VEC(basic_block) **work_stack)
   if (def_map == NULL)
     return;
 
-  phi_insertion_points = BITMAP_XMALLOC ();
+  phi_insertion_points = BITMAP_ALLOC (NULL);
 
   EXECUTE_IF_SET_IN_BITMAP (def_map->def_blocks, 0, bb_index, bi)
     {
@@ -1088,7 +1088,7 @@ insert_phi_nodes_for (tree var, bitmap *dfs, VEC(basic_block) **work_stack)
 	}
     }
 
-  BITMAP_XFREE (phi_insertion_points);
+  BITMAP_FREE (phi_insertion_points);
 }
 
 /* SSA Rewriting Step 2.  Rewrite every variable used in each statement in
@@ -1311,9 +1311,9 @@ static void
 def_blocks_free (void *p)
 {
   struct def_blocks_d *entry = p;
-  BITMAP_XFREE (entry->def_blocks);
-  BITMAP_XFREE (entry->phi_blocks);
-  BITMAP_XFREE (entry->livein_blocks);
+  BITMAP_FREE (entry->def_blocks);
+  BITMAP_FREE (entry->phi_blocks);
+  BITMAP_FREE (entry->livein_blocks);
   free (entry);
 }
 
@@ -1371,9 +1371,9 @@ get_def_blocks_for (tree var)
     {
       db_p = xmalloc (sizeof (*db_p));
       db_p->var = var;
-      db_p->def_blocks = BITMAP_XMALLOC ();
-      db_p->phi_blocks = BITMAP_XMALLOC ();
-      db_p->livein_blocks = BITMAP_XMALLOC ();
+      db_p->def_blocks = BITMAP_ALLOC (NULL);
+      db_p->phi_blocks = BITMAP_ALLOC (NULL);
+      db_p->livein_blocks = BITMAP_ALLOC (NULL);
       *slot = (void *) db_p;
     }
   else
@@ -1521,7 +1521,7 @@ mark_def_site_blocks (void)
   /* 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.  */
-  mark_def_sites_global_data.kills = BITMAP_XMALLOC ();
+  mark_def_sites_global_data.kills = BITMAP_ALLOC (NULL);
   walk_data.global_data = &mark_def_sites_global_data;
 
   /* We do not have any local data.  */
@@ -1537,7 +1537,7 @@ mark_def_site_blocks (void)
   fini_walk_dominator_tree (&walk_data);
 
   /* We no longer need this bitmap, clear and free it.  */
-  BITMAP_XFREE (mark_def_sites_global_data.kills);
+  BITMAP_FREE (mark_def_sites_global_data.kills);
 }
 
 
@@ -1601,7 +1601,7 @@ rewrite_into_ssa (bool all)
      can save significant time during PHI insertion for large graphs.  */
   dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *));
   FOR_EACH_BB (bb)
-    dfs[bb->index] = BITMAP_XMALLOC ();
+    dfs[bb->index] = BITMAP_ALLOC (NULL);
 
   /* Compute dominance frontiers.  */
   compute_dominance_frontiers (dfs);
@@ -1620,7 +1620,7 @@ rewrite_into_ssa (bool all)
 
   /* Free allocated memory.  */
   FOR_EACH_BB (bb)
-    BITMAP_XFREE (dfs[bb->index]);
+    BITMAP_FREE (dfs[bb->index]);
   free (dfs);
 
   vars_to_rename = old_vars_to_rename;
@@ -1669,7 +1669,7 @@ rewrite_ssa_into_ssa (void)
      can save significant time during PHI insertion for large graphs.  */
   dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *));
   FOR_EACH_BB (bb)
-    dfs[bb->index] = BITMAP_XMALLOC ();
+    dfs[bb->index] = BITMAP_ALLOC (NULL);
 
   /* Ensure that the dominance information is OK.  */
   calculate_dominance_info (CDI_DOMINATORS);
@@ -1698,7 +1698,7 @@ rewrite_ssa_into_ssa (void)
       set_current_def (ssa_name (i), NULL_TREE);
     }
 
-  mark_def_sites_global_data.kills = BITMAP_XMALLOC ();
+  mark_def_sites_global_data.kills = BITMAP_ALLOC (NULL);
   mark_def_sites_global_data.names_to_rename = snames_to_rename;
   walk_data.global_data = &mark_def_sites_global_data;
 
@@ -1717,7 +1717,7 @@ rewrite_ssa_into_ssa (void)
   fini_walk_dominator_tree (&walk_data);
 
   /* We no longer need this bitmap, clear and free it.  */
-  BITMAP_XFREE (mark_def_sites_global_data.kills);
+  BITMAP_FREE (mark_def_sites_global_data.kills);
 
   /* Insert PHI nodes at dominance frontiers of definition blocks.  */
   insert_phi_nodes (dfs, to_rename);
@@ -1773,7 +1773,7 @@ rewrite_ssa_into_ssa (void)
 
   /* Free allocated memory.  */
   FOR_EACH_BB (bb)
-    BITMAP_XFREE (dfs[bb->index]);
+    BITMAP_FREE (dfs[bb->index]);
   free (dfs);
 
   htab_delete (def_blocks);
@@ -1789,7 +1789,7 @@ rewrite_ssa_into_ssa (void)
     }
 #endif
 
-  BITMAP_XFREE (to_rename);
+  BITMAP_FREE (to_rename);
   
   VEC_free (tree_on_heap, block_defs_stack);
   block_defs_stack = NULL;
diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c
index a2b7697..d2c8ede 100644
--- a/gcc/tree-optimize.c
+++ b/gcc/tree-optimize.c
@@ -664,7 +664,7 @@ tree_rest_of_compilation (tree fndecl)
   bitmap_obstack_initialize (NULL);
   bitmap_obstack_initialize (&reg_obstack); /* FIXME, only at RTL generation*/
   
-  vars_to_rename = BITMAP_XMALLOC ();
+  vars_to_rename = BITMAP_ALLOC (NULL);
   
   /* Perform all tree transforms and optimizations.  */
   execute_pass_list (all_passes);
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index c6aa812..57aa200 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -1260,8 +1260,8 @@ new_temp_expr_table (var_map map)
   t->partition_dep_list = xcalloc (num_var_partitions (map) + 1, 
 				   sizeof (value_expr_p));
 
-  t->replaceable = BITMAP_XMALLOC ();
-  t->partition_in_use = BITMAP_XMALLOC ();
+  t->replaceable = BITMAP_ALLOC (NULL);
+  t->partition_in_use = BITMAP_ALLOC (NULL);
 
   t->saw_replaceable = false;
   t->virtual_partition = num_var_partitions (map);
@@ -1293,8 +1293,8 @@ free_temp_expr_table (temp_expr_table_p t)
       free (p);
     }
 
-  BITMAP_XFREE (t->partition_in_use);
-  BITMAP_XFREE (t->replaceable);
+  BITMAP_FREE (t->partition_in_use);
+  BITMAP_FREE (t->replaceable);
 
   free (t->partition_dep_list);
   if (t->saw_replaceable)
@@ -2115,7 +2115,7 @@ analyze_edges_for_bb (basic_block bb, FILE *debug_file)
     {
       VARRAY_EDGE_INIT (edge_leader, 25, "edge_leader");
       VARRAY_TREE_INIT (stmt_list, 25, "stmt_list");
-      leader_has_match = BITMAP_XMALLOC ();
+      leader_has_match = BITMAP_ALLOC (NULL);
     }
   else
     {
@@ -2261,7 +2261,7 @@ perform_edge_inserts (FILE *dump_file)
 
   /* Clear out any tables which were created.  */
   edge_leader = NULL;
-  BITMAP_XFREE (leader_has_match);
+  BITMAP_FREE (leader_has_match);
 
   if (changed)
     {
diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c
index c1c1035..c6a60fe 100644
--- a/gcc/tree-scalar-evolution.c
+++ b/gcc/tree-scalar-evolution.c
@@ -2466,7 +2466,7 @@ scev_initialize (struct loops *loops)
 
   scalar_evolution_info = htab_create (100, hash_scev_info,
 				       eq_scev_info, del_scev_info);
-  already_instantiated = BITMAP_XMALLOC ();
+  already_instantiated = BITMAP_ALLOC (NULL);
   
   initialize_scalar_evolutions_analyzer ();
 
@@ -2561,6 +2561,6 @@ void
 scev_finalize (void)
 {
   htab_delete (scalar_evolution_info);
-  BITMAP_XFREE (already_instantiated);
+  BITMAP_FREE (already_instantiated);
 }
 
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
index 01bf53c..1510904 100644
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -2079,10 +2079,10 @@ tree_sra (void)
 {
   /* Initialize local variables.  */
   gcc_obstack_init (&sra_obstack);
-  sra_candidates = BITMAP_XMALLOC ();
-  needs_copy_in = BITMAP_XMALLOC ();
-  sra_type_decomp_cache = BITMAP_XMALLOC ();
-  sra_type_inst_cache = BITMAP_XMALLOC ();
+  sra_candidates = BITMAP_ALLOC (NULL);
+  needs_copy_in = BITMAP_ALLOC (NULL);
+  sra_type_decomp_cache = BITMAP_ALLOC (NULL);
+  sra_type_inst_cache = BITMAP_ALLOC (NULL);
   sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL);
 
   /* Scan.  If we find anything, instantiate and scalarize.  */
@@ -2096,10 +2096,10 @@ tree_sra (void)
   /* Free allocated memory.  */
   htab_delete (sra_map);
   sra_map = NULL;
-  BITMAP_XFREE (sra_candidates);
-  BITMAP_XFREE (needs_copy_in);
-  BITMAP_XFREE (sra_type_decomp_cache);
-  BITMAP_XFREE (sra_type_inst_cache);
+  BITMAP_FREE (sra_candidates);
+  BITMAP_FREE (needs_copy_in);
+  BITMAP_FREE (sra_type_decomp_cache);
+  BITMAP_FREE (sra_type_inst_cache);
   obstack_free (&sra_obstack, NULL);
 }
 
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 6a95bcd..3e5f8e3 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -534,11 +534,11 @@ init_alias_info (void)
   ai->ssa_names_visited = sbitmap_alloc (num_ssa_names);
   sbitmap_zero (ai->ssa_names_visited);
   VARRAY_TREE_INIT (ai->processed_ptrs, 50, "processed_ptrs");
-  ai->addresses_needed = BITMAP_XMALLOC ();
+  ai->addresses_needed = BITMAP_ALLOC (NULL);
   VARRAY_UINT_INIT (ai->num_references, num_referenced_vars, "num_references");
-  ai->written_vars = BITMAP_XMALLOC ();
-  ai->dereferenced_ptrs_store = BITMAP_XMALLOC ();
-  ai->dereferenced_ptrs_load = BITMAP_XMALLOC ();
+  ai->written_vars = BITMAP_ALLOC (NULL);
+  ai->dereferenced_ptrs_store = BITMAP_ALLOC (NULL);
+  ai->dereferenced_ptrs_load = BITMAP_ALLOC (NULL);
 
   /* If aliases have been computed before, clear existing information.  */
   if (aliases_computed_p)
@@ -626,7 +626,7 @@ delete_alias_info (struct alias_info *ai)
 
   sbitmap_free (ai->ssa_names_visited);
   ai->processed_ptrs = NULL;
-  BITMAP_XFREE (ai->addresses_needed);
+  BITMAP_FREE (ai->addresses_needed);
 
   for (i = 0; i < ai->num_addressable_vars; i++)
     {
@@ -643,9 +643,9 @@ delete_alias_info (struct alias_info *ai)
   free (ai->pointers);
 
   ai->num_references = NULL;
-  BITMAP_XFREE (ai->written_vars);
-  BITMAP_XFREE (ai->dereferenced_ptrs_store);
-  BITMAP_XFREE (ai->dereferenced_ptrs_load);
+  BITMAP_FREE (ai->written_vars);
+  BITMAP_FREE (ai->dereferenced_ptrs_store);
+  BITMAP_FREE (ai->dereferenced_ptrs_load);
 
   free (ai);
 }
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 995b943..12d5a61 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1961,7 +1961,7 @@ ccp_fold_builtin (tree stmt, tree fn)
     }
 
   /* Try to use the dataflow information gathered by the CCP process.  */
-  visited = BITMAP_XMALLOC ();
+  visited = BITMAP_ALLOC (NULL);
 
   memset (strlen_val, 0, sizeof (strlen_val));
   for (i = 0, a = arglist;
@@ -1974,7 +1974,7 @@ ccp_fold_builtin (tree stmt, tree fn)
 	  strlen_val[i] = NULL_TREE;
       }
 
-  BITMAP_XFREE (visited);
+  BITMAP_FREE (visited);
 
   result = NULL_TREE;
   switch (DECL_FUNCTION_CODE (callee))
diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index 87f6561..16b9d48 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -879,7 +879,7 @@ tree_dce_init (bool aggressive)
       control_dependence_map 
 	= xmalloc (last_basic_block * sizeof (bitmap));
       for (i = 0; i < last_basic_block; ++i)
-	control_dependence_map[i] = BITMAP_XMALLOC ();
+	control_dependence_map[i] = BITMAP_ALLOC (NULL);
 
       last_stmt_necessary = sbitmap_alloc (last_basic_block);
       sbitmap_zero (last_stmt_necessary);
@@ -901,7 +901,7 @@ tree_dce_done (bool aggressive)
       int i;
 
       for (i = 0; i < last_basic_block; ++i)
-	BITMAP_XFREE (control_dependence_map[i]);
+	BITMAP_FREE (control_dependence_map[i]);
       free (control_dependence_map);
 
       sbitmap_free (visited_control_parents);
diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c
index ad8bc53..0d34ea2 100644
--- a/gcc/tree-ssa-dom.c
+++ b/gcc/tree-ssa-dom.c
@@ -383,8 +383,8 @@ tree_ssa_dominator_optimize (void)
   nonzero_vars_stack = VEC_alloc (tree_on_heap, 20);
   vrp_variables_stack = VEC_alloc (tree_on_heap, 20);
   stmts_to_rescan = VEC_alloc (tree_on_heap, 20);
-  nonzero_vars = BITMAP_XMALLOC ();
-  need_eh_cleanup = BITMAP_XMALLOC ();
+  nonzero_vars = BITMAP_ALLOC (NULL);
+  need_eh_cleanup = BITMAP_ALLOC (NULL);
 
   /* Setup callbacks for the generic dominator tree walker.  */
   walk_data.walk_stmts_backward = false;
@@ -497,8 +497,8 @@ tree_ssa_dominator_optimize (void)
   fini_walk_dominator_tree (&walk_data);
 
   /* Free nonzero_vars.  */
-  BITMAP_XFREE (nonzero_vars);
-  BITMAP_XFREE (need_eh_cleanup);
+  BITMAP_FREE (nonzero_vars);
+  BITMAP_FREE (need_eh_cleanup);
   
   VEC_free (tree_on_heap, block_defs_stack);
   VEC_free (tree_on_heap, avail_exprs_stack);
diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c
index 625e1d1..249132d 100644
--- a/gcc/tree-ssa-dse.c
+++ b/gcc/tree-ssa-dse.c
@@ -433,7 +433,7 @@ tree_ssa_dse (void)
   walk_data.block_local_data_size = sizeof (struct dse_block_local_data);
 
   /* This is the main hash table for the dead store elimination pass.  */
-  dse_gd.stores = BITMAP_XMALLOC ();
+  dse_gd.stores = BITMAP_ALLOC (NULL);
   walk_data.global_data = &dse_gd;
 
   /* Initialize the dominator walker.  */
@@ -446,7 +446,7 @@ tree_ssa_dse (void)
   fini_walk_dominator_tree (&walk_data);
 
   /* Release the main bitmap.  */
-  BITMAP_XFREE (dse_gd.stores);
+  BITMAP_FREE (dse_gd.stores);
 
   /* Free dataflow information.  It's probably out of date now anyway.  */
   free_df ();
diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c
index b13894e..12bc551 100644
--- a/gcc/tree-ssa-forwprop.c
+++ b/gcc/tree-ssa-forwprop.c
@@ -480,7 +480,7 @@ tree_ssa_forward_propagate_single_use_vars (void)
   basic_block bb;
   varray_type vars_worklist, cond_worklist;
 
-  vars = BITMAP_XMALLOC ();
+  vars = BITMAP_ALLOC (NULL);
   VARRAY_TREE_INIT (vars_worklist, 10, "VARS worklist");
   VARRAY_TREE_INIT (cond_worklist, 10, "COND worklist");
 
@@ -522,7 +522,7 @@ tree_ssa_forward_propagate_single_use_vars (void)
     }
 
   /* All done.  Clean up.  */
-  BITMAP_XFREE (vars);
+  BITMAP_FREE (vars);
 }
 
 
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 15c8b48..13cd843 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -439,11 +439,11 @@ new_tree_live_info (var_map map)
   live->map = map;
   live->num_blocks = last_basic_block;
 
-  live->global = BITMAP_XMALLOC ();
+  live->global = BITMAP_ALLOC (NULL);
 
   live->livein = (bitmap *)xmalloc (num_var_partitions (map) * sizeof (bitmap));
   for (x = 0; x < num_var_partitions (map); x++)
-    live->livein[x] = BITMAP_XMALLOC ();
+    live->livein[x] = BITMAP_ALLOC (NULL);
 
   /* liveout is deferred until it is actually requested.  */
   live->liveout = NULL;
@@ -460,17 +460,17 @@ delete_tree_live_info (tree_live_info_p live)
   if (live->liveout)
     {
       for (x = live->num_blocks - 1; x >= 0; x--)
-        BITMAP_XFREE (live->liveout[x]);
+        BITMAP_FREE (live->liveout[x]);
       free (live->liveout);
     }
   if (live->livein)
     {
       for (x = num_var_partitions (live->map) - 1; x >= 0; x--)
-        BITMAP_XFREE (live->livein[x]);
+        BITMAP_FREE (live->livein[x]);
       free (live->livein);
     }
   if (live->global)
-    BITMAP_XFREE (live->global);
+    BITMAP_FREE (live->global);
   
   free (live);
 }
@@ -573,7 +573,7 @@ calculate_live_on_entry (var_map map)
   edge_iterator ei;
 #endif
 
-  saw_def = BITMAP_XMALLOC ();
+  saw_def = BITMAP_ALLOC (NULL);
 
   live = new_tree_live_info (map);
 
@@ -720,7 +720,7 @@ calculate_live_on_entry (var_map map)
   gcc_assert (num <= 0);
 #endif
 
-  BITMAP_XFREE (saw_def);
+  BITMAP_FREE (saw_def);
 
   return live;
 }
@@ -742,7 +742,7 @@ calculate_live_on_exit (tree_live_info_p liveinfo)
 
   on_exit = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap));
   for (x = 0; x < (unsigned)last_basic_block; x++)
-    on_exit[x] = BITMAP_XMALLOC ();
+    on_exit[x] = BITMAP_ALLOC (NULL);
 
   /* Set all the live-on-exit bits for uses in PHIs.  */
   FOR_EACH_BB (bb)
@@ -1309,7 +1309,7 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa,
   if (tpa_num_trees (tpa) == 0)
     return graph;
 
-  live = BITMAP_XMALLOC ();
+  live = BITMAP_ALLOC (NULL);
 
   VARRAY_INT_INIT (partition_link, num_var_partitions (map) + 1, "part_link");
   VARRAY_INT_INIT (tpa_nodes, tpa_num_trees (tpa), "tpa nodes");
@@ -1443,7 +1443,7 @@ build_tree_conflict_graph (tree_live_info_p liveinfo, tpa_p tpa,
 	VARRAY_POP_ALL (tpa_to_clear);
     }
 
-  BITMAP_XFREE (live);
+  BITMAP_FREE (live);
   return graph;
 }
 
diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c
index 40661be..d1adbab 100644
--- a/gcc/tree-ssa-loop-ivopts.c
+++ b/gcc/tree-ssa-loop-ivopts.c
@@ -730,8 +730,8 @@ tree_ssa_iv_optimize_init (struct loops *loops, struct ivopts_data *data)
   data->version_info_size = 2 * num_ssa_names;
   data->version_info = xcalloc (data->version_info_size,
 				sizeof (struct version_info));
-  data->relevant = BITMAP_XMALLOC ();
-  data->important_candidates = BITMAP_XMALLOC ();
+  data->relevant = BITMAP_ALLOC (NULL);
+  data->important_candidates = BITMAP_ALLOC (NULL);
   data->max_inv_id = 0;
   data->niters = htab_create (10, nfe_hash, nfe_eq, free);
 
@@ -1152,7 +1152,7 @@ record_use (struct ivopts_data *data, tree *use_p, struct iv *iv,
   use->iv = iv;
   use->stmt = stmt;
   use->op_p = use_p;
-  use->related_cands = BITMAP_XMALLOC ();
+  use->related_cands = BITMAP_ALLOC (NULL);
 
   /* To avoid showing ssa name in the dumps, if it was not reset by the
      caller.  */
@@ -2184,7 +2184,7 @@ record_important_candidates (struct ivopts_data *data)
       for (i = 0; i < n_iv_uses (data); i++)
 	{
 	  use = iv_use (data, i);
-	  BITMAP_XFREE (use->related_cands);
+	  BITMAP_FREE (use->related_cands);
 	}
     }
   else
@@ -2260,7 +2260,7 @@ set_use_iv_cost (struct ivopts_data *data,
 
   if (cost == INFTY)
     {
-      BITMAP_XFREE (depends_on);
+      BITMAP_FREE (depends_on);
       return;
     }
 
@@ -2827,7 +2827,7 @@ find_depends (tree *expr_p, int *ws ATTRIBUTE_UNUSED, void *data)
     return NULL_TREE;
 
   if (!*depends_on)
-    *depends_on = BITMAP_XMALLOC ();
+    *depends_on = BITMAP_ALLOC (NULL);
   bitmap_set_bit (*depends_on, info->inv_id);
 
   return NULL_TREE;
@@ -3589,7 +3589,7 @@ determine_use_iv_costs (struct ivopts_data *data)
   unsigned i, j;
   struct iv_use *use;
   struct iv_cand *cand;
-  bitmap to_clear = BITMAP_XMALLOC ();
+  bitmap to_clear = BITMAP_ALLOC (NULL);
 
   alloc_use_cost_map (data);
 
@@ -3623,7 +3623,7 @@ determine_use_iv_costs (struct ivopts_data *data)
 	}
     }
 
-  BITMAP_XFREE (to_clear);
+  BITMAP_FREE (to_clear);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
@@ -4134,7 +4134,7 @@ iv_ca_new (struct ivopts_data *data)
   nw->bad_uses = 0;
   nw->cand_for_use = xcalloc (n_iv_uses (data), sizeof (struct cost_pair *));
   nw->n_cand_uses = xcalloc (n_iv_cands (data), sizeof (unsigned));
-  nw->cands = BITMAP_XMALLOC ();
+  nw->cands = BITMAP_ALLOC (NULL);
   nw->n_cands = 0;
   nw->n_regs = 0;
   nw->cand_use_cost = 0;
@@ -4152,7 +4152,7 @@ iv_ca_free (struct iv_ca **ivs)
 {
   free ((*ivs)->cand_for_use);
   free ((*ivs)->n_cand_uses);
-  BITMAP_XFREE ((*ivs)->cands);
+  BITMAP_FREE ((*ivs)->cands);
   free ((*ivs)->n_invariant_uses);
   free (*ivs);
   *ivs = NULL;
@@ -5192,10 +5192,10 @@ free_loop_data (struct ivopts_data *data)
       struct iv_use *use = iv_use (data, i);
 
       free (use->iv);
-      BITMAP_XFREE (use->related_cands);
+      BITMAP_FREE (use->related_cands);
       for (j = 0; j < use->n_map_members; j++)
 	if (use->cost_map[j].depends_on)
-	  BITMAP_XFREE (use->cost_map[j].depends_on);
+	  BITMAP_FREE (use->cost_map[j].depends_on);
       free (use->cost_map);
       free (use);
     }
@@ -5247,8 +5247,8 @@ tree_ssa_iv_optimize_finalize (struct loops *loops, struct ivopts_data *data)
 
   free_loop_data (data);
   free (data->version_info);
-  BITMAP_XFREE (data->relevant);
-  BITMAP_XFREE (data->important_candidates);
+  BITMAP_FREE (data->relevant);
+  BITMAP_FREE (data->important_candidates);
   htab_delete (data->niters);
 
   VARRAY_FREE (decl_rtl_to_reset);
diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c
index 6f745ea..848abbc 100644
--- a/gcc/tree-ssa-loop-manip.c
+++ b/gcc/tree-ssa-loop-manip.c
@@ -159,10 +159,10 @@ add_exit_phis_var (tree var, bitmap livein, bitmap exits)
 
   bitmap_clear_bit (livein, def_bb->index);
 
-  def = BITMAP_XMALLOC ();
+  def = BITMAP_ALLOC (NULL);
   bitmap_set_bit (def, def_bb->index);
   compute_global_livein (livein, def);
-  BITMAP_XFREE (def);
+  BITMAP_FREE (def);
 
   EXECUTE_IF_AND_IN_BITMAP (exits, livein, 0, index, bi)
     {
@@ -191,7 +191,7 @@ add_exit_phis (bitmap names_to_rename, bitmap *use_blocks, bitmap loop_exits)
 static bitmap
 get_loops_exits (void)
 {
-  bitmap exits = BITMAP_XMALLOC ();
+  bitmap exits = BITMAP_ALLOC (NULL);
   basic_block bb;
   edge e;
   edge_iterator ei;
@@ -235,7 +235,7 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks)
     return;
 
   if (!use_blocks[ver])
-    use_blocks[ver] = BITMAP_XMALLOC ();
+    use_blocks[ver] = BITMAP_ALLOC (NULL);
   bitmap_set_bit (use_blocks[ver], bb->index);
 
   if (!flow_bb_inside_loop_p (def_loop, bb))
@@ -330,10 +330,10 @@ rewrite_into_loop_closed_ssa (void)
   add_exit_phis (names_to_rename, use_blocks, loop_exits);
 
   for (i = 0; i < num_ssa_names; i++)
-    BITMAP_XFREE (use_blocks[i]);
+    BITMAP_FREE (use_blocks[i]);
   free (use_blocks);
-  BITMAP_XFREE (loop_exits);
-  BITMAP_XFREE (names_to_rename);
+  BITMAP_FREE (loop_exits);
+  BITMAP_FREE (names_to_rename);
 
   /* Do the rewriting.  */
   rewrite_ssa_into_ssa ();
@@ -618,7 +618,7 @@ tree_duplicate_loop_to_header_edge (struct loop *loop, edge e,
   definitions = marked_ssa_names ();
   rename_variables (first_new_block, definitions);
   unmark_all_for_rewrite ();
-  BITMAP_XFREE (definitions);
+  BITMAP_FREE (definitions);
 
   /* For some time we have the identical ssa names as results in multiple phi
      nodes.  When phi node is resized, it sets SSA_NAME_DEF_STMT of its result
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index a364162..66e2b22 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -2170,7 +2170,7 @@ init_pre (bool do_fre)
       AVAIL_OUT (bb) = bitmap_set_new ();
     }
 
-  need_eh_cleanup = BITMAP_XMALLOC ();
+  need_eh_cleanup = BITMAP_ALLOC (NULL);
 }
 
 
@@ -2208,7 +2208,7 @@ fini_pre (bool do_fre)
       cleanup_tree_cfg ();
     }
 
-  BITMAP_XFREE (need_eh_cleanup);
+  BITMAP_FREE (need_eh_cleanup);
 
   /* Wipe out pointers to VALUE_HANDLEs.  In the not terribly distant
      future we will want them to be persistent though.  */
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c
index de4006d..56a181a 100644
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -341,7 +341,7 @@ verify_flow_insensitive_alias_info (void)
 {
   size_t i;
   tree var;
-  bitmap visited = BITMAP_XMALLOC ();
+  bitmap visited = BITMAP_ALLOC (NULL);
 
   for (i = 0; i < num_referenced_vars; i++)
     {
@@ -384,7 +384,7 @@ verify_flow_insensitive_alias_info (void)
 	}
     }
 
-  BITMAP_XFREE (visited);
+  BITMAP_FREE (visited);
   return;
 
 err:
@@ -480,7 +480,7 @@ verify_name_tags (void)
   bitmap first, second;  
   VEC (tree) *name_tag_reps = NULL;
   VEC (bitmap) *pt_vars_for_reps = NULL;
-  bitmap type_aliases = BITMAP_XMALLOC ();
+  bitmap type_aliases = BITMAP_ALLOC (NULL);
 
   /* First we compute the name tag representatives and their points-to sets.  */
   for (i = 0; i < num_ssa_names; i++)
@@ -604,7 +604,7 @@ verify_ssa (void)
   ssa_op_iter iter;
   tree op;
   enum dom_state orig_dom_state = dom_computed[CDI_DOMINATORS];
-  bitmap names_defined_in_bb = BITMAP_XMALLOC ();
+  bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
 
   timevar_push (TV_TREE_SSA_VERIFY);
 
@@ -702,7 +702,7 @@ verify_ssa (void)
   else
     dom_computed[CDI_DOMINATORS] = orig_dom_state;
   
-  BITMAP_XFREE (names_defined_in_bb);
+  BITMAP_FREE (names_defined_in_bb);
   timevar_pop (TV_TREE_SSA_VERIFY);
   return;
 
@@ -717,8 +717,8 @@ void
 init_tree_ssa (void)
 {
   VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars");
-  call_clobbered_vars = BITMAP_XMALLOC ();
-  addressable_vars = BITMAP_XMALLOC ();
+  call_clobbered_vars = BITMAP_ALLOC (NULL);
+  addressable_vars = BITMAP_ALLOC (NULL);
   init_ssa_operands ();
   init_ssanames ();
   init_phinodes ();
@@ -762,9 +762,9 @@ delete_tree_ssa (void)
   fini_ssa_operands ();
 
   global_var = NULL_TREE;
-  BITMAP_XFREE (call_clobbered_vars);
+  BITMAP_FREE (call_clobbered_vars);
   call_clobbered_vars = NULL;
-  BITMAP_XFREE (addressable_vars);
+  BITMAP_FREE (addressable_vars);
   addressable_vars = NULL;
   modified_noreturn_calls = NULL;
 }
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index db6717c..7c181ed 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -118,7 +118,7 @@ unmark_all_for_rewrite (void)
 bitmap
 marked_ssa_names (void)
 {
-  bitmap ret = BITMAP_XMALLOC ();
+  bitmap ret = BITMAP_ALLOC (NULL);
 
   bitmap_copy (ret, ssa_names_to_rewrite);
 
@@ -138,7 +138,7 @@ init_ssanames (void)
      large.  */
   VARRAY_PUSH_TREE (ssa_names, NULL_TREE);
   free_ssanames = NULL;
-  ssa_names_to_rewrite = BITMAP_XMALLOC ();
+  ssa_names_to_rewrite = BITMAP_ALLOC (NULL);
 }
 
 /* Finalize management of SSA_NAMEs.  */
@@ -146,7 +146,7 @@ init_ssanames (void)
 void
 fini_ssanames (void)
 {
-  BITMAP_XFREE (ssa_names_to_rewrite);
+  BITMAP_FREE (ssa_names_to_rewrite);
   ggc_free (ssa_names);
   ssa_names = NULL;
   free_ssanames = NULL;
diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index a7e5bec..8c44742 100644
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -1023,7 +1023,7 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loops *loops,
     slpeel_make_loop_iterate_ntimes (first_loop, first_niters);
 
   free_new_names (definitions);
-  BITMAP_XFREE (definitions);
+  BITMAP_FREE (definitions);
   unmark_all_for_rewrite ();
 
   return new_loop;