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