From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14146 invoked by alias); 10 May 2017 08:29:22 -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 12573 invoked by uid 89); 10 May 2017 08:29:19 -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-f67.google.com Received: from mail-oi0-f67.google.com (HELO mail-oi0-f67.google.com) (209.85.218.67) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 10 May 2017 08:29:15 +0000 Received: by mail-oi0-f67.google.com with SMTP id w10so3945234oif.1 for ; Wed, 10 May 2017 01:29:17 -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=1e0JjXOtwI2Hc0tqrdCJyePUz89wN1wD8B2pX2aH9R4=; b=sd6ghjmjEvyDRqlmU9V7B4/nxSvqhIePoz0gtSCaGsJuwM0rssQwU3bnri1bcYjLlM U6pZBtAxeN0Z38HhpRAEhIVMiPibTCB7gg4YW59kxCvWljyUABPGPO+u/KvsbfK/4q7c ceh1z7Q/NDoFeh5SRRuo+6GLaAd/iK0HfZDJbKM5U5PYm3ydbwSGxMZnuUF829RVU+jV YX45xXF42gn1+NchzSCkq8XCaFh/R241qD/widbyiGUySnO5xZ1OPk6+GCvEit8zn1ip 5SCIkYSxmCjwCth4qeWH7Bu6Eehuvrs0OceqwErrI92R5xXDzngQtzCrylJg8/K75SjI 7mqQ== X-Gm-Message-State: AODbwcBoNqAcYe0EnKQJckGQleGMsAydfFatM/WEWz3I2fOXBpJxhqqH CXyYbzDUFKz2w19oWcPjaArxz0nsBQ== X-Received: by 10.157.26.125 with SMTP id u58mr2027604otu.167.1494404955613; Wed, 10 May 2017 01:29:15 -0700 (PDT) MIME-Version: 1.0 Received: by 10.157.51.83 with HTTP; Wed, 10 May 2017 01:29:15 -0700 (PDT) In-Reply-To: <20170509205242.2237-10-tbsaunde+gcc@tbsaunde.org> References: <20170509205242.2237-1-tbsaunde+gcc@tbsaunde.org> <20170509205242.2237-10-tbsaunde+gcc@tbsaunde.org> From: Richard Biener Date: Wed, 10 May 2017 08:31:00 -0000 Message-ID: Subject: Re: [PATCH 09/13] use auto_bitmap more with alternate obstacks To: tbsaunde+gcc@tbsaunde.org Cc: GCC Patches Content-Type: text/plain; charset=UTF-8 X-IsSubscribed: yes X-SW-Source: 2017-05/txt/msg00756.txt.bz2 On Tue, May 9, 2017 at 10:52 PM, wrote: > From: Trevor Saunders > > gcc/ChangeLog: Ok. > 2017-05-09 Trevor Saunders > > * df-core.c (df_set_blocks): Start using auto_bitmap. > (df_compact_blocks): Likewise. > * df-problems.c (df_rd_confluence_n): Likewise. > * df-scan.c (df_insn_rescan_all): Likewise. > (df_process_deferred_rescans): Likewise. > (df_update_entry_block_defs): Likewise. > (df_update_exit_block_uses): Likewise. > (df_entry_block_bitmap_verify): Likewise. > (df_exit_block_bitmap_verify): Likewise. > (df_scan_verify): Likewise. > * lra-constraints.c (lra_constraints): Likewise. > (undo_optional_reloads): Likewise. > (lra_undo_inheritance): Likewise. > * lra-remat.c (calculate_gen_cands): Likewise. > (do_remat): Likewise. > * lra-spills.c (assign_spill_hard_regs): Likewise. > (spill_pseudos): Likewise. > * tree-ssa-pre.c (bitmap_set_and): Likewise. > (bitmap_set_subtract_values): Likewise. > --- > gcc/df-core.c | 30 +++++++---------- > gcc/df-problems.c | 10 +++--- > gcc/df-scan.c | 93 ++++++++++++++++++++------------------------------- > gcc/lra-constraints.c | 42 ++++++++++------------- > gcc/lra-remat.c | 43 ++++++++++-------------- > gcc/lra-spills.c | 25 ++++++-------- > gcc/tree-ssa-pre.c | 17 ++++------ > 7 files changed, 104 insertions(+), 156 deletions(-) > > diff --git a/gcc/df-core.c b/gcc/df-core.c > index 98787a768c6..1b270d417aa 100644 > --- a/gcc/df-core.c > +++ b/gcc/df-core.c > @@ -497,9 +497,8 @@ df_set_blocks (bitmap blocks) > /* This block is called to change the focus from one subset > to another. */ > int p; > - bitmap_head diff; > - bitmap_initialize (&diff, &df_bitmap_obstack); > - bitmap_and_compl (&diff, df->blocks_to_analyze, blocks); > + auto_bitmap diff (&df_bitmap_obstack); > + bitmap_and_compl (diff, df->blocks_to_analyze, blocks); > for (p = 0; p < df->num_problems_defined; p++) > { > struct dataflow *dflow = df->problems_in_order[p]; > @@ -510,7 +509,7 @@ df_set_blocks (bitmap blocks) > bitmap_iterator bi; > unsigned int bb_index; > > - EXECUTE_IF_SET_IN_BITMAP (&diff, 0, bb_index, bi) > + EXECUTE_IF_SET_IN_BITMAP (diff, 0, bb_index, bi) > { > basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index); > if (bb) > @@ -522,8 +521,6 @@ df_set_blocks (bitmap blocks) > } > } > } > - > - bitmap_clear (&diff); > } > else > { > @@ -1652,9 +1649,8 @@ df_compact_blocks (void) > int i, p; > basic_block bb; > void *problem_temps; > - bitmap_head tmp; > > - bitmap_initialize (&tmp, &df_bitmap_obstack); > + auto_bitmap tmp (&df_bitmap_obstack); > for (p = 0; p < df->num_problems_defined; p++) > { > struct dataflow *dflow = df->problems_in_order[p]; > @@ -1663,17 +1659,17 @@ df_compact_blocks (void) > dflow problem. */ > if (dflow->out_of_date_transfer_functions) > { > - bitmap_copy (&tmp, dflow->out_of_date_transfer_functions); > + bitmap_copy (tmp, dflow->out_of_date_transfer_functions); > bitmap_clear (dflow->out_of_date_transfer_functions); > - if (bitmap_bit_p (&tmp, ENTRY_BLOCK)) > + if (bitmap_bit_p (tmp, ENTRY_BLOCK)) > bitmap_set_bit (dflow->out_of_date_transfer_functions, ENTRY_BLOCK); > - if (bitmap_bit_p (&tmp, EXIT_BLOCK)) > + if (bitmap_bit_p (tmp, EXIT_BLOCK)) > bitmap_set_bit (dflow->out_of_date_transfer_functions, EXIT_BLOCK); > > i = NUM_FIXED_BLOCKS; > FOR_EACH_BB_FN (bb, cfun) > { > - if (bitmap_bit_p (&tmp, bb->index)) > + if (bitmap_bit_p (tmp, bb->index)) > bitmap_set_bit (dflow->out_of_date_transfer_functions, i); > i++; > } > @@ -1711,23 +1707,21 @@ df_compact_blocks (void) > > if (df->blocks_to_analyze) > { > - if (bitmap_bit_p (&tmp, ENTRY_BLOCK)) > + if (bitmap_bit_p (tmp, ENTRY_BLOCK)) > bitmap_set_bit (df->blocks_to_analyze, ENTRY_BLOCK); > - if (bitmap_bit_p (&tmp, EXIT_BLOCK)) > + if (bitmap_bit_p (tmp, EXIT_BLOCK)) > bitmap_set_bit (df->blocks_to_analyze, EXIT_BLOCK); > - bitmap_copy (&tmp, df->blocks_to_analyze); > + bitmap_copy (tmp, df->blocks_to_analyze); > bitmap_clear (df->blocks_to_analyze); > i = NUM_FIXED_BLOCKS; > FOR_EACH_BB_FN (bb, cfun) > { > - if (bitmap_bit_p (&tmp, bb->index)) > + if (bitmap_bit_p (tmp, bb->index)) > bitmap_set_bit (df->blocks_to_analyze, i); > i++; > } > } > > - bitmap_clear (&tmp); > - > i = NUM_FIXED_BLOCKS; > FOR_EACH_BB_FN (bb, cfun) > { > diff --git a/gcc/df-problems.c b/gcc/df-problems.c > index 92323a39d8a..755aecf46df 100644 > --- a/gcc/df-problems.c > +++ b/gcc/df-problems.c > @@ -461,19 +461,17 @@ df_rd_confluence_n (edge e) > bitmap dense_invalidated = &problem_data->dense_invalidated_by_call; > bitmap_iterator bi; > unsigned int regno; > - bitmap_head tmp; > > - bitmap_initialize (&tmp, &df_bitmap_obstack); > - bitmap_and_compl (&tmp, op2, dense_invalidated); > + auto_bitmap tmp (&df_bitmap_obstack); > + bitmap_and_compl (tmp, op2, dense_invalidated); > > EXECUTE_IF_SET_IN_BITMAP (sparse_invalidated, 0, regno, bi) > { > - bitmap_clear_range (&tmp, > + bitmap_clear_range (tmp, > DF_DEFS_BEGIN (regno), > DF_DEFS_COUNT (regno)); > } > - changed |= bitmap_ior_into (op1, &tmp); > - bitmap_clear (&tmp); > + changed |= bitmap_ior_into (op1, tmp); > return changed; > } > else > diff --git a/gcc/df-scan.c b/gcc/df-scan.c > index f75098c2bec..4884608b167 100644 > --- a/gcc/df-scan.c > +++ b/gcc/df-scan.c > @@ -1161,9 +1161,6 @@ df_insn_rescan_all (void) > basic_block bb; > bitmap_iterator bi; > unsigned int uid; > - bitmap_head tmp; > - > - bitmap_initialize (&tmp, &df_bitmap_obstack); > > if (df->changeable_flags & DF_NO_INSN_RESCAN) > { > @@ -1177,15 +1174,15 @@ df_insn_rescan_all (void) > defer_insn_rescan = true; > } > > - bitmap_copy (&tmp, &df->insns_to_delete); > - EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi) > + auto_bitmap tmp (&df_bitmap_obstack); > + bitmap_copy (tmp, &df->insns_to_delete); > + EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi) > { > struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); > if (insn_info) > df_insn_info_delete (uid); > } > > - bitmap_clear (&tmp); > bitmap_clear (&df->insns_to_delete); > bitmap_clear (&df->insns_to_rescan); > bitmap_clear (&df->insns_to_notes_rescan); > @@ -1215,9 +1212,6 @@ df_process_deferred_rescans (void) > bool defer_insn_rescan = false; > bitmap_iterator bi; > unsigned int uid; > - bitmap_head tmp; > - > - bitmap_initialize (&tmp, &df_bitmap_obstack); > > if (df->changeable_flags & DF_NO_INSN_RESCAN) > { > @@ -1234,24 +1228,25 @@ df_process_deferred_rescans (void) > if (dump_file) > fprintf (dump_file, "starting the processing of deferred insns\n"); > > - bitmap_copy (&tmp, &df->insns_to_delete); > - EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi) > + auto_bitmap tmp (&df_bitmap_obstack); > + bitmap_copy (tmp, &df->insns_to_delete); > + EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi) > { > struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); > if (insn_info) > df_insn_info_delete (uid); > } > > - bitmap_copy (&tmp, &df->insns_to_rescan); > - EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi) > + bitmap_copy (tmp, &df->insns_to_rescan); > + EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi) > { > struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); > if (insn_info) > df_insn_rescan (insn_info->insn); > } > > - bitmap_copy (&tmp, &df->insns_to_notes_rescan); > - EXECUTE_IF_SET_IN_BITMAP (&tmp, 0, uid, bi) > + bitmap_copy (tmp, &df->insns_to_notes_rescan); > + EXECUTE_IF_SET_IN_BITMAP (tmp, 0, uid, bi) > { > struct df_insn_info *insn_info = DF_INSN_UID_SAFE_GET (uid); > if (insn_info) > @@ -1261,7 +1256,6 @@ df_process_deferred_rescans (void) > if (dump_file) > fprintf (dump_file, "ending the processing of deferred insns\n"); > > - bitmap_clear (&tmp); > bitmap_clear (&df->insns_to_delete); > bitmap_clear (&df->insns_to_rescan); > bitmap_clear (&df->insns_to_notes_rescan); > @@ -3628,14 +3622,13 @@ df_record_entry_block_defs (bitmap entry_block_defs) > void > df_update_entry_block_defs (void) > { > - bitmap_head refs; > bool changed = false; > > - bitmap_initialize (&refs, &df_bitmap_obstack); > - df_get_entry_block_def_set (&refs); > + auto_bitmap refs (&df_bitmap_obstack); > + df_get_entry_block_def_set (refs); > if (df->entry_block_defs) > { > - if (!bitmap_equal_p (df->entry_block_defs, &refs)) > + if (!bitmap_equal_p (df->entry_block_defs, refs)) > { > struct df_scan_bb_info *bb_info = df_scan_get_bb_info (ENTRY_BLOCK); > df_ref_chain_delete_du_chain (bb_info->artificial_defs); > @@ -3655,11 +3648,10 @@ df_update_entry_block_defs (void) > > if (changed) > { > - df_record_entry_block_defs (&refs); > - bitmap_copy (df->entry_block_defs, &refs); > + df_record_entry_block_defs (refs); > + bitmap_copy (df->entry_block_defs, refs); > df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, ENTRY_BLOCK)); > } > - bitmap_clear (&refs); > } > > > @@ -3804,14 +3796,13 @@ df_record_exit_block_uses (bitmap exit_block_uses) > void > df_update_exit_block_uses (void) > { > - bitmap_head refs; > bool changed = false; > > - bitmap_initialize (&refs, &df_bitmap_obstack); > - df_get_exit_block_use_set (&refs); > + auto_bitmap refs (&df_bitmap_obstack); > + df_get_exit_block_use_set (refs); > if (df->exit_block_uses) > { > - if (!bitmap_equal_p (df->exit_block_uses, &refs)) > + if (!bitmap_equal_p (df->exit_block_uses, refs)) > { > struct df_scan_bb_info *bb_info = df_scan_get_bb_info (EXIT_BLOCK); > df_ref_chain_delete_du_chain (bb_info->artificial_uses); > @@ -3831,11 +3822,10 @@ df_update_exit_block_uses (void) > > if (changed) > { > - df_record_exit_block_uses (&refs); > - bitmap_copy (df->exit_block_uses,& refs); > + df_record_exit_block_uses (refs); > + bitmap_copy (df->exit_block_uses, refs); > df_set_bb_dirty (BASIC_BLOCK_FOR_FN (cfun, EXIT_BLOCK)); > } > - bitmap_clear (&refs); > } > > static bool initialized = false; > @@ -4171,25 +4161,22 @@ df_bb_verify (basic_block bb) > static bool > df_entry_block_bitmap_verify (bool abort_if_fail) > { > - bitmap_head entry_block_defs; > bool is_eq; > > - bitmap_initialize (&entry_block_defs, &df_bitmap_obstack); > - df_get_entry_block_def_set (&entry_block_defs); > + auto_bitmap entry_block_defs (&df_bitmap_obstack); > + df_get_entry_block_def_set (entry_block_defs); > > - is_eq = bitmap_equal_p (&entry_block_defs, df->entry_block_defs); > + is_eq = bitmap_equal_p (entry_block_defs, df->entry_block_defs); > > if (!is_eq && abort_if_fail) > { > fprintf (stderr, "entry_block_defs = "); > - df_print_regset (stderr, &entry_block_defs); > + df_print_regset (stderr, entry_block_defs); > fprintf (stderr, "df->entry_block_defs = "); > df_print_regset (stderr, df->entry_block_defs); > gcc_assert (0); > } > > - bitmap_clear (&entry_block_defs); > - > return is_eq; > } > > @@ -4200,25 +4187,22 @@ df_entry_block_bitmap_verify (bool abort_if_fail) > static bool > df_exit_block_bitmap_verify (bool abort_if_fail) > { > - bitmap_head exit_block_uses; > bool is_eq; > > - bitmap_initialize (&exit_block_uses, &df_bitmap_obstack); > - df_get_exit_block_use_set (&exit_block_uses); > + auto_bitmap exit_block_uses (&df_bitmap_obstack); > + df_get_exit_block_use_set (exit_block_uses); > > - is_eq = bitmap_equal_p (&exit_block_uses, df->exit_block_uses); > + is_eq = bitmap_equal_p (exit_block_uses, df->exit_block_uses); > > if (!is_eq && abort_if_fail) > { > fprintf (stderr, "exit_block_uses = "); > - df_print_regset (stderr, &exit_block_uses); > + df_print_regset (stderr, exit_block_uses); > fprintf (stderr, "df->exit_block_uses = "); > df_print_regset (stderr, df->exit_block_uses); > gcc_assert (0); > } > > - bitmap_clear (&exit_block_uses); > - > return is_eq; > } > > @@ -4231,8 +4215,6 @@ df_scan_verify (void) > { > unsigned int i; > basic_block bb; > - bitmap_head regular_block_artificial_uses; > - bitmap_head eh_block_artificial_uses; > > if (!df) > return; > @@ -4253,24 +4235,21 @@ df_scan_verify (void) > /* (2) There are various bitmaps whose value may change over the > course of the compilation. This step recomputes them to make > sure that they have not slipped out of date. */ > - bitmap_initialize (®ular_block_artificial_uses, &df_bitmap_obstack); > - bitmap_initialize (&eh_block_artificial_uses, &df_bitmap_obstack); > + auto_bitmap regular_block_artificial_uses (&df_bitmap_obstack); > + auto_bitmap eh_block_artificial_uses (&df_bitmap_obstack); > > - df_get_regular_block_artificial_uses (®ular_block_artificial_uses); > - df_get_eh_block_artificial_uses (&eh_block_artificial_uses); > + df_get_regular_block_artificial_uses (regular_block_artificial_uses); > + df_get_eh_block_artificial_uses (eh_block_artificial_uses); > > - bitmap_ior_into (&eh_block_artificial_uses, > - ®ular_block_artificial_uses); > + bitmap_ior_into (eh_block_artificial_uses, > + regular_block_artificial_uses); > > /* Check artificial_uses bitmaps didn't change. */ > - gcc_assert (bitmap_equal_p (®ular_block_artificial_uses, > + gcc_assert (bitmap_equal_p (regular_block_artificial_uses, > &df->regular_block_artificial_uses)); > - gcc_assert (bitmap_equal_p (&eh_block_artificial_uses, > + gcc_assert (bitmap_equal_p (eh_block_artificial_uses, > &df->eh_block_artificial_uses)); > > - bitmap_clear (®ular_block_artificial_uses); > - bitmap_clear (&eh_block_artificial_uses); > - > /* Verify entry block and exit block. These only verify the bitmaps, > the refs are verified in df_bb_verify. */ > df_entry_block_bitmap_verify (true); > diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c > index c8bc9b9a66f..ed4fdc49d7c 100644 > --- a/gcc/lra-constraints.c > +++ b/gcc/lra-constraints.c > @@ -4644,7 +4644,6 @@ lra_constraints (bool first_p) > unsigned int min_len, new_min_len, uid; > rtx set, x, reg, dest_reg; > basic_block last_bb; > - bitmap_head equiv_insn_bitmap; > bitmap_iterator bi; > > lra_constraint_iter++; > @@ -4676,7 +4675,7 @@ lra_constraints (bool first_p) > /* Do elimination before the equivalence processing as we can spill > some pseudos during elimination. */ > lra_eliminate (false, first_p); > - bitmap_initialize (&equiv_insn_bitmap, ®_obstack); > + auto_bitmap equiv_insn_bitmap (®_obstack); > for (i = FIRST_PSEUDO_REGISTER; i < new_regno_start; i++) > if (lra_reg_info[i].nrefs != 0) > { > @@ -4737,14 +4736,14 @@ lra_constraints (bool first_p) > if (contains_reg_p (x, false, true)) > ira_reg_equiv[i].profitable_p = false; > if (get_equiv (reg) != reg) > - bitmap_ior_into (&equiv_insn_bitmap, &lra_reg_info[i].insn_bitmap); > + bitmap_ior_into (equiv_insn_bitmap, &lra_reg_info[i].insn_bitmap); > } > } > for (i = FIRST_PSEUDO_REGISTER; i < new_regno_start; i++) > update_equiv (i); > /* We should add all insns containing pseudos which should be > substituted by their equivalences. */ > - EXECUTE_IF_SET_IN_BITMAP (&equiv_insn_bitmap, 0, uid, bi) > + EXECUTE_IF_SET_IN_BITMAP (equiv_insn_bitmap, 0, uid, bi) > lra_push_insn_by_uid (uid); > min_len = lra_insn_stack_length (); > new_insns_num = 0; > @@ -4775,7 +4774,7 @@ lra_constraints (bool first_p) > /* We need to check equivalence in debug insn and change > pseudo to the equivalent value if necessary. */ > curr_id = lra_get_insn_recog_data (curr_insn); > - if (bitmap_bit_p (&equiv_insn_bitmap, INSN_UID (curr_insn))) > + if (bitmap_bit_p (equiv_insn_bitmap, INSN_UID (curr_insn))) > { > rtx old = *curr_id->operand_loc[0]; > *curr_id->operand_loc[0] > @@ -4849,7 +4848,7 @@ lra_constraints (bool first_p) > /* Check non-transformed insns too for equiv change as USE > or CLOBBER don't need reloads but can contain pseudos > being changed on their equivalences. */ > - else if (bitmap_bit_p (&equiv_insn_bitmap, INSN_UID (curr_insn)) > + else if (bitmap_bit_p (equiv_insn_bitmap, INSN_UID (curr_insn)) > && loc_equivalence_change_p (&PATTERN (curr_insn))) > { > lra_update_insn_regno_info (curr_insn); > @@ -4857,7 +4856,7 @@ lra_constraints (bool first_p) > } > } > } > - bitmap_clear (&equiv_insn_bitmap); > + > /* If we used a new hard regno, changed_p should be true because the > hard reg is assigned to a new pseudo. */ > if (flag_checking && !changed_p) > @@ -6761,10 +6760,9 @@ undo_optional_reloads (void) > bitmap_iterator bi, bi2; > rtx_insn *insn; > rtx set, src, dest; > - bitmap_head removed_optional_reload_pseudos, insn_bitmap; > + auto_bitmap removed_optional_reload_pseudos (®_obstack); > > - bitmap_initialize (&removed_optional_reload_pseudos, ®_obstack); > - bitmap_copy (&removed_optional_reload_pseudos, &lra_optional_reload_pseudos); > + bitmap_copy (removed_optional_reload_pseudos, &lra_optional_reload_pseudos); > EXECUTE_IF_SET_IN_BITMAP (&lra_optional_reload_pseudos, 0, regno, bi) > { > keep_p = false; > @@ -6799,19 +6797,19 @@ undo_optional_reloads (void) > } > if (keep_p) > { > - bitmap_clear_bit (&removed_optional_reload_pseudos, regno); > + bitmap_clear_bit (removed_optional_reload_pseudos, regno); > if (lra_dump_file != NULL) > fprintf (lra_dump_file, "Keep optional reload reg %d\n", regno); > } > } > - change_p = ! bitmap_empty_p (&removed_optional_reload_pseudos); > - bitmap_initialize (&insn_bitmap, ®_obstack); > - EXECUTE_IF_SET_IN_BITMAP (&removed_optional_reload_pseudos, 0, regno, bi) > + change_p = ! bitmap_empty_p (removed_optional_reload_pseudos); > + auto_bitmap insn_bitmap (®_obstack); > + EXECUTE_IF_SET_IN_BITMAP (removed_optional_reload_pseudos, 0, regno, bi) > { > if (lra_dump_file != NULL) > fprintf (lra_dump_file, "Remove optional reload reg %d\n", regno); > - bitmap_copy (&insn_bitmap, &lra_reg_info[regno].insn_bitmap); > - EXECUTE_IF_SET_IN_BITMAP (&insn_bitmap, 0, uid, bi2) > + bitmap_copy (insn_bitmap, &lra_reg_info[regno].insn_bitmap); > + EXECUTE_IF_SET_IN_BITMAP (insn_bitmap, 0, uid, bi2) > { > insn = lra_insn_recog_data[uid]->insn; > if ((set = single_set (insn)) != NULL_RTX) > @@ -6855,8 +6853,6 @@ undo_optional_reloads (void) > /* Clear restore_regnos. */ > EXECUTE_IF_SET_IN_BITMAP (&lra_optional_reload_pseudos, 0, regno, bi) > lra_reg_info[regno].restore_rtx = NULL_RTX; > - bitmap_clear (&insn_bitmap); > - bitmap_clear (&removed_optional_reload_pseudos); > return change_p; > } > > @@ -6869,7 +6865,6 @@ lra_undo_inheritance (void) > int hard_regno; > int n_all_inherit, n_inherit, n_all_split, n_split; > rtx restore_rtx; > - bitmap_head remove_pseudos; > bitmap_iterator bi; > bool change_p; > > @@ -6880,7 +6875,7 @@ lra_undo_inheritance (void) > fprintf (lra_dump_file, > "\n********** Undoing inheritance #%d: **********\n\n", > lra_undo_inheritance_iter); > - bitmap_initialize (&remove_pseudos, ®_obstack); > + auto_bitmap remove_pseudos (®_obstack); > n_inherit = n_all_inherit = 0; > EXECUTE_IF_SET_IN_BITMAP (&lra_inheritance_pseudos, 0, regno, bi) > if (lra_reg_info[regno].restore_rtx != NULL_RTX) > @@ -6892,7 +6887,7 @@ lra_undo_inheritance (void) > allocation we used shorter live-ranges. */ > && (! REG_P (lra_reg_info[regno].restore_rtx) > || reg_renumber[REGNO (lra_reg_info[regno].restore_rtx)] < 0)) > - bitmap_set_bit (&remove_pseudos, regno); > + bitmap_set_bit (remove_pseudos, regno); > else > n_inherit++; > } > @@ -6910,7 +6905,7 @@ lra_undo_inheritance (void) > hard_regno = (restore_regno >= FIRST_PSEUDO_REGISTER > ? reg_renumber[restore_regno] : restore_regno); > if (hard_regno < 0 || reg_renumber[regno] == hard_regno) > - bitmap_set_bit (&remove_pseudos, regno); > + bitmap_set_bit (remove_pseudos, regno); > else > { > n_split++; > @@ -6923,8 +6918,7 @@ lra_undo_inheritance (void) > fprintf (lra_dump_file, "Split %d out of %d (%.2f%%)\n", > n_split, n_all_split, > (double) n_split / n_all_split * 100); > - change_p = remove_inheritance_pseudos (&remove_pseudos); > - bitmap_clear (&remove_pseudos); > + change_p = remove_inheritance_pseudos (remove_pseudos); > /* Clear restore_regnos. */ > EXECUTE_IF_SET_IN_BITMAP (&lra_inheritance_pseudos, 0, regno, bi) > lra_reg_info[regno].restore_rtx = NULL_RTX; > diff --git a/gcc/lra-remat.c b/gcc/lra-remat.c > index 2c51481374a..fb294edf368 100644 > --- a/gcc/lra-remat.c > +++ b/gcc/lra-remat.c > @@ -746,14 +746,12 @@ calculate_gen_cands (void) > { > basic_block bb; > bitmap gen_cands; > - bitmap_head gen_insns; > rtx_insn *insn; > > - bitmap_initialize (&gen_insns, ®_obstack); > FOR_EACH_BB_FN (bb, cfun) > { > gen_cands = &get_remat_bb_data (bb)->gen_cands; > - bitmap_clear (&gen_insns); > + auto_bitmap gen_insns (®_obstack); > FOR_BB_INSNS (bb, insn) > if (INSN_P (insn)) > { > @@ -782,7 +780,7 @@ calculate_gen_cands (void) > reg = reg->next) > if (reg->type != OP_IN > || find_regno_note (insn, REG_DEAD, reg->regno) != NULL) > - EXECUTE_IF_SET_IN_BITMAP (&gen_insns, 0, uid, bi) > + EXECUTE_IF_SET_IN_BITMAP (gen_insns, 0, uid, bi) > { > rtx_insn *insn2 = lra_insn_recog_data[uid]->insn; > > @@ -801,7 +799,7 @@ calculate_gen_cands (void) > } > > if (CALL_P (insn)) > - EXECUTE_IF_SET_IN_BITMAP (&gen_insns, 0, uid, bi) > + EXECUTE_IF_SET_IN_BITMAP (gen_insns, 0, uid, bi) > { > rtx_insn *insn2 = lra_insn_recog_data[uid]->insn; > > @@ -813,17 +811,16 @@ calculate_gen_cands (void) > bitmap_set_bit (&temp_bitmap, uid); > } > } > - bitmap_and_compl_into (&gen_insns, &temp_bitmap); > + bitmap_and_compl_into (gen_insns, &temp_bitmap); > > cand = insn_to_cand[INSN_UID (insn)]; > if (cand != NULL) > { > bitmap_set_bit (gen_cands, cand->index); > - bitmap_set_bit (&gen_insns, INSN_UID (insn)); > + bitmap_set_bit (gen_insns, INSN_UID (insn)); > } > } > } > - bitmap_clear (&gen_insns); > } > > > @@ -1059,15 +1056,13 @@ do_remat (void) > unsigned regno; > rtx_insn *insn; > basic_block bb; > - bitmap_head avail_cands; > - bitmap_head active_cands; > bool changed_p = false; > /* Living hard regs and hard registers of living pseudos. */ > HARD_REG_SET live_hard_regs; > bitmap_iterator bi; > > - bitmap_initialize (&avail_cands, ®_obstack); > - bitmap_initialize (&active_cands, ®_obstack); > + auto_bitmap avail_cands (®_obstack); > + auto_bitmap active_cands (®_obstack); > FOR_EACH_BB_FN (bb, cfun) > { > CLEAR_HARD_REG_SET (live_hard_regs); > @@ -1079,11 +1074,11 @@ do_remat (void) > if (hard_regno >= 0) > SET_HARD_REG_BIT (live_hard_regs, hard_regno); > } > - bitmap_and (&avail_cands, &get_remat_bb_data (bb)->avin_cands, > + bitmap_and (avail_cands, &get_remat_bb_data (bb)->avin_cands, > &get_remat_bb_data (bb)->livein_cands); > /* Activating insns are always in the same block as their corresponding > remat insn, so at the start of a block the two bitsets are equal. */ > - bitmap_copy (&active_cands, &avail_cands); > + bitmap_copy (active_cands, avail_cands); > FOR_BB_INSNS (bb, insn) > { > if (!NONDEBUG_INSN_P (insn)) > @@ -1117,8 +1112,8 @@ do_remat (void) > for (cand = regno_cands[src_regno]; > cand != NULL; > cand = cand->next_regno_cand) > - if (bitmap_bit_p (&avail_cands, cand->index) > - && bitmap_bit_p (&active_cands, cand->index)) > + if (bitmap_bit_p (avail_cands, cand->index) > + && bitmap_bit_p (active_cands, cand->index)) > break; > } > int i, hard_regno, nregs; > @@ -1189,7 +1184,7 @@ do_remat (void) > reg = reg->next) > if (reg->type != OP_IN > || find_regno_note (insn, REG_DEAD, reg->regno) != NULL) > - EXECUTE_IF_SET_IN_BITMAP (&avail_cands, 0, cid, bi) > + EXECUTE_IF_SET_IN_BITMAP (avail_cands, 0, cid, bi) > { > cand = all_cands[cid]; > > @@ -1203,7 +1198,7 @@ do_remat (void) > } > > if (CALL_P (insn)) > - EXECUTE_IF_SET_IN_BITMAP (&avail_cands, 0, cid, bi) > + EXECUTE_IF_SET_IN_BITMAP (avail_cands, 0, cid, bi) > { > cand = all_cands[cid]; > > @@ -1211,22 +1206,22 @@ do_remat (void) > bitmap_set_bit (&temp_bitmap, cand->index); > } > > - bitmap_and_compl_into (&avail_cands, &temp_bitmap); > + bitmap_and_compl_into (avail_cands, &temp_bitmap); > > /* Now see whether a candidate is made active or available > by this insn. */ > cand = insn_to_cand_activation[INSN_UID (insn)]; > if (cand) > - bitmap_set_bit (&active_cands, cand->index); > + bitmap_set_bit (active_cands, cand->index); > > cand = insn_to_cand[INSN_UID (insn)]; > if (cand != NULL) > { > - bitmap_set_bit (&avail_cands, cand->index); > + bitmap_set_bit (avail_cands, cand->index); > if (cand->reload_regno == -1) > - bitmap_set_bit (&active_cands, cand->index); > + bitmap_set_bit (active_cands, cand->index); > else > - bitmap_clear_bit (&active_cands, cand->index); > + bitmap_clear_bit (active_cands, cand->index); > } > > if (remat_insn != NULL) > @@ -1274,8 +1269,6 @@ do_remat (void) > SET_HARD_REG_BIT (live_hard_regs, reg->regno); > } > } > - bitmap_clear (&avail_cands); > - bitmap_clear (&active_cands); > return changed_p; > } > > diff --git a/gcc/lra-spills.c b/gcc/lra-spills.c > index 492fc182cf0..3df6f6786a3 100644 > --- a/gcc/lra-spills.c > +++ b/gcc/lra-spills.c > @@ -223,7 +223,6 @@ assign_spill_hard_regs (int *pseudo_regnos, int n) > rtx set; > basic_block bb; > HARD_REG_SET conflict_hard_regs; > - bitmap_head ok_insn_bitmap; > bitmap setjump_crosses = regstat_get_setjmp_crosses (); > /* Hard registers which can not be used for any purpose at given > program point because they are unallocatable or already allocated > @@ -243,13 +242,13 @@ assign_spill_hard_regs (int *pseudo_regnos, int n) > for (p = r->start; p <= r->finish; p++) > add_to_hard_reg_set (&reserved_hard_regs[p], > lra_reg_info[i].biggest_mode, hard_regno); > - bitmap_initialize (&ok_insn_bitmap, ®_obstack); > + auto_bitmap ok_insn_bitmap (®_obstack); > FOR_EACH_BB_FN (bb, cfun) > FOR_BB_INSNS (bb, insn) > if (DEBUG_INSN_P (insn) > || ((set = single_set (insn)) != NULL_RTX > && REG_P (SET_SRC (set)) && REG_P (SET_DEST (set)))) > - bitmap_set_bit (&ok_insn_bitmap, INSN_UID (insn)); > + bitmap_set_bit (ok_insn_bitmap, INSN_UID (insn)); > for (res = i = 0; i < n; i++) > { > regno = pseudo_regnos[i]; > @@ -260,7 +259,7 @@ assign_spill_hard_regs (int *pseudo_regnos, int n) > targetm.spill_class ((reg_class_t) rclass, > PSEUDO_REGNO_MODE (regno)))) == NO_REGS > || bitmap_intersect_compl_p (&lra_reg_info[regno].insn_bitmap, > - &ok_insn_bitmap)) > + ok_insn_bitmap)) > { > pseudo_regnos[res++] = regno; > continue; > @@ -300,7 +299,6 @@ assign_spill_hard_regs (int *pseudo_regnos, int n) > /* Just loop. */ > df_set_regs_ever_live (hard_regno + nr, true); > } > - bitmap_clear (&ok_insn_bitmap); > free (reserved_hard_regs); > return res; > } > @@ -449,17 +447,16 @@ spill_pseudos (void) > basic_block bb; > rtx_insn *insn, *curr; > int i; > - bitmap_head spilled_pseudos, changed_insns; > > - bitmap_initialize (&spilled_pseudos, ®_obstack); > - bitmap_initialize (&changed_insns, ®_obstack); > + auto_bitmap spilled_pseudos (®_obstack); > + auto_bitmap changed_insns (®_obstack); > for (i = FIRST_PSEUDO_REGISTER; i < regs_num; i++) > { > if (lra_reg_info[i].nrefs != 0 && lra_get_regno_hard_regno (i) < 0 > && ! lra_former_scratch_p (i)) > { > - bitmap_set_bit (&spilled_pseudos, i); > - bitmap_ior_into (&changed_insns, &lra_reg_info[i].insn_bitmap); > + bitmap_set_bit (spilled_pseudos, i); > + bitmap_ior_into (changed_insns, &lra_reg_info[i].insn_bitmap); > } > } > FOR_EACH_BB_FN (bb, cfun) > @@ -468,7 +465,7 @@ spill_pseudos (void) > { > bool removed_pseudo_p = false; > > - if (bitmap_bit_p (&changed_insns, INSN_UID (insn))) > + if (bitmap_bit_p (changed_insns, INSN_UID (insn))) > { > rtx *link_loc, link; > > @@ -526,12 +523,10 @@ spill_pseudos (void) > "Debug insn #%u is reset because it referenced " > "removed pseudo\n", INSN_UID (insn)); > } > - bitmap_and_compl_into (df_get_live_in (bb), &spilled_pseudos); > - bitmap_and_compl_into (df_get_live_out (bb), &spilled_pseudos); > + bitmap_and_compl_into (df_get_live_in (bb), spilled_pseudos); > + bitmap_and_compl_into (df_get_live_out (bb), spilled_pseudos); > } > } > - bitmap_clear (&spilled_pseudos); > - bitmap_clear (&changed_insns); > } > > /* Return true if we need to change some pseudos into memory. */ > diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c > index 8175d2599ed..ca212daee62 100644 > --- a/gcc/tree-ssa-pre.c > +++ b/gcc/tree-ssa-pre.c > @@ -817,19 +817,17 @@ bitmap_set_and (bitmap_set_t dest, bitmap_set_t orig) > > if (dest != orig) > { > - bitmap_head temp; > - bitmap_initialize (&temp, &grand_bitmap_obstack); > + auto_bitmap temp (&grand_bitmap_obstack); > > bitmap_and_into (&dest->values, &orig->values); > - bitmap_copy (&temp, &dest->expressions); > - EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi) > + bitmap_copy (temp, &dest->expressions); > + EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi) > { > pre_expr expr = expression_for_id (i); > unsigned int value_id = get_expr_value_id (expr); > if (!bitmap_bit_p (&dest->values, value_id)) > bitmap_clear_bit (&dest->expressions, i); > } > - bitmap_clear (&temp); > } > } > > @@ -862,18 +860,15 @@ bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b) > { > unsigned int i; > bitmap_iterator bi; > - bitmap_head temp; > + auto_bitmap temp (&grand_bitmap_obstack); > > - bitmap_initialize (&temp, &grand_bitmap_obstack); > - > - bitmap_copy (&temp, &a->expressions); > - EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi) > + bitmap_copy (temp, &a->expressions); > + EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi) > { > pre_expr expr = expression_for_id (i); > if (bitmap_set_contains_value (b, get_expr_value_id (expr))) > bitmap_remove_from_set (a, expr); > } > - bitmap_clear (&temp); > } > > > -- > 2.11.0 >