From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 113073 invoked by alias); 10 May 2017 08:27:58 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 113062 invoked by uid 89); 10 May 2017 08:27:57 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-24.3 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,RCVD_IN_DNSWL_NONE,RCVD_IN_SORBS_SPAM,SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-oi0-f66.google.com Received: from mail-oi0-f66.google.com (HELO mail-oi0-f66.google.com) (209.85.218.66) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 10 May 2017 08:27:52 +0000 Received: by mail-oi0-f66.google.com with SMTP id m17so3942274oik.2 for ; Wed, 10 May 2017 01:27:55 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc; bh=7GP0EnIt3ctYXLQcAQyIqq5CDMy/5XQI/guL9NkVQqY=; b=kfWUj9/xvj7KEQU0B0HnXH9dhvpLU+MqcTatLQkmiL1HZoBHEBp4wJwB9693qmJQwy yKlGZtkUDKgOd9fmUSVMjAhytIYJTMq4aEsU7/baTRJLiI2VGu9HpfDMpqvYJZxdgwKD hloeZ7rGIPzhbDdsO55n/nHE0jy1ivAfJKyYqgH5dkJTTAe7wkj/kcf6DDE4kxRzYGbK WJru6VuQnSjvoQ6+ttfqD9D4Hzd5SGl8ovKlxJhTkAYAHOV9aOZmevH8jqpC0HT2//I/ 9xq361tGpR4V9/5SMArfEWjQT1iKs2McNmGWc4xcoXfP5Ga2grisGaXazaqJ/19WBPos eacg== X-Gm-Message-State: AODbwcDw3UfLN81CubVg1Ow2ZiSqyTBPt2yamCQD3ytgGDLfinRe5P0+ Ag4TzOpkpysqMwIk9Lld03KISrYHFQ== X-Received: by 10.157.63.143 with SMTP id r15mr1895221otc.89.1494404872980; Wed, 10 May 2017 01:27:52 -0700 (PDT) MIME-Version: 1.0 Received: by 10.157.51.83 with HTTP; Wed, 10 May 2017 01:27:52 -0700 (PDT) In-Reply-To: <20170509205242.2237-8-tbsaunde+gcc@tbsaunde.org> References: <20170509205242.2237-1-tbsaunde+gcc@tbsaunde.org> <20170509205242.2237-8-tbsaunde+gcc@tbsaunde.org> From: Richard Biener Date: Wed, 10 May 2017 08:28:00 -0000 Message-ID: Subject: Re: [PATCH 07/13] use auto_bitmap more To: tbsaunde+gcc@tbsaunde.org Cc: GCC Patches Content-Type: text/plain; charset=UTF-8 X-IsSubscribed: yes X-SW-Source: 2017-05/txt/msg00754.txt.bz2 On Tue, May 9, 2017 at 10:52 PM, wrote: > From: Trevor Saunders > > gcc/ChangeLog: Ok. Richard. > 2017-05-09 Trevor Saunders > > * bt-load.c (combine_btr_defs): Use auto_bitmap to manage bitmap > lifetime. > (migrate_btr_def): Likewise. > * cfgloop.c (get_loop_body_in_bfs_order): Likewise. > * df-core.c (loop_post_order_compute): Likewise. > (loop_inverted_post_order_compute): Likewise. > * hsa-common.h: Likewise. > * hsa-gen.c (hsa_bb::~hsa_bb): Likewise. > * init-regs.c (initialize_uninitialized_regs): Likewise. > * ipa-inline.c (resolve_noninline_speculation): Likewise. > (inline_small_functions): Likewise. > * ipa-reference.c (ipa_reference_write_optimization_summary): > Likewise. > * ira.c (combine_and_move_insns): Likewise. > (build_insn_chain): Likewise. > * loop-invariant.c (find_invariants): Likewise. > * lower-subreg.c (propagate_pseudo_copies): Likewise. > * predict.c (tree_predict_by_opcode): Likewise. > (predict_paths_leading_to): Likewise. > (predict_paths_leading_to_edge): Likewise. > (estimate_loops_at_level): Likewise. > (estimate_loops): Likewise. > * shrink-wrap.c (try_shrink_wrapping): Likewise. > (spread_components): Likewise. > * tree-cfg.c (remove_edge_and_dominated_blocks): Likewise. > * tree-loop-distribution.c (rdg_build_partitions): Likewise. > * tree-predcom.c (tree_predictive_commoning_loop): Likewise. > * tree-ssa-coalesce.c (coalesce_ssa_name): Likewise. > * tree-ssa-phionlycprop.c (pass_phi_only_cprop::execute): > Likewise. > * tree-ssa-pre.c (remove_dead_inserted_code): Likewise. > * tree-ssa-sink.c (nearest_common_dominator_of_uses): Likewise. > * tree-ssa-threadupdate.c (compute_path_counts): Likewise. > (mark_threaded_blocks): Likewise. > (thread_through_all_blocks): Likewise. > * tree-ssa.c (verify_ssa): Likewise. > (execute_update_addresses_taken): Likewise. > * tree-ssanames.c (verify_ssaname_freelists): Likewise. > --- > gcc/bt-load.c | 8 +++----- > gcc/cfgloop.c | 4 +--- > gcc/df-core.c | 8 ++------ > gcc/hsa-common.h | 4 ++-- > gcc/hsa-gen.c | 14 ++------------ > gcc/init-regs.c | 4 +--- > gcc/ipa-inline.c | 6 ++---- > gcc/ipa-reference.c | 3 +-- > gcc/ira.c | 13 ++++--------- > gcc/loop-invariant.c | 12 ++++-------- > gcc/lower-subreg.c | 8 +------- > gcc/predict.c | 19 +++++-------------- > gcc/shrink-wrap.c | 10 +++------- > gcc/tree-cfg.c | 7 +------ > gcc/tree-loop-distribution.c | 4 +--- > gcc/tree-predcom.c | 4 +--- > gcc/tree-ssa-coalesce.c | 4 +--- > gcc/tree-ssa-phionlycprop.c | 15 ++++----------- > gcc/tree-ssa-pre.c | 4 +--- > gcc/tree-ssa-sink.c | 9 +++------ > gcc/tree-ssa-threadupdate.c | 13 +++---------- > gcc/tree-ssa.c | 12 ++++-------- > gcc/tree-ssanames.c | 10 +++------- > 23 files changed, 53 insertions(+), 142 deletions(-) > > diff --git a/gcc/bt-load.c b/gcc/bt-load.c > index 27be6a382c4..32924e2ecc5 100644 > --- a/gcc/bt-load.c > +++ b/gcc/bt-load.c > @@ -1058,7 +1058,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_ALLOC (NULL); > + auto_bitmap combined_live_range; > btr_user *user; > > if (other_def->live_range == NULL) > @@ -1116,7 +1116,6 @@ combine_btr_defs (btr_def *def, HARD_REG_SET *btrs_live_in_range) > delete_insn (other_def->insn); > > } > - BITMAP_FREE (combined_live_range); > } > } > } > @@ -1255,7 +1254,6 @@ can_move_up (const_basic_block bb, const rtx_insn *insn, int n_insns) > static int > migrate_btr_def (btr_def *def, int min_cost) > { > - bitmap live_range; > HARD_REG_SET btrs_live_in_range; > int btr_used_near_def = 0; > int def_basic_block_freq; > @@ -1289,7 +1287,7 @@ migrate_btr_def (btr_def *def, int min_cost) > } > > btr_def_live_range (def, &btrs_live_in_range); > - live_range = BITMAP_ALLOC (NULL); > + auto_bitmap live_range; > bitmap_copy (live_range, def->live_range); > > #ifdef INSN_SCHEDULING > @@ -1373,7 +1371,7 @@ migrate_btr_def (btr_def *def, int min_cost) > if (dump_file) > fprintf (dump_file, "failed to move\n"); > } > - BITMAP_FREE (live_range); > + > return !give_up; > } > > diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c > index afd56bb8cf7..654d188e8b5 100644 > --- a/gcc/cfgloop.c > +++ b/gcc/cfgloop.c > @@ -923,7 +923,6 @@ get_loop_body_in_bfs_order (const struct loop *loop) > { > basic_block *blocks; > basic_block bb; > - bitmap visited; > unsigned int i = 1; > unsigned int vc = 0; > > @@ -931,7 +930,7 @@ get_loop_body_in_bfs_order (const struct loop *loop) > gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun)); > > blocks = XNEWVEC (basic_block, loop->num_nodes); > - visited = BITMAP_ALLOC (NULL); > + auto_bitmap visited; > blocks[0] = loop->header; > bitmap_set_bit (visited, loop->header->index); > while (i < loop->num_nodes) > @@ -952,7 +951,6 @@ get_loop_body_in_bfs_order (const struct loop *loop) > } > } > > - BITMAP_FREE (visited); > return blocks; > } > > diff --git a/gcc/df-core.c b/gcc/df-core.c > index 19f4d3dae8c..98787a768c6 100644 > --- a/gcc/df-core.c > +++ b/gcc/df-core.c > @@ -1303,14 +1303,13 @@ loop_post_order_compute (int *post_order, struct loop *loop) > edge_iterator *stack; > int sp; > int post_order_num = 0; > - bitmap visited; > > /* Allocate stack for back-tracking up CFG. */ > stack = XNEWVEC (edge_iterator, loop->num_nodes + 1); > sp = 0; > > /* Allocate bitmap to track nodes that have been visited. */ > - visited = BITMAP_ALLOC (NULL); > + auto_bitmap visited; > > /* Push the first edge on to the stack. */ > stack[sp++] = ei_start (loop_preheader_edge (loop)->src->succs); > @@ -1352,7 +1351,6 @@ loop_post_order_compute (int *post_order, struct loop *loop) > } > > free (stack); > - BITMAP_FREE (visited); > > return post_order_num; > } > @@ -1367,14 +1365,13 @@ loop_inverted_post_order_compute (int *post_order, struct loop *loop) > edge_iterator *stack; > int sp; > int post_order_num = 0; > - bitmap visited; > > /* Allocate stack for back-tracking up CFG. */ > stack = XNEWVEC (edge_iterator, loop->num_nodes + 1); > sp = 0; > > /* Allocate bitmap to track nodes that have been visited. */ > - visited = BITMAP_ALLOC (NULL); > + auto_bitmap visited; > > /* Put all latches into the initial work list. In theory we'd want > to start from loop exits but then we'd have the special case of > @@ -1420,7 +1417,6 @@ loop_inverted_post_order_compute (int *post_order, struct loop *loop) > } > > free (stack); > - BITMAP_FREE (visited); > return post_order_num; > } > > diff --git a/gcc/hsa-common.h b/gcc/hsa-common.h > index a24bf6e5ad1..810624e4e1c 100644 > --- a/gcc/hsa-common.h > +++ b/gcc/hsa-common.h > @@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see > #include "vec.h" > #include "hash-table.h" > #include "basic-block.h" > +#include "bitmap.h" > > > /* Return true if the compiler should produce HSAIL. */ > @@ -1027,7 +1028,6 @@ class hsa_bb > public: > hsa_bb (basic_block cfg_bb); > hsa_bb (basic_block cfg_bb, int idx); > - ~hsa_bb (); > > /* Append an instruction INSN into the basic block. */ > void append_insn (hsa_insn_basic *insn); > @@ -1049,7 +1049,7 @@ public: > /* Just a number to construct names from. */ > int m_index; > > - bitmap m_liveout, m_livein; > + auto_bitmap m_liveout, m_livein; > private: > /* Make the default constructor inaccessible. */ > hsa_bb (); > diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c > index 4b85e0b2678..c5d8a6e1f44 100644 > --- a/gcc/hsa-gen.c > +++ b/gcc/hsa-gen.c > @@ -5716,8 +5716,7 @@ gen_hsa_phi_from_gimple_phi (gimple *phi_stmt, hsa_bb *hbb) > > hsa_bb::hsa_bb (basic_block cfg_bb, int idx) > : m_bb (cfg_bb), m_first_insn (NULL), m_last_insn (NULL), m_first_phi (NULL), > - m_last_phi (NULL), m_index (idx), m_liveout (BITMAP_ALLOC (NULL)), > - m_livein (BITMAP_ALLOC (NULL)) > + m_last_phi (NULL), m_index (idx) > { > gcc_assert (!cfg_bb->aux); > cfg_bb->aux = this; > @@ -5728,21 +5727,12 @@ hsa_bb::hsa_bb (basic_block cfg_bb, int idx) > > hsa_bb::hsa_bb (basic_block cfg_bb) > : m_bb (cfg_bb), m_first_insn (NULL), m_last_insn (NULL), m_first_phi (NULL), > - m_last_phi (NULL), m_index (hsa_cfun->m_hbb_count++), > - m_liveout (BITMAP_ALLOC (NULL)), m_livein (BITMAP_ALLOC (NULL)) > + m_last_phi (NULL), m_index (hsa_cfun->m_hbb_count++) > { > gcc_assert (!cfg_bb->aux); > cfg_bb->aux = this; > } > > -/* Destructor of class representing HSA BB. */ > - > -hsa_bb::~hsa_bb () > -{ > - BITMAP_FREE (m_livein); > - BITMAP_FREE (m_liveout); > -} > - > /* Create and initialize and return a new hsa_bb structure for a given CFG > basic block BB. */ > > diff --git a/gcc/init-regs.c b/gcc/init-regs.c > index 2c69991c9e1..15d77467149 100644 > --- a/gcc/init-regs.c > +++ b/gcc/init-regs.c > @@ -48,7 +48,7 @@ static void > initialize_uninitialized_regs (void) > { > basic_block bb; > - bitmap already_genned = BITMAP_ALLOC (NULL); > + auto_bitmap already_genned; > > if (optimize == 1) > { > @@ -125,8 +125,6 @@ initialize_uninitialized_regs (void) > df_dump (dump_file); > df_remove_problem (df_live); > } > - > - BITMAP_FREE (already_genned); > } > > namespace { > diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c > index ce79af5719e..7337e0a2fe5 100644 > --- a/gcc/ipa-inline.c > +++ b/gcc/ipa-inline.c > @@ -1674,7 +1674,7 @@ resolve_noninline_speculation (edge_heap_t *edge_heap, struct cgraph_edge *edge) > struct cgraph_node *node = edge->caller; > struct cgraph_node *where = node->global.inlined_to > ? node->global.inlined_to : node; > - bitmap updated_nodes = BITMAP_ALLOC (NULL); > + auto_bitmap updated_nodes; > > spec_rem += edge->count; > edge->resolve_speculation (); > @@ -1684,7 +1684,6 @@ resolve_noninline_speculation (edge_heap_t *edge_heap, struct cgraph_edge *edge) > updated_nodes, NULL); > update_callee_keys (edge_heap, where, > updated_nodes); > - BITMAP_FREE (updated_nodes); > } > } > > @@ -1726,7 +1725,7 @@ inline_small_functions (void) > struct cgraph_node *node; > struct cgraph_edge *edge; > edge_heap_t edge_heap (sreal::min ()); > - bitmap updated_nodes = BITMAP_ALLOC (NULL); > + auto_bitmap updated_nodes; > int min_size, max_size; > auto_vec new_indirect_edges; > int initial_size = 0; > @@ -2072,7 +2071,6 @@ inline_small_functions (void) > "Unit growth for small function inlining: %i->%i (%i%%)\n", > initial_size, overall_size, > initial_size ? overall_size * 100 / (initial_size) - 100: 0); > - BITMAP_FREE (updated_nodes); > symtab->remove_edge_removal_hook (edge_removal_hook_holder); > } > > diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c > index f47d0cc51e1..222253920fd 100644 > --- a/gcc/ipa-reference.c > +++ b/gcc/ipa-reference.c > @@ -992,7 +992,7 @@ ipa_reference_write_optimization_summary (void) > unsigned int count = 0; > int ltrans_statics_bitcount = 0; > lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder; > - bitmap ltrans_statics = BITMAP_ALLOC (NULL); > + auto_bitmap ltrans_statics; > int i; > > reference_vars_to_consider = splay_tree_new (splay_tree_compare_ints, 0, 0); > @@ -1052,7 +1052,6 @@ ipa_reference_write_optimization_summary (void) > ltrans_statics_bitcount); > } > } > - BITMAP_FREE (ltrans_statics); > lto_destroy_simple_output_block (ob); > splay_tree_delete (reference_vars_to_consider); > } > diff --git a/gcc/ira.c b/gcc/ira.c > index bfb05080de1..c9751ce81ba 100644 > --- a/gcc/ira.c > +++ b/gcc/ira.c > @@ -3698,7 +3698,7 @@ add_store_equivs (void) > static void > combine_and_move_insns (void) > { > - bitmap cleared_regs = BITMAP_ALLOC (NULL); > + auto_bitmap cleared_regs; > int max = max_reg_num (); > > for (int regno = FIRST_PSEUDO_REGISTER; regno < max; regno++) > @@ -3856,8 +3856,6 @@ combine_and_move_insns (void) > df_insn_rescan (insn); > } > } > - > - BITMAP_FREE (cleared_regs); > } > > /* A pass over indirect jumps, converting simple cases to direct jumps. > @@ -4083,8 +4081,8 @@ build_insn_chain (void) > basic_block bb; > struct insn_chain *c = NULL; > struct insn_chain *next = NULL; > - bitmap live_relevant_regs = BITMAP_ALLOC (NULL); > - bitmap elim_regset = BITMAP_ALLOC (NULL); > + auto_bitmap live_relevant_regs; > + auto_bitmap elim_regset; > /* live_subregs is a vector used to keep accurate information about > which hardregs are live in multiword pseudos. live_subregs and > live_subregs_used are indexed by pseudo number. The live_subreg > @@ -4093,7 +4091,7 @@ build_insn_chain (void) > live_subreg[allocno] is number of bytes that the pseudo can > occupy. */ > sbitmap *live_subregs = XCNEWVEC (sbitmap, max_regno); > - bitmap live_subregs_used = BITMAP_ALLOC (NULL); > + auto_bitmap live_subregs_used; > > for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) > if (TEST_HARD_REG_BIT (eliminable_regset, i)) > @@ -4336,9 +4334,6 @@ build_insn_chain (void) > if (live_subregs[i] != NULL) > sbitmap_free (live_subregs[i]); > free (live_subregs); > - BITMAP_FREE (live_subregs_used); > - BITMAP_FREE (live_relevant_regs); > - BITMAP_FREE (elim_regset); > > if (dump_file) > print_insn_chains (dump_file); > diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c > index 8292cea3e52..cda42efd13e 100644 > --- a/gcc/loop-invariant.c > +++ b/gcc/loop-invariant.c > @@ -1219,10 +1219,10 @@ find_invariants_body (struct loop *loop, basic_block *body, > static void > find_invariants (struct loop *loop) > { > - bitmap may_exit = BITMAP_ALLOC (NULL); > - bitmap always_reached = BITMAP_ALLOC (NULL); > - bitmap has_exit = BITMAP_ALLOC (NULL); > - bitmap always_executed = BITMAP_ALLOC (NULL); > + auto_bitmap may_exit; > + auto_bitmap always_reached; > + auto_bitmap has_exit; > + auto_bitmap always_executed; > basic_block *body = get_loop_body_in_dom_order (loop); > > find_exits (loop, body, may_exit, has_exit); > @@ -1233,10 +1233,6 @@ find_invariants (struct loop *loop) > find_invariants_body (loop, body, always_reached, always_executed); > merge_identical_invariants (); > > - BITMAP_FREE (always_reached); > - BITMAP_FREE (always_executed); > - BITMAP_FREE (may_exit); > - BITMAP_FREE (has_exit); > free (body); > } > > diff --git a/gcc/lower-subreg.c b/gcc/lower-subreg.c > index a4dcec51bb5..1ab1c71211f 100644 > --- a/gcc/lower-subreg.c > +++ b/gcc/lower-subreg.c > @@ -405,10 +405,7 @@ find_pseudo_copy (rtx set) > static void > propagate_pseudo_copies (void) > { > - bitmap queue, propagate; > - > - queue = BITMAP_ALLOC (NULL); > - propagate = BITMAP_ALLOC (NULL); > + auto_bitmap queue, propagate; > > bitmap_copy (queue, decomposable_context); > do > @@ -429,9 +426,6 @@ propagate_pseudo_copies (void) > bitmap_ior_into (decomposable_context, propagate); > } > while (!bitmap_empty_p (queue)); > - > - BITMAP_FREE (queue); > - BITMAP_FREE (propagate); > } > > /* A pointer to one of these values is passed to > diff --git a/gcc/predict.c b/gcc/predict.c > index fa4e626fab8..0fc9fc5c466 100644 > --- a/gcc/predict.c > +++ b/gcc/predict.c > @@ -2396,7 +2396,6 @@ tree_predict_by_opcode (basic_block bb) > tree type; > tree val; > enum tree_code cmp; > - bitmap visited; > edge_iterator ei; > enum br_predictor predictor; > > @@ -2409,10 +2408,8 @@ tree_predict_by_opcode (basic_block bb) > op1 = gimple_cond_rhs (stmt); > cmp = gimple_cond_code (stmt); > type = TREE_TYPE (op0); > - visited = BITMAP_ALLOC (NULL); > - val = expr_expected_value_1 (boolean_type_node, op0, cmp, op1, visited, > + val = expr_expected_value_1 (boolean_type_node, op0, cmp, op1, auto_bitmap (), > &predictor); > - BITMAP_FREE (visited); > if (val && TREE_CODE (val) == INTEGER_CST) > { > if (predictor == PRED_BUILTIN_EXPECT) > @@ -2917,9 +2914,7 @@ static void > predict_paths_leading_to (basic_block bb, enum br_predictor pred, > enum prediction taken, struct loop *in_loop) > { > - bitmap visited = BITMAP_ALLOC (NULL); > - predict_paths_for_bb (bb, bb, pred, taken, visited, in_loop); > - BITMAP_FREE (visited); > + predict_paths_for_bb (bb, bb, pred, taken, auto_bitmap (), in_loop); > } > > /* Like predict_paths_leading_to but take edge instead of basic block. */ > @@ -2943,9 +2938,7 @@ predict_paths_leading_to_edge (edge e, enum br_predictor pred, > } > if (!has_nonloop_edge) > { > - bitmap visited = BITMAP_ALLOC (NULL); > - predict_paths_for_bb (bb, bb, pred, taken, visited, in_loop); > - BITMAP_FREE (visited); > + predict_paths_for_bb (bb, bb, pred, taken, auto_bitmap (), in_loop); > } > else > predict_edge_def (e, pred, taken); > @@ -3119,7 +3112,7 @@ estimate_loops_at_level (struct loop *first_loop) > edge e; > basic_block *bbs; > unsigned i; > - bitmap tovisit = BITMAP_ALLOC (NULL); > + auto_bitmap tovisit; > > estimate_loops_at_level (loop->inner); > > @@ -3132,7 +3125,6 @@ estimate_loops_at_level (struct loop *first_loop) > bitmap_set_bit (tovisit, bbs[i]->index); > free (bbs); > propagate_freq (loop->header, tovisit); > - BITMAP_FREE (tovisit); > } > } > > @@ -3141,7 +3133,7 @@ estimate_loops_at_level (struct loop *first_loop) > static void > estimate_loops (void) > { > - bitmap tovisit = BITMAP_ALLOC (NULL); > + auto_bitmap tovisit; > basic_block bb; > > /* Start by estimating the frequencies in the loops. */ > @@ -3154,7 +3146,6 @@ estimate_loops (void) > bitmap_set_bit (tovisit, bb->index); > } > propagate_freq (ENTRY_BLOCK_PTR_FOR_FN (cfun), tovisit); > - BITMAP_FREE (tovisit); > } > > /* Drop the profile for NODE to guessed, and update its frequency based on > diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c > index 35eb85ba63c..492376d949b 100644 > --- a/gcc/shrink-wrap.c > +++ b/gcc/shrink-wrap.c > @@ -758,7 +758,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) > reachable from PRO that we already found, and in VEC a stack of > those we still need to consider (to find successors). */ > > - bitmap bb_with = BITMAP_ALLOC (NULL); > + auto_bitmap bb_with; > bitmap_set_bit (bb_with, pro->index); > > vec vec; > @@ -822,7 +822,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) > { > calculate_dominance_info (CDI_POST_DOMINATORS); > > - bitmap bb_tmp = BITMAP_ALLOC (NULL); > + auto_bitmap bb_tmp; > bitmap_copy (bb_tmp, bb_with); > basic_block last_ok = pro; > vec.truncate (0); > @@ -859,7 +859,6 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) > > pro = last_ok; > > - BITMAP_FREE (bb_tmp); > free_dominance_info (CDI_POST_DOMINATORS); > } > > @@ -871,7 +870,6 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) > > if (pro == entry) > { > - BITMAP_FREE (bb_with); > free_dominance_info (CDI_DOMINATORS); > return; > } > @@ -1006,7 +1004,6 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) > *entry_edge = make_single_succ_edge (new_bb, pro, EDGE_FALLTHRU); > force_nonfallthru (*entry_edge); > > - BITMAP_FREE (bb_with); > free_dominance_info (CDI_DOMINATORS); > } > > @@ -1265,7 +1262,7 @@ spread_components (sbitmap components) > on that stack. */ > vec todo; > todo.create (n_basic_blocks_for_fn (cfun)); > - bitmap seen = BITMAP_ALLOC (NULL); > + auto_bitmap seen; > > sbitmap old = sbitmap_alloc (SBITMAP_SIZE (components)); > > @@ -1395,7 +1392,6 @@ spread_components (sbitmap components) > } > > sbitmap_free (old); > - BITMAP_FREE (seen); > } > > /* If we cannot handle placing some component's prologues or epilogues where > diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c > index a540416cbb5..8fdfdd6f1bc 100644 > --- a/gcc/tree-cfg.c > +++ b/gcc/tree-cfg.c > @@ -8178,7 +8178,6 @@ remove_edge_and_dominated_blocks (edge e) > { > vec bbs_to_remove = vNULL; > vec bbs_to_fix_dom = vNULL; > - bitmap df, df_idom; > edge f; > edge_iterator ei; > bool none_removed = false; > @@ -8227,9 +8226,7 @@ remove_edge_and_dominated_blocks (edge e) > } > } > > - df = BITMAP_ALLOC (NULL); > - df_idom = BITMAP_ALLOC (NULL); > - > + auto_bitmap df, df_idom; > if (none_removed) > bitmap_set_bit (df_idom, > get_immediate_dominator (CDI_DOMINATORS, e->dest)->index); > @@ -8296,8 +8293,6 @@ remove_edge_and_dominated_blocks (edge e) > > iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true); > > - BITMAP_FREE (df); > - BITMAP_FREE (df_idom); > bbs_to_remove.release (); > bbs_to_fix_dom.release (); > } > diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c > index 1b9950eca8e..a60454b5218 100644 > --- a/gcc/tree-loop-distribution.c > +++ b/gcc/tree-loop-distribution.c > @@ -1251,7 +1251,7 @@ rdg_build_partitions (struct graph *rdg, > vec starting_stmts, > vec *partitions) > { > - bitmap processed = BITMAP_ALLOC (NULL); > + auto_bitmap processed; > int i; > gimple *stmt; > > @@ -1282,8 +1282,6 @@ rdg_build_partitions (struct graph *rdg, > > /* All vertices should have been assigned to at least one partition now, > other than vertices belonging to dead code. */ > - > - BITMAP_FREE (processed); > } > > /* Dump to FILE the PARTITIONS. */ > diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c > index 57d8f7d207c..23e7870dd2d 100644 > --- a/gcc/tree-predcom.c > +++ b/gcc/tree-predcom.c > @@ -2498,7 +2498,6 @@ tree_predictive_commoning_loop (struct loop *loop) > struct tree_niter_desc desc; > bool unroll = false; > edge exit; > - bitmap tmp_vars; > > if (dump_file && (dump_flags & TDF_DETAILS)) > fprintf (dump_file, "Processing loop %d\n", loop->num); > @@ -2549,7 +2548,7 @@ tree_predictive_commoning_loop (struct loop *loop) > /* Find the suitable components and split them into chains. */ > components = filter_suitable_components (loop, components); > > - tmp_vars = BITMAP_ALLOC (NULL); > + auto_bitmap tmp_vars; > looparound_phis = BITMAP_ALLOC (NULL); > determine_roots (loop, components, &chains); > release_components (components); > @@ -2617,7 +2616,6 @@ tree_predictive_commoning_loop (struct loop *loop) > end: ; > release_chains (chains); > free_data_refs (datarefs); > - BITMAP_FREE (tmp_vars); > BITMAP_FREE (looparound_phis); > > free_affine_expand_cache (&name_expansions); > diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c > index 1b78d66456e..e166314ed4d 100644 > --- a/gcc/tree-ssa-coalesce.c > +++ b/gcc/tree-ssa-coalesce.c > @@ -1791,7 +1791,7 @@ coalesce_ssa_name (void) > tree_live_info_p liveinfo; > ssa_conflicts *graph; > coalesce_list *cl; > - bitmap used_in_copies = BITMAP_ALLOC (NULL); > + auto_bitmap used_in_copies; > var_map map; > unsigned int i; > tree a; > @@ -1848,8 +1848,6 @@ coalesce_ssa_name (void) > else > compute_samebase_partition_bases (map); > > - BITMAP_FREE (used_in_copies); > - > if (num_var_partitions (map) < 1) > { > delete_coalesce_list (cl); > diff --git a/gcc/tree-ssa-phionlycprop.c b/gcc/tree-ssa-phionlycprop.c > index f61b269cd63..aa0f50256cd 100644 > --- a/gcc/tree-ssa-phionlycprop.c > +++ b/gcc/tree-ssa-phionlycprop.c > @@ -497,13 +497,11 @@ public: > unsigned int > pass_phi_only_cprop::execute (function *fun) > { > - bitmap interesting_names; > - bitmap interesting_names1; > bool cfg_altered = false; > > /* Bitmap of blocks which need EH information updated. We can not > update it on-the-fly as doing so invalidates the dominator tree. */ > - bitmap need_eh_cleanup = BITMAP_ALLOC (NULL); > + auto_bitmap need_eh_cleanup; > > /* INTERESTING_NAMES is effectively our worklist, indexed by > SSA_NAME_VERSION. > @@ -515,8 +513,8 @@ pass_phi_only_cprop::execute (function *fun) > > Experiments have show we generally get better compilation > time behavior with bitmaps rather than sbitmaps. */ > - interesting_names = BITMAP_ALLOC (NULL); > - interesting_names1 = BITMAP_ALLOC (NULL); > + auto_bitmap interesting_names; > + auto_bitmap interesting_names1; > > calculate_dominance_info (CDI_DOMINATORS); > cfg_altered = false; > @@ -570,13 +568,8 @@ pass_phi_only_cprop::execute (function *fun) > /* Propagation of const and copies may make some EH edges dead. Purge > such edges from the CFG as needed. */ > if (!bitmap_empty_p (need_eh_cleanup)) > - { > - gimple_purge_all_dead_eh_edges (need_eh_cleanup); > - BITMAP_FREE (need_eh_cleanup); > - } > + gimple_purge_all_dead_eh_edges (need_eh_cleanup); > > - BITMAP_FREE (interesting_names); > - BITMAP_FREE (interesting_names1); > return 0; > } > > diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c > index b4095bfdeed..8175d2599ed 100644 > --- a/gcc/tree-ssa-pre.c > +++ b/gcc/tree-ssa-pre.c > @@ -4903,12 +4903,11 @@ mark_operand_necessary (tree op) > static void > remove_dead_inserted_code (void) > { > - bitmap worklist; > unsigned i; > bitmap_iterator bi; > gimple *t; > > - worklist = BITMAP_ALLOC (NULL); > + auto_bitmap worklist; > EXECUTE_IF_SET_IN_BITMAP (inserted_exprs, 0, i, bi) > { > t = SSA_NAME_DEF_STMT (ssa_name (i)); > @@ -4984,7 +4983,6 @@ remove_dead_inserted_code (void) > } > } > } > - BITMAP_FREE (worklist); > } > > > diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c > index eb8b36095d8..acf832d66f6 100644 > --- a/gcc/tree-ssa-sink.c > +++ b/gcc/tree-ssa-sink.c > @@ -128,7 +128,7 @@ static basic_block > nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts) > { > tree var = DEF_FROM_PTR (def_p); > - bitmap blocks = BITMAP_ALLOC (NULL); > + auto_bitmap blocks; > basic_block commondom; > unsigned int j; > bitmap_iterator bi; > @@ -158,17 +158,14 @@ nearest_common_dominator_of_uses (def_operand_p def_p, bool *debug_stmts) > > /* Short circuit. Nothing dominates the entry block. */ > if (useblock == ENTRY_BLOCK_PTR_FOR_FN (cfun)) > - { > - BITMAP_FREE (blocks); > - return NULL; > - } > + return NULL; > + > bitmap_set_bit (blocks, useblock->index); > } > commondom = BASIC_BLOCK_FOR_FN (cfun, bitmap_first_set_bit (blocks)); > EXECUTE_IF_SET_IN_BITMAP (blocks, 0, j, bi) > commondom = nearest_common_dominator (CDI_DOMINATORS, commondom, > BASIC_BLOCK_FOR_FN (cfun, j)); > - BITMAP_FREE (blocks); > return commondom; > } > > diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c > index e30ddd821ed..319826861dc 100644 > --- a/gcc/tree-ssa-threadupdate.c > +++ b/gcc/tree-ssa-threadupdate.c > @@ -723,7 +723,7 @@ compute_path_counts (struct redirection_data *rd, > below to add up the counts of the other edges not included in this jump > threading path. */ > struct el *next, *el; > - bitmap in_edge_srcs = BITMAP_ALLOC (NULL); > + auto_bitmap in_edge_srcs; > for (el = rd->incoming_edges; el; el = next) > { > next = el->next; > @@ -759,8 +759,6 @@ compute_path_counts (struct redirection_data *rd, > if (path_in_freq > BB_FREQ_MAX) > path_in_freq = BB_FREQ_MAX; > > - BITMAP_FREE (in_edge_srcs); > - > /* Now compute the fraction of the total count coming into the first > path bb that is from the current threading path. */ > gcov_type total_count = e->dest->count; > @@ -1958,7 +1956,7 @@ mark_threaded_blocks (bitmap threaded_blocks) > { > unsigned int i; > bitmap_iterator bi; > - bitmap tmp = BITMAP_ALLOC (NULL); > + auto_bitmap tmp; > basic_block bb; > edge e; > edge_iterator ei; > @@ -2169,8 +2167,6 @@ mark_threaded_blocks (bitmap threaded_blocks) > } > } > } > - > - BITMAP_FREE (tmp); > } > > > @@ -2436,8 +2432,8 @@ thread_through_all_blocks (bool may_peel_loop_headers) > bool retval = false; > unsigned int i; > bitmap_iterator bi; > - bitmap threaded_blocks; > struct loop *loop; > + auto_bitmap threaded_blocks; > > if (!paths.exists ()) > { > @@ -2445,7 +2441,6 @@ thread_through_all_blocks (bool may_peel_loop_headers) > goto out; > } > > - threaded_blocks = BITMAP_ALLOC (NULL); > memset (&thread_stats, 0, sizeof (thread_stats)); > > /* Remove any paths that referenced removed edges. */ > @@ -2578,8 +2573,6 @@ thread_through_all_blocks (bool may_peel_loop_headers) > > free_original_copy_tables (); > > - BITMAP_FREE (threaded_blocks); > - threaded_blocks = NULL; > paths.release (); > > if (retval) > diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c > index 42e708ed673..11f5a2bac92 100644 > --- a/gcc/tree-ssa.c > +++ b/gcc/tree-ssa.c > @@ -1022,7 +1022,7 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands) > ssa_op_iter iter; > tree op; > enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS); > - bitmap names_defined_in_bb = BITMAP_ALLOC (NULL); > + auto_bitmap names_defined_in_bb; > > gcc_assert (!need_ssa_update_p (cfun)); > > @@ -1176,7 +1176,6 @@ verify_ssa (bool check_modified_stmt, bool check_ssa_operands) > else > set_dom_info_availability (CDI_DOMINATORS, orig_dom_state); > > - BITMAP_FREE (names_defined_in_bb); > timevar_pop (TV_TREE_SSA_VERIFY); > return; > > @@ -1622,9 +1621,9 @@ void > execute_update_addresses_taken (void) > { > basic_block bb; > - bitmap addresses_taken = BITMAP_ALLOC (NULL); > - bitmap not_reg_needs = BITMAP_ALLOC (NULL); > - bitmap suitable_for_renaming = BITMAP_ALLOC (NULL); > + auto_bitmap addresses_taken; > + auto_bitmap not_reg_needs; > + auto_bitmap suitable_for_renaming; > tree var; > unsigned i; > > @@ -2005,9 +2004,6 @@ execute_update_addresses_taken (void) > update_ssa (TODO_update_ssa); > } > > - BITMAP_FREE (not_reg_needs); > - BITMAP_FREE (addresses_taken); > - BITMAP_FREE (suitable_for_renaming); > timevar_pop (TV_ADDRESS_TAKEN); > } > > diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c > index 6487542eb8f..353c7b1906a 100644 > --- a/gcc/tree-ssanames.c > +++ b/gcc/tree-ssanames.c > @@ -127,7 +127,7 @@ verify_ssaname_freelists (struct function *fun) > if (!gimple_in_ssa_p (fun)) > return; > > - bitmap names_in_il = BITMAP_ALLOC (NULL); > + auto_bitmap names_in_il; > > /* Walk the entire IL noting every SSA_NAME we see. */ > basic_block bb; > @@ -165,7 +165,7 @@ verify_ssaname_freelists (struct function *fun) > > /* Now walk the free list noting what we find there and verifying > there are no duplicates. */ > - bitmap names_in_freelists = BITMAP_ALLOC (NULL); > + auto_bitmap names_in_freelists; > if (FREE_SSANAMES (fun)) > { > for (unsigned int i = 0; i < FREE_SSANAMES (fun)->length (); i++) > @@ -221,7 +221,7 @@ verify_ssaname_freelists (struct function *fun) > > unsigned int i; > bitmap_iterator bi; > - bitmap all_names = BITMAP_ALLOC (NULL); > + auto_bitmap all_names; > bitmap_set_range (all_names, UNUSED_NAME_VERSION + 1, num_ssa_names - 1); > bitmap_ior_into (names_in_il, names_in_freelists); > > @@ -230,10 +230,6 @@ verify_ssaname_freelists (struct function *fun) > EXECUTE_IF_AND_COMPL_IN_BITMAP(all_names, names_in_il, > UNUSED_NAME_VERSION + 1, i, bi) > gcc_assert (!ssa_name (i)); > - > - BITMAP_FREE (all_names); > - BITMAP_FREE (names_in_freelists); > - BITMAP_FREE (names_in_il); > } > > /* Move all SSA_NAMEs from FREE_SSA_NAMES_QUEUE to FREE_SSA_NAMES. > -- > 2.11.0 >