git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Nathan Sidwell 2005-02-17 16:19:49 +00:00 committed by Nathan Sidwell
parent 3abbb7389b
commit 8bdbfff57e
35 changed files with 264 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
gcc/ChangeLog
View File

@ -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> 2005-02-17 Ralf Corsepius <ralf.corsepius@rtems.org>
* config/rs6000/t-rtems: Completely reworked. * config/rs6000/t-rtems: Completely reworked.

4
gcc/bb-reorder.c
View File

@ -2031,7 +2031,7 @@ duplicate_computed_gotos (void)
uncond_jump_length = get_uncond_jump_length (); uncond_jump_length = get_uncond_jump_length ();
max_size = uncond_jump_length * PARAM_VALUE (PARAM_MAX_GOTO_DUPLICATION_INSNS); 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. /* Build the reorder chain for the original order of blocks.
Look for a computed jump while we are at it. */ Look for a computed jump while we are at it. */
@ -2094,7 +2094,7 @@ duplicate_computed_gotos (void)
done: done:
cfg_layout_finalize (); cfg_layout_finalize ();
BITMAP_XFREE (candidates); BITMAP_FREE (candidates);
timevar_pop (TV_REORDER_BLOCKS); timevar_pop (TV_REORDER_BLOCKS);
} }

6
gcc/bitmap.h
View File

@ -159,16 +159,10 @@ extern unsigned bitmap_first_set_bit (bitmap);
/* Allocate a gc'd bitmap. */ /* Allocate a gc'd bitmap. */
#define BITMAP_GGC_ALLOC() bitmap_gc_alloc () #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. */ /* Do any cleanup needed on a bitmap when it is no longer used. */
#define BITMAP_FREE(BITMAP) \ #define BITMAP_FREE(BITMAP) \
((void)(bitmap_obstack_free (BITMAP), (BITMAP) = NULL)) ((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. */ /* Iterator for bitmaps. */
typedef struct typedef struct

12
gcc/bt-load.c
View File

@ -996,7 +996,7 @@ btr_def_live_range (btr_def def, HARD_REG_SET *btrs_live_in_range)
{ {
btr_user user; btr_user user;
def->live_range = BITMAP_XMALLOC (); def->live_range = BITMAP_ALLOC (NULL);
bitmap_set_bit (def->live_range, def->bb->index); bitmap_set_bit (def->live_range, def->bb->index);
COPY_HARD_REG_SET (*btrs_live_in_range, 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. */ target registers live over the merged range. */
int btr; int btr;
HARD_REG_SET combined_btrs_live; HARD_REG_SET combined_btrs_live;
bitmap combined_live_range = BITMAP_XMALLOC (); bitmap combined_live_range = BITMAP_ALLOC (NULL);
btr_user user; btr_user user;
if (other_def->live_range == NULL) 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); 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); 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); bitmap_copy (live_range, def->live_range);
#ifdef INSN_SCHEDULING #ifdef INSN_SCHEDULING
@ -1361,7 +1361,7 @@ migrate_btr_def (btr_def def, int min_cost)
if (dump_file) if (dump_file)
fprintf (dump_file, "failed to move\n"); fprintf (dump_file, "failed to move\n");
} }
BITMAP_XFREE (live_range); BITMAP_FREE (live_range);
return !give_up; return !give_up;
} }
@ -1420,7 +1420,7 @@ migrate_btr_defs (enum reg_class btr_class, int allow_callee_save)
} }
} }
else else
BITMAP_XFREE (def->live_range); BITMAP_FREE (def->live_range);
} }
free (btrs_live); free (btrs_live);

6
gcc/cfgcleanup.c
View File

@ -353,7 +353,7 @@ thread_jump (int mode, edge e, basic_block b)
if (INSN_P (insn)) if (INSN_P (insn))
cselib_process_insn (insn); cselib_process_insn (insn);
nonequal = BITMAP_XMALLOC(); nonequal = BITMAP_ALLOC (NULL);
CLEAR_REG_SET (nonequal); CLEAR_REG_SET (nonequal);
/* Now assume that we've continued by the edge E to B and continue /* 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) EXECUTE_IF_SET_IN_REG_SET (nonequal, 0, i, rsi)
goto failed_exit; goto failed_exit;
BITMAP_XFREE (nonequal); BITMAP_FREE (nonequal);
cselib_finish (); cselib_finish ();
if ((comparison_dominates_p (code1, code2) != 0) if ((comparison_dominates_p (code1, code2) != 0)
!= (XEXP (SET_SRC (set2), 1) == pc_rtx)) != (XEXP (SET_SRC (set2), 1) == pc_rtx))
@ -410,7 +410,7 @@ thread_jump (int mode, edge e, basic_block b)
return FALLTHRU_EDGE (b); return FALLTHRU_EDGE (b);
failed_exit: failed_exit:
BITMAP_XFREE (nonequal); BITMAP_FREE (nonequal);
cselib_finish (); cselib_finish ();
return NULL; return NULL;
} }

4
gcc/cfgloop.c
View File

@ -1103,7 +1103,7 @@ get_loop_body_in_bfs_order (const struct loop *loop)
gcc_assert (loop->latch != EXIT_BLOCK_PTR); gcc_assert (loop->latch != EXIT_BLOCK_PTR);
blocks = xcalloc (loop->num_nodes, sizeof (basic_block)); blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
visited = BITMAP_XMALLOC (); visited = BITMAP_ALLOC (NULL);
bb = loop->header; bb = loop->header;
while (i < loop->num_nodes) while (i < loop->num_nodes)
@ -1135,7 +1135,7 @@ get_loop_body_in_bfs_order (const struct loop *loop)
bb = blocks[vc++]; bb = blocks[vc++];
} }
BITMAP_XFREE (visited); BITMAP_FREE (visited);
return blocks; return blocks;
} }

76
gcc/df.c
View File

@ -320,7 +320,7 @@ df_insn_table_realloc (struct df *df, unsigned int size)
if (! df->insns_modified) if (! df->insns_modified)
{ {
df->insns_modified = BITMAP_XMALLOC (); df->insns_modified = BITMAP_ALLOC (NULL);
bitmap_zero (df->insns_modified); bitmap_zero (df->insns_modified);
} }
} }
@ -392,10 +392,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
if (!bb_info->rd_in) if (!bb_info->rd_in)
{ {
/* Allocate bitmaps for reaching definitions. */ /* Allocate bitmaps for reaching definitions. */
bb_info->rd_kill = BITMAP_XMALLOC (); bb_info->rd_kill = BITMAP_ALLOC (NULL);
bb_info->rd_gen = BITMAP_XMALLOC (); bb_info->rd_gen = BITMAP_ALLOC (NULL);
bb_info->rd_in = BITMAP_XMALLOC (); bb_info->rd_in = BITMAP_ALLOC (NULL);
bb_info->rd_out = BITMAP_XMALLOC (); bb_info->rd_out = BITMAP_ALLOC (NULL);
} }
else else
{ {
@ -411,10 +411,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
if (!bb_info->ru_in) if (!bb_info->ru_in)
{ {
/* Allocate bitmaps for upward exposed uses. */ /* Allocate bitmaps for upward exposed uses. */
bb_info->ru_kill = BITMAP_XMALLOC (); bb_info->ru_kill = BITMAP_ALLOC (NULL);
bb_info->ru_gen = BITMAP_XMALLOC (); bb_info->ru_gen = BITMAP_ALLOC (NULL);
bb_info->ru_in = BITMAP_XMALLOC (); bb_info->ru_in = BITMAP_ALLOC (NULL);
bb_info->ru_out = BITMAP_XMALLOC (); bb_info->ru_out = BITMAP_ALLOC (NULL);
} }
else else
{ {
@ -430,10 +430,10 @@ df_bitmaps_alloc (struct df *df, bitmap blocks, int flags)
if (!bb_info->lr_in) if (!bb_info->lr_in)
{ {
/* Allocate bitmaps for live variables. */ /* Allocate bitmaps for live variables. */
bb_info->lr_def = BITMAP_XMALLOC (); bb_info->lr_def = BITMAP_ALLOC (NULL);
bb_info->lr_use = BITMAP_XMALLOC (); bb_info->lr_use = BITMAP_ALLOC (NULL);
bb_info->lr_in = BITMAP_XMALLOC (); bb_info->lr_in = BITMAP_ALLOC (NULL);
bb_info->lr_out = BITMAP_XMALLOC (); bb_info->lr_out = BITMAP_ALLOC (NULL);
} }
else else
{ {
@ -463,39 +463,39 @@ df_bitmaps_free (struct df *df, int flags)
if ((flags & DF_RD) && bb_info->rd_in) if ((flags & DF_RD) && bb_info->rd_in)
{ {
/* Free bitmaps for reaching definitions. */ /* Free bitmaps for reaching definitions. */
BITMAP_XFREE (bb_info->rd_kill); BITMAP_FREE (bb_info->rd_kill);
bb_info->rd_kill = NULL; bb_info->rd_kill = NULL;
BITMAP_XFREE (bb_info->rd_gen); BITMAP_FREE (bb_info->rd_gen);
bb_info->rd_gen = NULL; bb_info->rd_gen = NULL;
BITMAP_XFREE (bb_info->rd_in); BITMAP_FREE (bb_info->rd_in);
bb_info->rd_in = NULL; bb_info->rd_in = NULL;
BITMAP_XFREE (bb_info->rd_out); BITMAP_FREE (bb_info->rd_out);
bb_info->rd_out = NULL; bb_info->rd_out = NULL;
} }
if ((flags & DF_RU) && bb_info->ru_in) if ((flags & DF_RU) && bb_info->ru_in)
{ {
/* Free bitmaps for upward exposed uses. */ /* Free bitmaps for upward exposed uses. */
BITMAP_XFREE (bb_info->ru_kill); BITMAP_FREE (bb_info->ru_kill);
bb_info->ru_kill = NULL; bb_info->ru_kill = NULL;
BITMAP_XFREE (bb_info->ru_gen); BITMAP_FREE (bb_info->ru_gen);
bb_info->ru_gen = NULL; bb_info->ru_gen = NULL;
BITMAP_XFREE (bb_info->ru_in); BITMAP_FREE (bb_info->ru_in);
bb_info->ru_in = NULL; bb_info->ru_in = NULL;
BITMAP_XFREE (bb_info->ru_out); BITMAP_FREE (bb_info->ru_out);
bb_info->ru_out = NULL; bb_info->ru_out = NULL;
} }
if ((flags & DF_LR) && bb_info->lr_in) if ((flags & DF_LR) && bb_info->lr_in)
{ {
/* Free bitmaps for live variables. */ /* Free bitmaps for live variables. */
BITMAP_XFREE (bb_info->lr_def); BITMAP_FREE (bb_info->lr_def);
bb_info->lr_def = NULL; bb_info->lr_def = NULL;
BITMAP_XFREE (bb_info->lr_use); BITMAP_FREE (bb_info->lr_use);
bb_info->lr_use = NULL; bb_info->lr_use = NULL;
BITMAP_XFREE (bb_info->lr_in); BITMAP_FREE (bb_info->lr_in);
bb_info->lr_in = NULL; bb_info->lr_in = NULL;
BITMAP_XFREE (bb_info->lr_out); BITMAP_FREE (bb_info->lr_out);
bb_info->lr_out = NULL; 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_reg_table_realloc (df, df->n_regs);
df->bbs_modified = BITMAP_XMALLOC (); df->bbs_modified = BITMAP_ALLOC (NULL);
bitmap_zero (df->bbs_modified); bitmap_zero (df->bbs_modified);
df->flags = 0; df->flags = 0;
df->bbs = xcalloc (last_basic_block, sizeof (struct bb_info)); 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) FOR_EACH_BB (bb)
bitmap_set_bit (df->all_blocks, bb->index); bitmap_set_bit (df->all_blocks, bb->index);
} }
@ -583,13 +583,13 @@ df_free (struct df *df)
df->regs = 0; df->regs = 0;
df->reg_size = 0; df->reg_size = 0;
BITMAP_XFREE (df->bbs_modified); BITMAP_FREE (df->bbs_modified);
df->bbs_modified = 0; df->bbs_modified = 0;
BITMAP_XFREE (df->insns_modified); BITMAP_FREE (df->insns_modified);
df->insns_modified = 0; df->insns_modified = 0;
BITMAP_XFREE (df->all_blocks); BITMAP_FREE (df->all_blocks);
df->all_blocks = 0; df->all_blocks = 0;
free_alloc_pool (df_ref_pool); free_alloc_pool (df_ref_pool);
@ -1484,14 +1484,14 @@ df_du_chain_create (struct df *df, bitmap blocks)
bitmap ru; bitmap ru;
basic_block bb; basic_block bb;
ru = BITMAP_XMALLOC (); ru = BITMAP_ALLOC (NULL);
FOR_EACH_BB_IN_BITMAP (blocks, 0, bb, FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
{ {
df_bb_du_chain_create (df, bb, ru); 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); struct bb_info *bb_info = DF_BB_INFO (df, bb);
rtx insn; rtx insn;
bitmap seen = BITMAP_XMALLOC (); bitmap seen = BITMAP_ALLOC (NULL);
bool call_seen = false; bool call_seen = false;
FOR_BB_INSNS_REVERSE (bb, insn) 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) 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++) for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
{ {
if (!TEST_HARD_REG_BIT (regs_invalidated_by_call, 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) 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; basic_block bb;
bitmap live; bitmap live;
live = BITMAP_XMALLOC (); live = BITMAP_ALLOC (NULL);
FOR_EACH_BB_IN_BITMAP (blocks, 0, bb, FOR_EACH_BB_IN_BITMAP (blocks, 0, bb,
{ {
df_bb_reg_info_compute (df, bb, live); df_bb_reg_info_compute (df, bb, live);
}); });
BITMAP_XFREE (live); BITMAP_FREE (live);
} }

4
gcc/dominance.c
View File

@ -170,7 +170,7 @@ init_dom_info (struct dom_info *di, enum cdi_direction dir)
di->dfsnum = 1; di->dfsnum = 1;
di->nodes = 0; di->nodes = 0;
di->fake_exit_edge = dir ? BITMAP_XMALLOC () : NULL; di->fake_exit_edge = dir ? BITMAP_ALLOC (NULL) : NULL;
} }
#undef init_ar #undef init_ar
@ -191,7 +191,7 @@ free_dom_info (struct dom_info *di)
free (di->set_child); free (di->set_child);
free (di->dfs_order); free (di->dfs_order);
free (di->dfs_to_bb); 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 /* The nonrecursive variant of creating a DFS tree. DI is our working

8
gcc/flow.c
View File

@ -1826,12 +1826,12 @@ init_propagate_block_info (basic_block bb, regset live, regset local_set,
else else
pbi->reg_next_use = NULL; pbi->reg_next_use = NULL;
pbi->new_set = BITMAP_XMALLOC (); pbi->new_set = BITMAP_ALLOC (NULL);
#ifdef HAVE_conditional_execution #ifdef HAVE_conditional_execution
pbi->reg_cond_dead = splay_tree_new (splay_tree_compare_ints, NULL, pbi->reg_cond_dead = splay_tree_new (splay_tree_compare_ints, NULL,
free_reg_cond_life_info); 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 /* If this block ends in a conditional branch, for each register
live from one side of the branch and not the other, record the 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); free_EXPR_LIST_list (&pbi->mem_set_list);
BITMAP_XFREE (pbi->new_set); BITMAP_FREE (pbi->new_set);
#ifdef HAVE_conditional_execution #ifdef HAVE_conditional_execution
splay_tree_delete (pbi->reg_cond_dead); splay_tree_delete (pbi->reg_cond_dead);
BITMAP_XFREE (pbi->reg_cond_reg); BITMAP_FREE (pbi->reg_cond_reg);
#endif #endif
if (pbi->flags & PROP_REG_INFO) if (pbi->flags & PROP_REG_INFO)

12
gcc/gcse.c
View File

@ -962,7 +962,7 @@ alloc_gcse_mem (rtx f)
CUID_INSN (i++) = insn; CUID_INSN (i++) = insn;
/* Allocate vars to track sets of regs. */ /* 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. */ /* Allocate vars to track sets of regs, memory per block. */
reg_set_in_block = sbitmap_vector_alloc (last_basic_block, max_gcse_regno); reg_set_in_block = sbitmap_vector_alloc (last_basic_block, max_gcse_regno);
@ -970,8 +970,8 @@ alloc_gcse_mem (rtx f)
basic block. */ basic block. */
modify_mem_list = gcalloc (last_basic_block, sizeof (rtx)); modify_mem_list = gcalloc (last_basic_block, sizeof (rtx));
canon_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 (); modify_mem_list_set = BITMAP_ALLOC (NULL);
blocks_with_calls = BITMAP_XMALLOC (); blocks_with_calls = BITMAP_ALLOC (NULL);
} }
/* Free memory allocated by alloc_gcse_mem. */ /* Free memory allocated by alloc_gcse_mem. */
@ -982,12 +982,12 @@ free_gcse_mem (void)
free (uid_cuid); free (uid_cuid);
free (cuid_insn); free (cuid_insn);
BITMAP_XFREE (reg_set_bitmap); BITMAP_FREE (reg_set_bitmap);
sbitmap_vector_free (reg_set_in_block); sbitmap_vector_free (reg_set_in_block);
free_modify_mem_tables (); free_modify_mem_tables ();
BITMAP_XFREE (modify_mem_list_set); BITMAP_FREE (modify_mem_list_set);
BITMAP_XFREE (blocks_with_calls); BITMAP_FREE (blocks_with_calls);
} }
/* Compute the local properties of each recorded expression. /* Compute the local properties of each recorded expression.

32
gcc/global.c
View File

@ -2033,21 +2033,21 @@ allocate_bb_info (void)
bitmap init; bitmap init;
alloc_aux_for_blocks (sizeof (struct bb_info)); alloc_aux_for_blocks (sizeof (struct bb_info));
init = BITMAP_XMALLOC (); init = BITMAP_ALLOC (NULL);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
bitmap_set_bit (init, i); bitmap_set_bit (init, i);
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
{ {
bb_info = bb->aux; bb_info = bb->aux;
bb_info->earlyclobber = BITMAP_XMALLOC (); bb_info->earlyclobber = BITMAP_ALLOC (NULL);
bb_info->avloc = BITMAP_XMALLOC (); bb_info->avloc = BITMAP_ALLOC (NULL);
bb_info->killed = BITMAP_XMALLOC (); bb_info->killed = BITMAP_ALLOC (NULL);
bb_info->live_pavin = BITMAP_XMALLOC (); bb_info->live_pavin = BITMAP_ALLOC (NULL);
bb_info->live_pavout = BITMAP_XMALLOC (); bb_info->live_pavout = BITMAP_ALLOC (NULL);
bitmap_copy (bb_info->live_pavin, init); bitmap_copy (bb_info->live_pavin, init);
bitmap_copy (bb_info->live_pavout, init); bitmap_copy (bb_info->live_pavout, init);
} }
BITMAP_XFREE (init); BITMAP_FREE (init);
} }
/* The function frees the allocated info of all basic blocks. */ /* The function frees the allocated info of all basic blocks. */
@ -2061,11 +2061,11 @@ free_bb_info (void)
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
{ {
bb_info = BB_INFO (bb); bb_info = BB_INFO (bb);
BITMAP_XFREE (bb_info->live_pavout); BITMAP_FREE (bb_info->live_pavout);
BITMAP_XFREE (bb_info->live_pavin); BITMAP_FREE (bb_info->live_pavin);
BITMAP_XFREE (bb_info->killed); BITMAP_FREE (bb_info->killed);
BITMAP_XFREE (bb_info->avloc); BITMAP_FREE (bb_info->avloc);
BITMAP_XFREE (bb_info->earlyclobber); BITMAP_FREE (bb_info->earlyclobber);
} }
free_aux_for_blocks (); free_aux_for_blocks ();
} }
@ -2297,7 +2297,7 @@ calculate_reg_pav (void)
VARRAY_BB_INIT (bbs, n_basic_blocks, "basic blocks"); VARRAY_BB_INIT (bbs, n_basic_blocks, "basic blocks");
VARRAY_BB_INIT (new_bbs, n_basic_blocks, "basic blocks for the next iter."); 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) FOR_EACH_BB (bb)
{ {
VARRAY_PUSH_BB (bbs, bb); VARRAY_PUSH_BB (bbs, bb);
@ -2351,7 +2351,7 @@ calculate_reg_pav (void)
VARRAY_POP_ALL (new_bbs); VARRAY_POP_ALL (new_bbs);
} }
sbitmap_free (wset); sbitmap_free (wset);
BITMAP_XFREE (temp_bitmap); BITMAP_FREE (temp_bitmap);
} }
/* The function modifies partial availability information for two /* The function modifies partial availability information for two
@ -2373,7 +2373,7 @@ modify_reg_pav (void)
CLEAR_HARD_REG_SET (stack_hard_regs); CLEAR_HARD_REG_SET (stack_hard_regs);
for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++) for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
SET_HARD_REG_BIT(stack_hard_regs, 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++) for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
{ {
COPY_HARD_REG_SET (used, reg_class_contents[reg_preferred_class (i)]); COPY_HARD_REG_SET (used, reg_class_contents[reg_preferred_class (i)]);
@ -2405,7 +2405,7 @@ modify_reg_pav (void)
#endif #endif
} }
#ifdef STACK_REGS #ifdef STACK_REGS
BITMAP_XFREE (stack_regs); BITMAP_FREE (stack_regs);
#endif #endif
} }

26
gcc/loop-invariant.c
View File

@ -296,13 +296,13 @@ static void
find_defs (struct loop *loop, basic_block *body, struct df *df) find_defs (struct loop *loop, basic_block *body, struct df *df)
{ {
unsigned i; unsigned i;
bitmap blocks = BITMAP_XMALLOC (); bitmap blocks = BITMAP_ALLOC (NULL);
for (i = 0; i < loop->num_nodes; i++) for (i = 0; i < loop->num_nodes; i++)
bitmap_set_bit (blocks, body[i]->index); bitmap_set_bit (blocks, body[i]->index);
df_analyze_subcfg (df, blocks, DF_UD_CHAIN | DF_HARD_REGS | DF_EQUIV_NOTES); 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 /* 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; return;
} }
depends_on = BITMAP_XMALLOC (); depends_on = BITMAP_ALLOC (NULL);
if (!check_dependencies (insn, df, depends_on)) if (!check_dependencies (insn, df, depends_on))
{ {
BITMAP_XFREE (depends_on); BITMAP_FREE (depends_on);
return; return;
} }
@ -557,10 +557,10 @@ find_invariants_body (struct loop *loop, basic_block *body,
static void static void
find_invariants (struct loop *loop, struct df *df) find_invariants (struct loop *loop, struct df *df)
{ {
bitmap may_exit = BITMAP_XMALLOC (); bitmap may_exit = BITMAP_ALLOC (NULL);
bitmap always_reached = BITMAP_XMALLOC (); bitmap always_reached = BITMAP_ALLOC (NULL);
bitmap has_exit = BITMAP_XMALLOC (); bitmap has_exit = BITMAP_ALLOC (NULL);
bitmap always_executed = BITMAP_XMALLOC (); bitmap always_executed = BITMAP_ALLOC (NULL);
basic_block *body = get_loop_body_in_dom_order (loop); basic_block *body = get_loop_body_in_dom_order (loop);
find_exits (loop, body, may_exit, has_exit); 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_defs (loop, body, df);
find_invariants_body (loop, body, always_reached, always_executed, df); find_invariants_body (loop, body, always_reached, always_executed, df);
BITMAP_XFREE (always_reached); BITMAP_FREE (always_reached);
BITMAP_XFREE (always_executed); BITMAP_FREE (always_executed);
BITMAP_XFREE (may_exit); BITMAP_FREE (may_exit);
BITMAP_XFREE (has_exit); BITMAP_FREE (has_exit);
free (body); free (body);
} }
@ -863,7 +863,7 @@ free_inv_motion_data (struct df *df)
for (i = 0; i < VARRAY_ACTIVE_SIZE (invariants); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (invariants); i++)
{ {
inv = VARRAY_GENERIC_PTR_NOGC (invariants, i); inv = VARRAY_GENERIC_PTR_NOGC (invariants, i);
BITMAP_XFREE (inv->depends_on); BITMAP_FREE (inv->depends_on);
free (inv); free (inv);
} }
VARRAY_POP_ALL (invariants); VARRAY_POP_ALL (invariants);

8
gcc/predict.c
View File

@ -1043,9 +1043,9 @@ tree_predict_by_opcode (basic_block bb)
return; return;
op0 = TREE_OPERAND (cond, 0); op0 = TREE_OPERAND (cond, 0);
type = TREE_TYPE (op0); type = TREE_TYPE (op0);
visited = BITMAP_XMALLOC (); visited = BITMAP_ALLOC (NULL);
val = expr_expected_value (cond, visited); val = expr_expected_value (cond, visited);
BITMAP_XFREE (visited); BITMAP_FREE (visited);
if (val) if (val)
{ {
if (integer_zerop (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; EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->probability = REG_BR_PROB_BASE;
/* Set up block info for each basic block. */ /* 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_blocks (sizeof (struct block_info_def));
alloc_aux_for_edges (sizeof (struct edge_info_def)); alloc_aux_for_edges (sizeof (struct edge_info_def));
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb) 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_blocks ();
free_aux_for_edges (); free_aux_for_edges ();
BITMAP_XFREE (tovisit); BITMAP_FREE (tovisit);
} }
compute_function_frequency (); compute_function_frequency ();
if (flag_reorder_functions) if (flag_reorder_functions)

4
gcc/stmt.c
View File

@ -2359,7 +2359,7 @@ expand_case (tree exp)
uniq = 0; uniq = 0;
count = 0; count = 0;
label_bitmap = BITMAP_XMALLOC (); label_bitmap = BITMAP_ALLOC (NULL);
for (n = case_list; n; n = n->right) for (n = case_list; n; n = n->right)
{ {
/* Count the elements and track the largest and smallest /* 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 /* cleanup_tree_cfg removes all SWITCH_EXPR with a single
destination, such as one with a default case only. */ destination, such as one with a default case only. */

2
gcc/tree-cfg.c
View File

@ -5079,7 +5079,7 @@ tree_duplicate_sese_region (edge entry, edge exit,
free (region_copy); free (region_copy);
unmark_all_for_rewrite (); unmark_all_for_rewrite ();
BITMAP_XFREE (definitions); BITMAP_FREE (definitions);
return true; return true;
} }

4
gcc/tree-dfa.c
View File

@ -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_may_defs_before, v_may_defs_after;
int v_must_defs_before, v_must_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 /* Before re-scanning the statement for operands, mark the existing
virtual operands to be renamed again. We do this because when new 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) || v_must_defs_before > v_must_defs_after)
bitmap_ior_into (vars_to_rename, vars_in_vops_to_rename); 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 /* Find all variables within the gimplified statement that were not previously

6
gcc/tree-if-conv.c
View File

@ -1017,7 +1017,7 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
gcc_assert (loop->latch != EXIT_BLOCK_PTR); gcc_assert (loop->latch != EXIT_BLOCK_PTR);
blocks = xcalloc (loop->num_nodes, sizeof (basic_block)); 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); 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) if (bb->flags & BB_IRREDUCIBLE_LOOP)
{ {
free (blocks_in_bfs_order); free (blocks_in_bfs_order);
BITMAP_XFREE (visited); BITMAP_FREE (visited);
free (blocks); free (blocks);
return NULL; return NULL;
} }
@ -1052,7 +1052,7 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
} }
} }
free (blocks_in_bfs_order); free (blocks_in_bfs_order);
BITMAP_XFREE (visited); BITMAP_FREE (visited);
return blocks; return blocks;
} }

34
gcc/tree-into-ssa.c
View File

@ -1023,7 +1023,7 @@ insert_phi_nodes_for (tree var, bitmap *dfs, VEC(basic_block) **work_stack)
if (def_map == NULL) if (def_map == NULL)
return; 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) 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 /* SSA Rewriting Step 2. Rewrite every variable used in each statement in
@ -1311,9 +1311,9 @@ static void
def_blocks_free (void *p) def_blocks_free (void *p)
{ {
struct def_blocks_d *entry = p; struct def_blocks_d *entry = p;
BITMAP_XFREE (entry->def_blocks); BITMAP_FREE (entry->def_blocks);
BITMAP_XFREE (entry->phi_blocks); BITMAP_FREE (entry->phi_blocks);
BITMAP_XFREE (entry->livein_blocks); BITMAP_FREE (entry->livein_blocks);
free (entry); free (entry);
} }
@ -1371,9 +1371,9 @@ get_def_blocks_for (tree var)
{ {
db_p = xmalloc (sizeof (*db_p)); db_p = xmalloc (sizeof (*db_p));
db_p->var = var; db_p->var = var;
db_p->def_blocks = BITMAP_XMALLOC (); db_p->def_blocks = BITMAP_ALLOC (NULL);
db_p->phi_blocks = BITMAP_XMALLOC (); db_p->phi_blocks = BITMAP_ALLOC (NULL);
db_p->livein_blocks = BITMAP_XMALLOC (); db_p->livein_blocks = BITMAP_ALLOC (NULL);
*slot = (void *) db_p; *slot = (void *) db_p;
} }
else else
@ -1521,7 +1521,7 @@ mark_def_site_blocks (void)
/* Notice that this bitmap is indexed using variable UIDs, so it must be /* Notice that this bitmap is indexed using variable UIDs, so it must be
large enough to accommodate all the variables referenced in the large enough to accommodate all the variables referenced in the
function, not just the ones we are renaming. */ 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; walk_data.global_data = &mark_def_sites_global_data;
/* We do not have any local data. */ /* We do not have any local data. */
@ -1537,7 +1537,7 @@ mark_def_site_blocks (void)
fini_walk_dominator_tree (&walk_data); fini_walk_dominator_tree (&walk_data);
/* We no longer need this bitmap, clear and free it. */ /* 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. */ can save significant time during PHI insertion for large graphs. */
dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *)); dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *));
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
dfs[bb->index] = BITMAP_XMALLOC (); dfs[bb->index] = BITMAP_ALLOC (NULL);
/* Compute dominance frontiers. */ /* Compute dominance frontiers. */
compute_dominance_frontiers (dfs); compute_dominance_frontiers (dfs);
@ -1620,7 +1620,7 @@ rewrite_into_ssa (bool all)
/* Free allocated memory. */ /* Free allocated memory. */
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
BITMAP_XFREE (dfs[bb->index]); BITMAP_FREE (dfs[bb->index]);
free (dfs); free (dfs);
vars_to_rename = old_vars_to_rename; 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. */ can save significant time during PHI insertion for large graphs. */
dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *)); dfs = (bitmap *) xmalloc (last_basic_block * sizeof (bitmap *));
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
dfs[bb->index] = BITMAP_XMALLOC (); dfs[bb->index] = BITMAP_ALLOC (NULL);
/* Ensure that the dominance information is OK. */ /* Ensure that the dominance information is OK. */
calculate_dominance_info (CDI_DOMINATORS); calculate_dominance_info (CDI_DOMINATORS);
@ -1698,7 +1698,7 @@ rewrite_ssa_into_ssa (void)
set_current_def (ssa_name (i), NULL_TREE); 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; mark_def_sites_global_data.names_to_rename = snames_to_rename;
walk_data.global_data = &mark_def_sites_global_data; walk_data.global_data = &mark_def_sites_global_data;
@ -1717,7 +1717,7 @@ rewrite_ssa_into_ssa (void)
fini_walk_dominator_tree (&walk_data); fini_walk_dominator_tree (&walk_data);
/* We no longer need this bitmap, clear and free it. */ /* 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 at dominance frontiers of definition blocks. */
insert_phi_nodes (dfs, to_rename); insert_phi_nodes (dfs, to_rename);
@ -1773,7 +1773,7 @@ rewrite_ssa_into_ssa (void)
/* Free allocated memory. */ /* Free allocated memory. */
FOR_EACH_BB (bb) FOR_EACH_BB (bb)
BITMAP_XFREE (dfs[bb->index]); BITMAP_FREE (dfs[bb->index]);
free (dfs); free (dfs);
htab_delete (def_blocks); htab_delete (def_blocks);
@ -1789,7 +1789,7 @@ rewrite_ssa_into_ssa (void)
} }
#endif #endif
BITMAP_XFREE (to_rename); BITMAP_FREE (to_rename);
VEC_free (tree_on_heap, block_defs_stack); VEC_free (tree_on_heap, block_defs_stack);
block_defs_stack = NULL; block_defs_stack = NULL;

2
gcc/tree-optimize.c
View File

@ -664,7 +664,7 @@ tree_rest_of_compilation (tree fndecl)
bitmap_obstack_initialize (NULL); bitmap_obstack_initialize (NULL);
bitmap_obstack_initialize (&reg_obstack); /* FIXME, only at RTL generation*/ 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. */ /* Perform all tree transforms and optimizations. */
execute_pass_list (all_passes); execute_pass_list (all_passes);

12
gcc/tree-outof-ssa.c
View File

@ -1260,8 +1260,8 @@ new_temp_expr_table (var_map map)
t->partition_dep_list = xcalloc (num_var_partitions (map) + 1, t->partition_dep_list = xcalloc (num_var_partitions (map) + 1,
sizeof (value_expr_p)); sizeof (value_expr_p));
t->replaceable = BITMAP_XMALLOC (); t->replaceable = BITMAP_ALLOC (NULL);
t->partition_in_use = BITMAP_XMALLOC (); t->partition_in_use = BITMAP_ALLOC (NULL);
t->saw_replaceable = false; t->saw_replaceable = false;
t->virtual_partition = num_var_partitions (map); t->virtual_partition = num_var_partitions (map);
@ -1293,8 +1293,8 @@ free_temp_expr_table (temp_expr_table_p t)
free (p); free (p);
} }
BITMAP_XFREE (t->partition_in_use); BITMAP_FREE (t->partition_in_use);
BITMAP_XFREE (t->replaceable); BITMAP_FREE (t->replaceable);
free (t->partition_dep_list); free (t->partition_dep_list);
if (t->saw_replaceable) 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_EDGE_INIT (edge_leader, 25, "edge_leader");
VARRAY_TREE_INIT (stmt_list, 25, "stmt_list"); VARRAY_TREE_INIT (stmt_list, 25, "stmt_list");
leader_has_match = BITMAP_XMALLOC (); leader_has_match = BITMAP_ALLOC (NULL);
} }
else else
{ {
@ -2261,7 +2261,7 @@ perform_edge_inserts (FILE *dump_file)
/* Clear out any tables which were created. */ /* Clear out any tables which were created. */
edge_leader = NULL; edge_leader = NULL;
BITMAP_XFREE (leader_has_match); BITMAP_FREE (leader_has_match);
if (changed) if (changed)
{ {

4
gcc/tree-scalar-evolution.c
View File

@ -2466,7 +2466,7 @@ scev_initialize (struct loops *loops)
scalar_evolution_info = htab_create (100, hash_scev_info, scalar_evolution_info = htab_create (100, hash_scev_info,
eq_scev_info, del_scev_info); eq_scev_info, del_scev_info);
already_instantiated = BITMAP_XMALLOC (); already_instantiated = BITMAP_ALLOC (NULL);
initialize_scalar_evolutions_analyzer (); initialize_scalar_evolutions_analyzer ();
@ -2561,6 +2561,6 @@ void
scev_finalize (void) scev_finalize (void)
{ {
htab_delete (scalar_evolution_info); htab_delete (scalar_evolution_info);
BITMAP_XFREE (already_instantiated); BITMAP_FREE (already_instantiated);
} }

16
gcc/tree-sra.c
View File

@ -2079,10 +2079,10 @@ tree_sra (void)
{ {
/* Initialize local variables. */ /* Initialize local variables. */
gcc_obstack_init (&sra_obstack); gcc_obstack_init (&sra_obstack);
sra_candidates = BITMAP_XMALLOC (); sra_candidates = BITMAP_ALLOC (NULL);
needs_copy_in = BITMAP_XMALLOC (); needs_copy_in = BITMAP_ALLOC (NULL);
sra_type_decomp_cache = BITMAP_XMALLOC (); sra_type_decomp_cache = BITMAP_ALLOC (NULL);
sra_type_inst_cache = BITMAP_XMALLOC (); sra_type_inst_cache = BITMAP_ALLOC (NULL);
sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL); sra_map = htab_create (101, sra_elt_hash, sra_elt_eq, NULL);
/* Scan. If we find anything, instantiate and scalarize. */ /* Scan. If we find anything, instantiate and scalarize. */
@ -2096,10 +2096,10 @@ tree_sra (void)
/* Free allocated memory. */ /* Free allocated memory. */
htab_delete (sra_map); htab_delete (sra_map);
sra_map = NULL; sra_map = NULL;
BITMAP_XFREE (sra_candidates); BITMAP_FREE (sra_candidates);
BITMAP_XFREE (needs_copy_in); BITMAP_FREE (needs_copy_in);
BITMAP_XFREE (sra_type_decomp_cache); BITMAP_FREE (sra_type_decomp_cache);
BITMAP_XFREE (sra_type_inst_cache); BITMAP_FREE (sra_type_inst_cache);
obstack_free (&sra_obstack, NULL); obstack_free (&sra_obstack, NULL);
} }

16
gcc/tree-ssa-alias.c
View File

@ -534,11 +534,11 @@ init_alias_info (void)
ai->ssa_names_visited = sbitmap_alloc (num_ssa_names); ai->ssa_names_visited = sbitmap_alloc (num_ssa_names);
sbitmap_zero (ai->ssa_names_visited); sbitmap_zero (ai->ssa_names_visited);
VARRAY_TREE_INIT (ai->processed_ptrs, 50, "processed_ptrs"); 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"); VARRAY_UINT_INIT (ai->num_references, num_referenced_vars, "num_references");
ai->written_vars = BITMAP_XMALLOC (); ai->written_vars = BITMAP_ALLOC (NULL);
ai->dereferenced_ptrs_store = BITMAP_XMALLOC (); ai->dereferenced_ptrs_store = BITMAP_ALLOC (NULL);
ai->dereferenced_ptrs_load = BITMAP_XMALLOC (); ai->dereferenced_ptrs_load = BITMAP_ALLOC (NULL);
/* If aliases have been computed before, clear existing information. */ /* If aliases have been computed before, clear existing information. */
if (aliases_computed_p) if (aliases_computed_p)
@ -626,7 +626,7 @@ delete_alias_info (struct alias_info *ai)
sbitmap_free (ai->ssa_names_visited); sbitmap_free (ai->ssa_names_visited);
ai->processed_ptrs = NULL; ai->processed_ptrs = NULL;
BITMAP_XFREE (ai->addresses_needed); BITMAP_FREE (ai->addresses_needed);
for (i = 0; i < ai->num_addressable_vars; i++) for (i = 0; i < ai->num_addressable_vars; i++)
{ {
@ -643,9 +643,9 @@ delete_alias_info (struct alias_info *ai)
free (ai->pointers); free (ai->pointers);
ai->num_references = NULL; ai->num_references = NULL;
BITMAP_XFREE (ai->written_vars); BITMAP_FREE (ai->written_vars);
BITMAP_XFREE (ai->dereferenced_ptrs_store); BITMAP_FREE (ai->dereferenced_ptrs_store);
BITMAP_XFREE (ai->dereferenced_ptrs_load); BITMAP_FREE (ai->dereferenced_ptrs_load);
free (ai); free (ai);
} }

4
gcc/tree-ssa-ccp.c
View File

@ -1961,7 +1961,7 @@ ccp_fold_builtin (tree stmt, tree fn)
} }
/* Try to use the dataflow information gathered by the CCP process. */ /* 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)); memset (strlen_val, 0, sizeof (strlen_val));
for (i = 0, a = arglist; for (i = 0, a = arglist;
@ -1974,7 +1974,7 @@ ccp_fold_builtin (tree stmt, tree fn)
strlen_val[i] = NULL_TREE; strlen_val[i] = NULL_TREE;
} }
BITMAP_XFREE (visited); BITMAP_FREE (visited);
result = NULL_TREE; result = NULL_TREE;
switch (DECL_FUNCTION_CODE (callee)) switch (DECL_FUNCTION_CODE (callee))

4
gcc/tree-ssa-dce.c
View File

@ -879,7 +879,7 @@ tree_dce_init (bool aggressive)
control_dependence_map control_dependence_map
= xmalloc (last_basic_block * sizeof (bitmap)); = xmalloc (last_basic_block * sizeof (bitmap));
for (i = 0; i < last_basic_block; ++i) 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); last_stmt_necessary = sbitmap_alloc (last_basic_block);
sbitmap_zero (last_stmt_necessary); sbitmap_zero (last_stmt_necessary);
@ -901,7 +901,7 @@ tree_dce_done (bool aggressive)
int i; int i;
for (i = 0; i < last_basic_block; ++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); free (control_dependence_map);
sbitmap_free (visited_control_parents); sbitmap_free (visited_control_parents);

8
gcc/tree-ssa-dom.c
View File

@ -383,8 +383,8 @@ tree_ssa_dominator_optimize (void)
nonzero_vars_stack = VEC_alloc (tree_on_heap, 20); nonzero_vars_stack = VEC_alloc (tree_on_heap, 20);
vrp_variables_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); stmts_to_rescan = VEC_alloc (tree_on_heap, 20);
nonzero_vars = BITMAP_XMALLOC (); nonzero_vars = BITMAP_ALLOC (NULL);
need_eh_cleanup = BITMAP_XMALLOC (); need_eh_cleanup = BITMAP_ALLOC (NULL);
/* Setup callbacks for the generic dominator tree walker. */ /* Setup callbacks for the generic dominator tree walker. */
walk_data.walk_stmts_backward = false; walk_data.walk_stmts_backward = false;
@ -497,8 +497,8 @@ tree_ssa_dominator_optimize (void)
fini_walk_dominator_tree (&walk_data); fini_walk_dominator_tree (&walk_data);
/* Free nonzero_vars. */ /* Free nonzero_vars. */
BITMAP_XFREE (nonzero_vars); BITMAP_FREE (nonzero_vars);
BITMAP_XFREE (need_eh_cleanup); BITMAP_FREE (need_eh_cleanup);
VEC_free (tree_on_heap, block_defs_stack); VEC_free (tree_on_heap, block_defs_stack);
VEC_free (tree_on_heap, avail_exprs_stack); VEC_free (tree_on_heap, avail_exprs_stack);

4
gcc/tree-ssa-dse.c
View File

@ -433,7 +433,7 @@ tree_ssa_dse (void)
walk_data.block_local_data_size = sizeof (struct dse_block_local_data); walk_data.block_local_data_size = sizeof (struct dse_block_local_data);
/* This is the main hash table for the dead store elimination pass. */ /* 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; walk_data.global_data = &dse_gd;
/* Initialize the dominator walker. */ /* Initialize the dominator walker. */
@ -446,7 +446,7 @@ tree_ssa_dse (void)
fini_walk_dominator_tree (&walk_data); fini_walk_dominator_tree (&walk_data);
/* Release the main bitmap. */ /* 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 dataflow information. It's probably out of date now anyway. */
free_df (); free_df ();

4
gcc/tree-ssa-forwprop.c
View File

@ -480,7 +480,7 @@ tree_ssa_forward_propagate_single_use_vars (void)
basic_block bb; basic_block bb;
varray_type vars_worklist, cond_worklist; varray_type vars_worklist, cond_worklist;
vars = BITMAP_XMALLOC (); vars = BITMAP_ALLOC (NULL);
VARRAY_TREE_INIT (vars_worklist, 10, "VARS worklist"); VARRAY_TREE_INIT (vars_worklist, 10, "VARS worklist");
VARRAY_TREE_INIT (cond_worklist, 10, "COND 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. */ /* All done. Clean up. */
BITMAP_XFREE (vars); BITMAP_FREE (vars);
} }

20
gcc/tree-ssa-live.c
View File

@ -439,11 +439,11 @@ new_tree_live_info (var_map map)
live->map = map; live->map = map;
live->num_blocks = last_basic_block; 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)); live->livein = (bitmap *)xmalloc (num_var_partitions (map) * sizeof (bitmap));
for (x = 0; x < num_var_partitions (map); x++) 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. */ /* liveout is deferred until it is actually requested. */
live->liveout = NULL; live->liveout = NULL;
@ -460,17 +460,17 @@ delete_tree_live_info (tree_live_info_p live)
if (live->liveout) if (live->liveout)
{ {
for (x = live->num_blocks - 1; x >= 0; x--) for (x = live->num_blocks - 1; x >= 0; x--)
BITMAP_XFREE (live->liveout[x]); BITMAP_FREE (live->liveout[x]);
free (live->liveout); free (live->liveout);
} }
if (live->livein) if (live->livein)
{ {
for (x = num_var_partitions (live->map) - 1; x >= 0; x--) for (x = num_var_partitions (live->map) - 1; x >= 0; x--)
BITMAP_XFREE (live->livein[x]); BITMAP_FREE (live->livein[x]);
free (live->livein); free (live->livein);
} }
if (live->global) if (live->global)
BITMAP_XFREE (live->global); BITMAP_FREE (live->global);
free (live); free (live);
} }
@ -573,7 +573,7 @@ calculate_live_on_entry (var_map map)
edge_iterator ei; edge_iterator ei;
#endif #endif
saw_def = BITMAP_XMALLOC (); saw_def = BITMAP_ALLOC (NULL);
live = new_tree_live_info (map); live = new_tree_live_info (map);
@ -720,7 +720,7 @@ calculate_live_on_entry (var_map map)
gcc_assert (num <= 0); gcc_assert (num <= 0);
#endif #endif
BITMAP_XFREE (saw_def); BITMAP_FREE (saw_def);
return live; return live;
} }
@ -742,7 +742,7 @@ calculate_live_on_exit (tree_live_info_p liveinfo)
on_exit = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap)); on_exit = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap));
for (x = 0; x < (unsigned)last_basic_block; x++) 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. */ /* Set all the live-on-exit bits for uses in PHIs. */
FOR_EACH_BB (bb) 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) if (tpa_num_trees (tpa) == 0)
return graph; return graph;
live = BITMAP_XMALLOC (); live = BITMAP_ALLOC (NULL);
VARRAY_INT_INIT (partition_link, num_var_partitions (map) + 1, "part_link"); VARRAY_INT_INIT (partition_link, num_var_partitions (map) + 1, "part_link");
VARRAY_INT_INIT (tpa_nodes, tpa_num_trees (tpa), "tpa nodes"); 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); VARRAY_POP_ALL (tpa_to_clear);
} }
BITMAP_XFREE (live); BITMAP_FREE (live);
return graph; return graph;
} }

28
gcc/tree-ssa-loop-ivopts.c
View File

@ -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_size = 2 * num_ssa_names;
data->version_info = xcalloc (data->version_info_size, data->version_info = xcalloc (data->version_info_size,
sizeof (struct version_info)); sizeof (struct version_info));
data->relevant = BITMAP_XMALLOC (); data->relevant = BITMAP_ALLOC (NULL);
data->important_candidates = BITMAP_XMALLOC (); data->important_candidates = BITMAP_ALLOC (NULL);
data->max_inv_id = 0; data->max_inv_id = 0;
data->niters = htab_create (10, nfe_hash, nfe_eq, free); 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->iv = iv;
use->stmt = stmt; use->stmt = stmt;
use->op_p = use_p; 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 /* To avoid showing ssa name in the dumps, if it was not reset by the
caller. */ caller. */
@ -2184,7 +2184,7 @@ record_important_candidates (struct ivopts_data *data)
for (i = 0; i < n_iv_uses (data); i++) for (i = 0; i < n_iv_uses (data); i++)
{ {
use = iv_use (data, i); use = iv_use (data, i);
BITMAP_XFREE (use->related_cands); BITMAP_FREE (use->related_cands);
} }
} }
else else
@ -2260,7 +2260,7 @@ set_use_iv_cost (struct ivopts_data *data,
if (cost == INFTY) if (cost == INFTY)
{ {
BITMAP_XFREE (depends_on); BITMAP_FREE (depends_on);
return; return;
} }
@ -2827,7 +2827,7 @@ find_depends (tree *expr_p, int *ws ATTRIBUTE_UNUSED, void *data)
return NULL_TREE; return NULL_TREE;
if (!*depends_on) if (!*depends_on)
*depends_on = BITMAP_XMALLOC (); *depends_on = BITMAP_ALLOC (NULL);
bitmap_set_bit (*depends_on, info->inv_id); bitmap_set_bit (*depends_on, info->inv_id);
return NULL_TREE; return NULL_TREE;
@ -3589,7 +3589,7 @@ determine_use_iv_costs (struct ivopts_data *data)
unsigned i, j; unsigned i, j;
struct iv_use *use; struct iv_use *use;
struct iv_cand *cand; struct iv_cand *cand;
bitmap to_clear = BITMAP_XMALLOC (); bitmap to_clear = BITMAP_ALLOC (NULL);
alloc_use_cost_map (data); 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)) if (dump_file && (dump_flags & TDF_DETAILS))
{ {
@ -4134,7 +4134,7 @@ iv_ca_new (struct ivopts_data *data)
nw->bad_uses = 0; nw->bad_uses = 0;
nw->cand_for_use = xcalloc (n_iv_uses (data), sizeof (struct cost_pair *)); 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->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_cands = 0;
nw->n_regs = 0; nw->n_regs = 0;
nw->cand_use_cost = 0; nw->cand_use_cost = 0;
@ -4152,7 +4152,7 @@ iv_ca_free (struct iv_ca **ivs)
{ {
free ((*ivs)->cand_for_use); free ((*ivs)->cand_for_use);
free ((*ivs)->n_cand_uses); free ((*ivs)->n_cand_uses);
BITMAP_XFREE ((*ivs)->cands); BITMAP_FREE ((*ivs)->cands);
free ((*ivs)->n_invariant_uses); free ((*ivs)->n_invariant_uses);
free (*ivs); free (*ivs);
*ivs = NULL; *ivs = NULL;
@ -5192,10 +5192,10 @@ free_loop_data (struct ivopts_data *data)
struct iv_use *use = iv_use (data, i); struct iv_use *use = iv_use (data, i);
free (use->iv); free (use->iv);
BITMAP_XFREE (use->related_cands); BITMAP_FREE (use->related_cands);
for (j = 0; j < use->n_map_members; j++) for (j = 0; j < use->n_map_members; j++)
if (use->cost_map[j].depends_on) 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->cost_map);
free (use); free (use);
} }
@ -5247,8 +5247,8 @@ tree_ssa_iv_optimize_finalize (struct loops *loops, struct ivopts_data *data)
free_loop_data (data); free_loop_data (data);
free (data->version_info); free (data->version_info);
BITMAP_XFREE (data->relevant); BITMAP_FREE (data->relevant);
BITMAP_XFREE (data->important_candidates); BITMAP_FREE (data->important_candidates);
htab_delete (data->niters); htab_delete (data->niters);
VARRAY_FREE (decl_rtl_to_reset); VARRAY_FREE (decl_rtl_to_reset);

16
gcc/tree-ssa-loop-manip.c
View File

@ -159,10 +159,10 @@ add_exit_phis_var (tree var, bitmap livein, bitmap exits)
bitmap_clear_bit (livein, def_bb->index); bitmap_clear_bit (livein, def_bb->index);
def = BITMAP_XMALLOC (); def = BITMAP_ALLOC (NULL);
bitmap_set_bit (def, def_bb->index); bitmap_set_bit (def, def_bb->index);
compute_global_livein (livein, def); compute_global_livein (livein, def);
BITMAP_XFREE (def); BITMAP_FREE (def);
EXECUTE_IF_AND_IN_BITMAP (exits, livein, 0, index, bi) 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 static bitmap
get_loops_exits (void) get_loops_exits (void)
{ {
bitmap exits = BITMAP_XMALLOC (); bitmap exits = BITMAP_ALLOC (NULL);
basic_block bb; basic_block bb;
edge e; edge e;
edge_iterator ei; edge_iterator ei;
@ -235,7 +235,7 @@ find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks)
return; return;
if (!use_blocks[ver]) if (!use_blocks[ver])
use_blocks[ver] = BITMAP_XMALLOC (); use_blocks[ver] = BITMAP_ALLOC (NULL);
bitmap_set_bit (use_blocks[ver], bb->index); bitmap_set_bit (use_blocks[ver], bb->index);
if (!flow_bb_inside_loop_p (def_loop, bb)) 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); add_exit_phis (names_to_rename, use_blocks, loop_exits);
for (i = 0; i < num_ssa_names; i++) for (i = 0; i < num_ssa_names; i++)
BITMAP_XFREE (use_blocks[i]); BITMAP_FREE (use_blocks[i]);
free (use_blocks); free (use_blocks);
BITMAP_XFREE (loop_exits); BITMAP_FREE (loop_exits);
BITMAP_XFREE (names_to_rename); BITMAP_FREE (names_to_rename);
/* Do the rewriting. */ /* Do the rewriting. */
rewrite_ssa_into_ssa (); rewrite_ssa_into_ssa ();
@ -618,7 +618,7 @@ tree_duplicate_loop_to_header_edge (struct loop *loop, edge e,
definitions = marked_ssa_names (); definitions = marked_ssa_names ();
rename_variables (first_new_block, definitions); rename_variables (first_new_block, definitions);
unmark_all_for_rewrite (); unmark_all_for_rewrite ();
BITMAP_XFREE (definitions); BITMAP_FREE (definitions);
/* For some time we have the identical ssa names as results in multiple phi /* 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 nodes. When phi node is resized, it sets SSA_NAME_DEF_STMT of its result

4
gcc/tree-ssa-pre.c
View File

@ -2170,7 +2170,7 @@ init_pre (bool do_fre)
AVAIL_OUT (bb) = bitmap_set_new (); 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 (); cleanup_tree_cfg ();
} }
BITMAP_XFREE (need_eh_cleanup); BITMAP_FREE (need_eh_cleanup);
/* Wipe out pointers to VALUE_HANDLEs. In the not terribly distant /* Wipe out pointers to VALUE_HANDLEs. In the not terribly distant
future we will want them to be persistent though. */ future we will want them to be persistent though. */

18
gcc/tree-ssa.c
View File

@ -341,7 +341,7 @@ verify_flow_insensitive_alias_info (void)
{ {
size_t i; size_t i;
tree var; tree var;
bitmap visited = BITMAP_XMALLOC (); bitmap visited = BITMAP_ALLOC (NULL);
for (i = 0; i < num_referenced_vars; i++) 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; return;
err: err:
@ -480,7 +480,7 @@ verify_name_tags (void)
bitmap first, second; bitmap first, second;
VEC (tree) *name_tag_reps = NULL; VEC (tree) *name_tag_reps = NULL;
VEC (bitmap) *pt_vars_for_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. */ /* First we compute the name tag representatives and their points-to sets. */
for (i = 0; i < num_ssa_names; i++) for (i = 0; i < num_ssa_names; i++)
@ -604,7 +604,7 @@ verify_ssa (void)
ssa_op_iter iter; ssa_op_iter iter;
tree op; tree op;
enum dom_state orig_dom_state = dom_computed[CDI_DOMINATORS]; 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); timevar_push (TV_TREE_SSA_VERIFY);
@ -702,7 +702,7 @@ verify_ssa (void)
else else
dom_computed[CDI_DOMINATORS] = orig_dom_state; 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); timevar_pop (TV_TREE_SSA_VERIFY);
return; return;
@ -717,8 +717,8 @@ void
init_tree_ssa (void) init_tree_ssa (void)
{ {
VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars"); VARRAY_TREE_INIT (referenced_vars, 20, "referenced_vars");
call_clobbered_vars = BITMAP_XMALLOC (); call_clobbered_vars = BITMAP_ALLOC (NULL);
addressable_vars = BITMAP_XMALLOC (); addressable_vars = BITMAP_ALLOC (NULL);
init_ssa_operands (); init_ssa_operands ();
init_ssanames (); init_ssanames ();
init_phinodes (); init_phinodes ();
@ -762,9 +762,9 @@ delete_tree_ssa (void)
fini_ssa_operands (); fini_ssa_operands ();
global_var = NULL_TREE; global_var = NULL_TREE;
BITMAP_XFREE (call_clobbered_vars); BITMAP_FREE (call_clobbered_vars);
call_clobbered_vars = NULL; call_clobbered_vars = NULL;
BITMAP_XFREE (addressable_vars); BITMAP_FREE (addressable_vars);
addressable_vars = NULL; addressable_vars = NULL;
modified_noreturn_calls = NULL; modified_noreturn_calls = NULL;
} }

6
gcc/tree-ssanames.c
View File

@ -118,7 +118,7 @@ unmark_all_for_rewrite (void)
bitmap bitmap
marked_ssa_names (void) marked_ssa_names (void)
{ {
bitmap ret = BITMAP_XMALLOC (); bitmap ret = BITMAP_ALLOC (NULL);
bitmap_copy (ret, ssa_names_to_rewrite); bitmap_copy (ret, ssa_names_to_rewrite);
@ -138,7 +138,7 @@ init_ssanames (void)
large. */ large. */
VARRAY_PUSH_TREE (ssa_names, NULL_TREE); VARRAY_PUSH_TREE (ssa_names, NULL_TREE);
free_ssanames = NULL; free_ssanames = NULL;
ssa_names_to_rewrite = BITMAP_XMALLOC (); ssa_names_to_rewrite = BITMAP_ALLOC (NULL);
} }
/* Finalize management of SSA_NAMEs. */ /* Finalize management of SSA_NAMEs. */
@ -146,7 +146,7 @@ init_ssanames (void)
void void
fini_ssanames (void) fini_ssanames (void)
{ {
BITMAP_XFREE (ssa_names_to_rewrite); BITMAP_FREE (ssa_names_to_rewrite);
ggc_free (ssa_names); ggc_free (ssa_names);
ssa_names = NULL; ssa_names = NULL;
free_ssanames = NULL; free_ssanames = NULL;

2
gcc/tree-vectorizer.c
View File

@ -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); slpeel_make_loop_iterate_ntimes (first_loop, first_niters);
free_new_names (definitions); free_new_names (definitions);
BITMAP_XFREE (definitions); BITMAP_FREE (definitions);
unmark_all_for_rewrite (); unmark_all_for_rewrite ();
return new_loop; return new_loop;