OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source 
* 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>
* 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 ();
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);
}

6
gcc/bitmap.h
View File

@ -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

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;
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);

6
gcc/cfgcleanup.c
View File

@ -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;
}

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);
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;
}

76
gcc/df.c
View File

@ -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);
}

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->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

8
gcc/flow.c
View File

@ -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)

12
gcc/gcse.c
View File

@ -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.

32
gcc/global.c
View File

@ -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
}

26
gcc/loop-invariant.c
View File

@ -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);

8
gcc/predict.c
View File

@ -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)

4
gcc/stmt.c
View File

@ -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. */

2
gcc/tree-cfg.c
View File

@ -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;
}

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_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

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);
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;
}

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)
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;

2
gcc/tree-optimize.c
View File

@ -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);

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,
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)
{

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,
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);
}

16
gcc/tree-sra.c
View File

@ -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);
}

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);
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);
}

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. */
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))

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

@ -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);

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);
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);

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);
/* 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 ();

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

@ -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);
}

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

@ -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;
}

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 = 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);

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);
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

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

@ -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. */

18
gcc/tree-ssa.c
View File

@ -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;
}

6
gcc/tree-ssanames.c
View File

@ -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;

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);
free_new_names (definitions);
BITMAP_XFREE (definitions);
BITMAP_FREE (definitions);
unmark_all_for_rewrite ();
return new_loop;