From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 101841 invoked by alias); 10 May 2017 08:26:03 -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 101766 invoked by uid 89); 10 May 2017 08:26:00 -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-f68.google.com Received: from mail-oi0-f68.google.com (HELO mail-oi0-f68.google.com) (209.85.218.68) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 10 May 2017 08:25:57 +0000 Received: by mail-oi0-f68.google.com with SMTP id m17so3937256oik.2 for ; Wed, 10 May 2017 01:25:59 -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=98mh7H0edj1FXJcalSKYisNlQCUt1q8dbu4fIRytXNo=; b=dfoG2kaGBEIV3XB1zYFPaSxCHycygc0r4WvmhsvgUw0dWHxKVjDazfGMaKIWxB6E+H xAATCevr/rt4VFMxywlBl/wQhWfawgt6yvV+6V7uKOeWJIdLXKqewZL0PnjtaCb8czJ5 bUF6N8eZrPLv0jlmdxnkP+c5+FR4g342Ve9GhIZ73glg05NiM4c8TdM1Cl4gVxXcsiCM fhKL8YONmpKSO4+NlNVz735/Vo30c/9ZFysa+vsK7JTL9vjwX77ZI4uRwjb1uSWkc7S+ IiW/FXEgnQYN61kxkBBqmXVLzAz3aOIx+g/8x0IrYSUBTQBsTM8cFkobbedGnRh6xlin HcGA== X-Gm-Message-State: AODbwcAAhepj/mIzgBRK/iuzX6rGNq3y+vAAH4d6kaf4Gd3VA6p7cBW1 PbySFFZNdV9OD6lvX33Qu9nGHlvKLMSj X-Received: by 10.202.195.70 with SMTP id t67mr2060927oif.164.1494404758113; Wed, 10 May 2017 01:25:58 -0700 (PDT) MIME-Version: 1.0 Received: by 10.157.51.83 with HTTP; Wed, 10 May 2017 01:25:57 -0700 (PDT) In-Reply-To: <20170509205242.2237-9-tbsaunde+gcc@tbsaunde.org> References: <20170509205242.2237-1-tbsaunde+gcc@tbsaunde.org> <20170509205242.2237-9-tbsaunde+gcc@tbsaunde.org> From: Richard Biener Date: Wed, 10 May 2017 08:26:00 -0000 Message-ID: Subject: Re: [PATCH 08/13] move several bitmaps from gc memory to the default obstack and use auto_bitmap To: tbsaunde+gcc@tbsaunde.org Cc: GCC Patches Content-Type: text/plain; charset=UTF-8 X-IsSubscribed: yes X-SW-Source: 2017-05/txt/msg00749.txt.bz2 On Tue, May 9, 2017 at 10:52 PM, wrote: > From: Trevor Saunders > > These places where probably trying to use the default bitmap obstack, > but passing 0 to bitmap_initialize actually uses gc allocation. In any > case they are all cleaned up before going out of scope so using > auto_bitmap should be fine. Ok. Richard. > gcc/ChangeLog: > > 2017-05-09 Trevor Saunders > > * haifa-sched.c (estimate_shadow_tick): Replace manual bitmap > management with auto_bitmap. > (fix_inter_tick): Likewise. > (fix_recovery_deps): Likewise. > * ira.c (add_store_equivs): Likewise. > (find_moveable_pseudos): Likewise. > (split_live_ranges_for_shrink_wrap): Likewise. > * print-rtl.c (rtx_reuse_manager::rtx_reuse_manager): Likewise. > (rtx_reuse_manager::seen_def_p): Likewise. > (rtx_reuse_manager::set_seen_def): Likewise. > * print-rtl.h (class rtx_reuse_manager): Likewise. > --- > gcc/haifa-sched.c | 23 +++++---------- > gcc/ira.c | 84 +++++++++++++++++++------------------------------------ > gcc/print-rtl.c | 5 ++-- > gcc/print-rtl.h | 2 +- > 4 files changed, 38 insertions(+), 76 deletions(-) > > diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c > index 0ebf110471c..1fcc01d04ae 100644 > --- a/gcc/haifa-sched.c > +++ b/gcc/haifa-sched.c > @@ -4843,14 +4843,12 @@ estimate_insn_tick (bitmap processed, rtx_insn *insn, int budget) > static int > estimate_shadow_tick (struct delay_pair *p) > { > - bitmap_head processed; > + auto_bitmap processed; > int t; > bool cutoff; > - bitmap_initialize (&processed, 0); > > - cutoff = !estimate_insn_tick (&processed, p->i2, > + cutoff = !estimate_insn_tick (processed, p->i2, > max_insn_queue_index + pair_delay (p)); > - bitmap_clear (&processed); > if (cutoff) > return max_insn_queue_index; > t = INSN_TICK_ESTIMATE (p->i2) - (clock_var + pair_delay (p) + 1); > @@ -7515,15 +7513,13 @@ static void > fix_inter_tick (rtx_insn *head, rtx_insn *tail) > { > /* Set of instructions with corrected INSN_TICK. */ > - bitmap_head processed; > + auto_bitmap processed; > /* ??? It is doubtful if we should assume that cycle advance happens on > basic block boundaries. Basically insns that are unconditionally ready > on the start of the block are more preferable then those which have > a one cycle dependency over insn from the previous block. */ > int next_clock = clock_var + 1; > > - bitmap_initialize (&processed, 0); > - > /* Iterates over scheduled instructions and fix their INSN_TICKs and > INSN_TICKs of dependent instructions, so that INSN_TICKs are consistent > across different blocks. */ > @@ -7539,7 +7535,7 @@ fix_inter_tick (rtx_insn *head, rtx_insn *tail) > gcc_assert (tick >= MIN_TICK); > > /* Fix INSN_TICK of instruction from just scheduled block. */ > - if (bitmap_set_bit (&processed, INSN_LUID (head))) > + if (bitmap_set_bit (processed, INSN_LUID (head))) > { > tick -= next_clock; > > @@ -7563,7 +7559,7 @@ fix_inter_tick (rtx_insn *head, rtx_insn *tail) > /* If NEXT has its INSN_TICK calculated, fix it. > If not - it will be properly calculated from > scratch later in fix_tick_ready. */ > - && bitmap_set_bit (&processed, INSN_LUID (next))) > + && bitmap_set_bit (processed, INSN_LUID (next))) > { > tick -= next_clock; > > @@ -7580,7 +7576,6 @@ fix_inter_tick (rtx_insn *head, rtx_insn *tail) > } > } > } > - bitmap_clear (&processed); > } > > /* Check if NEXT is ready to be added to the ready or queue list. > @@ -8617,9 +8612,7 @@ fix_recovery_deps (basic_block rec) > { > rtx_insn *note, *insn, *jump; > auto_vec ready_list; > - bitmap_head in_ready; > - > - bitmap_initialize (&in_ready, 0); > + auto_bitmap in_ready; > > /* NOTE - a basic block note. */ > note = NEXT_INSN (BB_HEAD (rec)); > @@ -8642,7 +8635,7 @@ fix_recovery_deps (basic_block rec) > { > sd_delete_dep (sd_it); > > - if (bitmap_set_bit (&in_ready, INSN_LUID (consumer))) > + if (bitmap_set_bit (in_ready, INSN_LUID (consumer))) > ready_list.safe_push (consumer); > } > else > @@ -8657,8 +8650,6 @@ fix_recovery_deps (basic_block rec) > } > while (insn != note); > > - bitmap_clear (&in_ready); > - > /* Try to add instructions to the ready or queue list. */ > unsigned int i; > rtx_insn *temp; > diff --git a/gcc/ira.c b/gcc/ira.c > index c9751ce81ba..36a779bd37f 100644 > --- a/gcc/ira.c > +++ b/gcc/ira.c > @@ -3635,16 +3635,15 @@ update_equiv_regs (void) > static void > add_store_equivs (void) > { > - bitmap_head seen_insns; > + auto_bitmap seen_insns; > > - bitmap_initialize (&seen_insns, NULL); > for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn)) > { > rtx set, src, dest; > unsigned regno; > rtx_insn *init_insn; > > - bitmap_set_bit (&seen_insns, INSN_UID (insn)); > + bitmap_set_bit (seen_insns, INSN_UID (insn)); > > if (! INSN_P (insn)) > continue; > @@ -3665,7 +3664,7 @@ add_store_equivs (void) > && ! reg_equiv[regno].pdx_subregs > && reg_equiv[regno].init_insns != NULL > && (init_insn = reg_equiv[regno].init_insns->insn ()) != 0 > - && bitmap_bit_p (&seen_insns, INSN_UID (init_insn)) > + && bitmap_bit_p (seen_insns, INSN_UID (init_insn)) > && ! find_reg_note (init_insn, REG_EQUIV, NULL_RTX) > && validate_equiv_mem (init_insn, src, dest) == valid_reload > && ! memref_used_between_p (dest, init_insn, insn) > @@ -3685,7 +3684,6 @@ add_store_equivs (void) > INSN_UID (insn)); > } > } > - bitmap_clear (&seen_insns); > } > > /* Scan all regs killed in an insn to see if any of them are registers > @@ -4485,9 +4483,8 @@ find_moveable_pseudos (void) > moved freely downwards, but are otherwise transparent to a block. */ > bitmap_head *bb_moveable_reg_sets = XNEWVEC (bitmap_head, > last_basic_block_for_fn (cfun)); > - bitmap_head live, used, set, interesting, unusable_as_input; > + auto_bitmap live, used, set, interesting, unusable_as_input; > bitmap_iterator bi; > - bitmap_initialize (&interesting, 0); > > first_moveable_pseudo = max_regs; > pseudo_replaced_reg.release (); > @@ -4497,10 +4494,6 @@ find_moveable_pseudos (void) > calculate_dominance_info (CDI_DOMINATORS); > > i = 0; > - bitmap_initialize (&live, 0); > - bitmap_initialize (&used, 0); > - bitmap_initialize (&set, 0); > - bitmap_initialize (&unusable_as_input, 0); > FOR_EACH_BB_FN (bb, cfun) > { > rtx_insn *insn; > @@ -4511,13 +4504,13 @@ find_moveable_pseudos (void) > bitmap_initialize (local, 0); > bitmap_initialize (transp, 0); > bitmap_initialize (moveable, 0); > - bitmap_copy (&live, df_get_live_out (bb)); > - bitmap_and_into (&live, df_get_live_in (bb)); > - bitmap_copy (transp, &live); > + bitmap_copy (live, df_get_live_out (bb)); > + bitmap_and_into (live, df_get_live_in (bb)); > + bitmap_copy (transp, live); > bitmap_clear (moveable); > - bitmap_clear (&live); > - bitmap_clear (&used); > - bitmap_clear (&set); > + bitmap_clear (live); > + bitmap_clear (used); > + bitmap_clear (set); > FOR_BB_INSNS (bb, insn) > if (NONDEBUG_INSN_P (insn)) > { > @@ -4531,20 +4524,20 @@ find_moveable_pseudos (void) > if (use > && def > && DF_REF_REGNO (use) == DF_REF_REGNO (def) > - && !bitmap_bit_p (&set, DF_REF_REGNO (use)) > + && !bitmap_bit_p (set, DF_REF_REGNO (use)) > && rtx_moveable_p (&PATTERN (insn), OP_IN)) > { > unsigned regno = DF_REF_REGNO (use); > bitmap_set_bit (moveable, regno); > - bitmap_set_bit (&set, regno); > - bitmap_set_bit (&used, regno); > + bitmap_set_bit (set, regno); > + bitmap_set_bit (used, regno); > bitmap_clear_bit (transp, regno); > continue; > } > FOR_EACH_INSN_INFO_USE (use, insn_info) > { > unsigned regno = DF_REF_REGNO (use); > - bitmap_set_bit (&used, regno); > + bitmap_set_bit (used, regno); > if (bitmap_clear_bit (moveable, regno)) > bitmap_clear_bit (transp, regno); > } > @@ -4552,17 +4545,13 @@ find_moveable_pseudos (void) > FOR_EACH_INSN_INFO_DEF (def, insn_info) > { > unsigned regno = DF_REF_REGNO (def); > - bitmap_set_bit (&set, regno); > + bitmap_set_bit (set, regno); > bitmap_clear_bit (transp, regno); > bitmap_clear_bit (moveable, regno); > } > } > } > > - bitmap_clear (&live); > - bitmap_clear (&used); > - bitmap_clear (&set); > - > FOR_EACH_BB_FN (bb, cfun) > { > bitmap local = bb_local + bb->index; > @@ -4605,7 +4594,7 @@ find_moveable_pseudos (void) > if (dump_file) > fprintf (dump_file, "Ignoring reg %d, has equiv memory\n", > regno); > - bitmap_set_bit (&unusable_as_input, regno); > + bitmap_set_bit (unusable_as_input, regno); > continue; > } > > @@ -4665,7 +4654,7 @@ find_moveable_pseudos (void) > continue; > } > > - bitmap_set_bit (&interesting, regno); > + bitmap_set_bit (interesting, regno); > /* If we get here, we know closest_use is a non-NULL insn > (as opposed to const_0_rtx). */ > closest_uses[regno] = as_a (closest_use); > @@ -4684,7 +4673,7 @@ find_moveable_pseudos (void) > } > } > > - EXECUTE_IF_SET_IN_BITMAP (&interesting, 0, i, bi) > + EXECUTE_IF_SET_IN_BITMAP (interesting, 0, i, bi) > { > df_ref def = DF_REG_DEF_CHAIN (i); > rtx_insn *def_insn = DF_REF_INSN (def); > @@ -4728,7 +4717,7 @@ find_moveable_pseudos (void) > FOR_EACH_INSN_USE (use, def_insn) > { > unsigned regno = DF_REF_REGNO (use); > - if (bitmap_bit_p (&unusable_as_input, regno)) > + if (bitmap_bit_p (unusable_as_input, regno)) > { > all_ok = false; > if (dump_file) > @@ -4794,8 +4783,6 @@ find_moveable_pseudos (void) > bitmap_clear (bb_transp_live + bb->index); > bitmap_clear (bb_moveable_reg_sets + bb->index); > } > - bitmap_clear (&interesting); > - bitmap_clear (&unusable_as_input); > free (uid_luid); > free (closest_uses); > free (bb_local); > @@ -4875,14 +4862,12 @@ split_live_ranges_for_shrink_wrap (void) > basic_block bb, call_dom = NULL; > basic_block first = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)); > rtx_insn *insn, *last_interesting_insn = NULL; > - bitmap_head need_new, reachable; > + auto_bitmap need_new, reachable; > vec queue; > > if (!SHRINK_WRAPPING_ENABLED) > return false; > > - bitmap_initialize (&need_new, 0); > - bitmap_initialize (&reachable, 0); > queue.create (n_basic_blocks_for_fn (cfun)); > > FOR_EACH_BB_FN (bb, cfun) > @@ -4891,22 +4876,18 @@ split_live_ranges_for_shrink_wrap (void) > { > if (bb == first) > { > - bitmap_clear (&need_new); > - bitmap_clear (&reachable); > queue.release (); > return false; > } > > - bitmap_set_bit (&need_new, bb->index); > - bitmap_set_bit (&reachable, bb->index); > + bitmap_set_bit (need_new, bb->index); > + bitmap_set_bit (reachable, bb->index); > queue.quick_push (bb); > break; > } > > if (queue.is_empty ()) > { > - bitmap_clear (&need_new); > - bitmap_clear (&reachable); > queue.release (); > return false; > } > @@ -4919,7 +4900,7 @@ split_live_ranges_for_shrink_wrap (void) > bb = queue.pop (); > FOR_EACH_EDGE (e, ei, bb->succs) > if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun) > - && bitmap_set_bit (&reachable, e->dest->index)) > + && bitmap_set_bit (reachable, e->dest->index)) > queue.quick_push (e->dest); > } > queue.release (); > @@ -4931,32 +4912,23 @@ split_live_ranges_for_shrink_wrap (void) > continue; > > if (DF_REG_DEF_COUNT (REGNO (dest)) > 1) > - { > - bitmap_clear (&need_new); > - bitmap_clear (&reachable); > - return false; > - } > + return false; > > for (df_ref use = DF_REG_USE_CHAIN (REGNO(dest)); > use; > use = DF_REF_NEXT_REG (use)) > { > int ubbi = DF_REF_BB (use)->index; > - if (bitmap_bit_p (&reachable, ubbi)) > - bitmap_set_bit (&need_new, ubbi); > + if (bitmap_bit_p (reachable, ubbi)) > + bitmap_set_bit (need_new, ubbi); > } > last_interesting_insn = insn; > } > > - bitmap_clear (&reachable); > if (!last_interesting_insn) > - { > - bitmap_clear (&need_new); > - return false; > - } > + return false; > > - call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, &need_new); > - bitmap_clear (&need_new); > + call_dom = nearest_common_dominator_for_set (CDI_DOMINATORS, need_new); > if (call_dom == first) > return false; > > diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c > index 30fd7597450..20bdafdb580 100644 > --- a/gcc/print-rtl.c > +++ b/gcc/print-rtl.c > @@ -90,7 +90,6 @@ rtx_writer::rtx_writer (FILE *outf, int ind, bool simple, bool compact, > rtx_reuse_manager::rtx_reuse_manager () > : m_next_id (0) > { > - bitmap_initialize (&m_defs_seen, NULL); > } > > /* Determine if X is of a kind suitable for dumping via reuse_rtx. */ > @@ -158,7 +157,7 @@ rtx_reuse_manager::has_reuse_id (const_rtx x, int *out) > bool > rtx_reuse_manager::seen_def_p (int reuse_id) > { > - return bitmap_bit_p (&m_defs_seen, reuse_id); > + return bitmap_bit_p (m_defs_seen, reuse_id); > } > > /* Record that the definition of the given reuse ID has been seen. */ > @@ -166,7 +165,7 @@ rtx_reuse_manager::seen_def_p (int reuse_id) > void > rtx_reuse_manager::set_seen_def (int reuse_id) > { > - bitmap_set_bit (&m_defs_seen, reuse_id); > + bitmap_set_bit (m_defs_seen, reuse_id); > } > > #endif /* #ifndef GENERATOR_FILE */ > diff --git a/gcc/print-rtl.h b/gcc/print-rtl.h > index 81dfcba62cf..eee949a1792 100644 > --- a/gcc/print-rtl.h > +++ b/gcc/print-rtl.h > @@ -153,7 +153,7 @@ class rtx_reuse_manager > private: > hash_map m_rtx_occurrence_count; > hash_map m_rtx_reuse_ids; > - bitmap_head m_defs_seen; > + auto_bitmap m_defs_seen; > int m_next_id; > }; > > -- > 2.11.0 >