From 3b8266e279c432acdc9feca326cf7410ca584f68 Mon Sep 17 00:00:00 2001 From: Kenneth Zadeck Date: Fri, 20 Jan 2006 01:55:52 +0000 Subject: [PATCH] df-scan.c (df_scan_free_bb_info): Added basic block parameter to be able to clean out basic block when not necessary. 2005-01-19 Kenneth Zadeck * df-scan.c (df_scan_free_bb_info): Added basic block parameter to be able to clean out basic block when not necessary. (df_scan_free): Fixed to properly delete information if df is unused before calling df_finish. (df_scan_alloc, df_rescan_blocks, df_reg_chain_unlink, df_insn_create_insn_record, df_bb_refs_record): Fixed formatting or comment typos. (df_bb_refs_delete): New function. (df_refs_delete): Moved per block code to df_bb_refs_delete. * df-core.c (df_set_blocks): Added code to properly clean out unused blocks if they are not part of the blocks to consider. Added additional null check. (df_compact_blocks): Added basic block parameter to free_bb_fun to be able to clean out basic block when not necessary * df.h (df_free_bb_function): Ditto. (df_bb_refs_delete): New function. * df-problems.c (df_ru_free_bb_info, df_rd_set_bb_info, df_lr_set_bb_info, df_ur_free_bb_info, df_urec_free_bb_info):Added basic block parameter to be able to clean out basic block when not necessary. (df_ru_alloc, df_rd_alloc): Fixed dyslexic overflow test. (df_ru_free, df_rd_free, df_lr_free, df_ur_free, df_urec_free): Fixed to properly delete information if df is unused before calling df_finish. From-SVN: r110009 --- gcc/ChangeLog | 27 +++++++ gcc/df-core.c | 31 +++++++- gcc/df-problems.c | 217 ++++++++++++++++++++++++++++++------------------------ gcc/df-scan.c | 89 +++++++++++++--------- gcc/df.h | 3 +- 5 files changed, 231 insertions(+), 136 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index fec7729..12ad1e2 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,32 @@ 2005-01-19 Kenneth Zadeck + * df-scan.c (df_scan_free_bb_info): Added basic block parameter to + be able to clean out basic block when not necessary. + (df_scan_free): Fixed to properly delete information if df is + unused before calling df_finish. + (df_scan_alloc, df_rescan_blocks, df_reg_chain_unlink, + df_insn_create_insn_record, df_bb_refs_record): Fixed formatting + or comment typos. + (df_bb_refs_delete): New function. + (df_refs_delete): Moved per block code to df_bb_refs_delete. + * df-core.c (df_set_blocks): Added code to properly clean out + unused blocks if they are not part of the blocks to consider. + Added additional null check. + (df_compact_blocks): Added basic block parameter to free_bb_fun to + be able to clean out basic block when not necessary + * df.h (df_free_bb_function): Ditto. + (df_bb_refs_delete): New function. + * df-problems.c (df_ru_free_bb_info, df_rd_set_bb_info, + df_lr_set_bb_info, df_ur_free_bb_info, df_urec_free_bb_info):Added + basic block parameter to be able to clean out basic block when not + necessary. + (df_ru_alloc, df_rd_alloc): Fixed dyslexic overflow test. + (df_ru_free, df_rd_free, df_lr_free, df_ur_free, df_urec_free): + Fixed to properly delete information if df is unused before + calling df_finish. + +2005-01-19 Kenneth Zadeck + PR rtl-optimization/25799 * df-problems.c (df_ru_confluence_n, df_rd_confluence_n): Corrected confluence operator to remove bits from op2 before oring diff --git a/gcc/df-core.c b/gcc/df-core.c index 59602de..87d9324 100644 --- a/gcc/df-core.c +++ b/gcc/df-core.c @@ -354,7 +354,30 @@ df_set_blocks (struct df *df, bitmap blocks) { if (blocks) { - if (!df->blocks_to_analyze) + if (df->blocks_to_analyze) + { + int p; + bitmap diff = BITMAP_ALLOC (NULL); + 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]; + if (*dflow->problem->free_bb_fun) + { + bitmap_iterator bi; + unsigned int bb_index; + + EXECUTE_IF_SET_IN_BITMAP (diff, 0, bb_index, bi) + { + basic_block bb = BASIC_BLOCK (bb_index); + (*dflow->problem->free_bb_fun) (dflow, bb, diff); + } + } + } + + BITMAP_FREE (diff); + } + else df->blocks_to_analyze = BITMAP_ALLOC (NULL); bitmap_copy (df->blocks_to_analyze, blocks); } @@ -781,8 +804,10 @@ df_compact_blocks (struct df *df) These are from orphaned blocks. */ for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++) { - if (problem_temps[i]) - (*dflow->problem->free_bb_fun) (dflow, problem_temps[i]); + basic_block bb = BASIC_BLOCK (i); + if (problem_temps[i] && bb) + (*dflow->problem->free_bb_fun) + (dflow, bb, problem_temps[i]); } } } diff --git a/gcc/df-problems.c b/gcc/df-problems.c index 790b3e2..ecc8eab 100644 --- a/gcc/df-problems.c +++ b/gcc/df-problems.c @@ -324,7 +324,9 @@ df_ru_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_ru_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_ru_free_bb_info (struct dataflow *dflow, + basic_block bb ATTRIBUTE_UNUSED, + void *vbb_info) { struct df_ru_bb_info *bb_info = (struct df_ru_bb_info *) vbb_info; if (bb_info) @@ -687,35 +689,38 @@ df_ru_free (struct dataflow *dflow) struct df_ru_problem_data *problem_data = (struct df_ru_problem_data *) dflow->problem_data; - for (i = 0; i < dflow->block_info_size; i++) + if (problem_data) { - struct df_ru_bb_info *bb_info = df_ru_get_bb_info (dflow, i); - if (bb_info) + for (i = 0; i < dflow->block_info_size; i++) { - BITMAP_FREE (bb_info->kill); - BITMAP_FREE (bb_info->sparse_kill); - BITMAP_FREE (bb_info->gen); - BITMAP_FREE (bb_info->in); - BITMAP_FREE (bb_info->out); + struct df_ru_bb_info *bb_info = df_ru_get_bb_info (dflow, i); + if (bb_info) + { + BITMAP_FREE (bb_info->kill); + BITMAP_FREE (bb_info->sparse_kill); + BITMAP_FREE (bb_info->gen); + BITMAP_FREE (bb_info->in); + BITMAP_FREE (bb_info->out); + } } + + free_alloc_pool (dflow->block_pool); + + for (i = 0; i < problem_data->use_sites_size; i++) + { + bitmap bm = problem_data->use_sites[i]; + if (bm) + BITMAP_FREE (bm); + } + + free (problem_data->use_sites); + BITMAP_FREE (problem_data->sparse_invalidated_by_call); + BITMAP_FREE (problem_data->dense_invalidated_by_call); + + dflow->block_info_size = 0; + free (dflow->block_info); + free (dflow->problem_data); } - - free_alloc_pool (dflow->block_pool); - - for (i = 0; i < problem_data->use_sites_size; i++) - { - bitmap bm = problem_data->use_sites[i]; - if (bm) - BITMAP_FREE (bm); - } - - free (problem_data->use_sites); - BITMAP_FREE (problem_data->sparse_invalidated_by_call); - BITMAP_FREE (problem_data->dense_invalidated_by_call); - - dflow->block_info_size = 0; - free (dflow->block_info); - free (dflow->problem_data); free (dflow); } @@ -837,7 +842,9 @@ df_rd_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_rd_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_rd_free_bb_info (struct dataflow *dflow, + basic_block bb ATTRIBUTE_UNUSED, + void *vbb_info) { struct df_rd_bb_info *bb_info = (struct df_rd_bb_info *) vbb_info; if (bb_info) @@ -1174,35 +1181,38 @@ df_rd_free (struct dataflow *dflow) struct df_rd_problem_data *problem_data = (struct df_rd_problem_data *) dflow->problem_data; - for (i = 0; i < dflow->block_info_size; i++) + if (problem_data) { - struct df_rd_bb_info *bb_info = df_rd_get_bb_info (dflow, i); - if (bb_info) + for (i = 0; i < dflow->block_info_size; i++) { - BITMAP_FREE (bb_info->kill); - BITMAP_FREE (bb_info->sparse_kill); - BITMAP_FREE (bb_info->gen); - BITMAP_FREE (bb_info->in); - BITMAP_FREE (bb_info->out); + struct df_rd_bb_info *bb_info = df_rd_get_bb_info (dflow, i); + if (bb_info) + { + BITMAP_FREE (bb_info->kill); + BITMAP_FREE (bb_info->sparse_kill); + BITMAP_FREE (bb_info->gen); + BITMAP_FREE (bb_info->in); + BITMAP_FREE (bb_info->out); + } } + + free_alloc_pool (dflow->block_pool); + + for (i = 0; i < problem_data->def_sites_size; i++) + { + bitmap bm = problem_data->def_sites[i]; + if (bm) + BITMAP_FREE (bm); + } + + free (problem_data->def_sites); + BITMAP_FREE (problem_data->sparse_invalidated_by_call); + BITMAP_FREE (problem_data->dense_invalidated_by_call); + + dflow->block_info_size = 0; + free (dflow->block_info); + free (dflow->problem_data); } - - free_alloc_pool (dflow->block_pool); - - for (i = 0; i < problem_data->def_sites_size; i++) - { - bitmap bm = problem_data->def_sites[i]; - if (bm) - BITMAP_FREE (bm); - } - - free (problem_data->def_sites); - BITMAP_FREE (problem_data->sparse_invalidated_by_call); - BITMAP_FREE (problem_data->dense_invalidated_by_call); - - dflow->block_info_size = 0; - free (dflow->block_info); - free (dflow->problem_data); free (dflow); } @@ -1315,7 +1325,9 @@ df_lr_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_lr_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_lr_free_bb_info (struct dataflow *dflow, + basic_block bb ATTRIBUTE_UNUSED, + void *vbb_info) { struct df_lr_bb_info *bb_info = (struct df_lr_bb_info *) vbb_info; if (bb_info) @@ -1586,22 +1598,25 @@ df_lr_transfer_function (struct dataflow *dflow, int bb_index) static void df_lr_free (struct dataflow *dflow) { - unsigned int i; - for (i = 0; i < dflow->block_info_size; i++) + if (dflow->block_info) { - struct df_lr_bb_info *bb_info = df_lr_get_bb_info (dflow, i); - if (bb_info) + unsigned int i; + for (i = 0; i < dflow->block_info_size; i++) { - BITMAP_FREE (bb_info->use); - BITMAP_FREE (bb_info->def); - BITMAP_FREE (bb_info->in); - BITMAP_FREE (bb_info->out); + struct df_lr_bb_info *bb_info = df_lr_get_bb_info (dflow, i); + if (bb_info) + { + BITMAP_FREE (bb_info->use); + BITMAP_FREE (bb_info->def); + BITMAP_FREE (bb_info->in); + BITMAP_FREE (bb_info->out); + } } + free_alloc_pool (dflow->block_pool); + + dflow->block_info_size = 0; + free (dflow->block_info); } - free_alloc_pool (dflow->block_pool); - - dflow->block_info_size = 0; - free (dflow->block_info); free (dflow); } @@ -1695,7 +1710,9 @@ df_ur_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_ur_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_ur_free_bb_info (struct dataflow *dflow, + basic_block bb ATTRIBUTE_UNUSED, + void *vbb_info) { struct df_ur_bb_info *bb_info = (struct df_ur_bb_info *) vbb_info; if (bb_info) @@ -1915,23 +1932,26 @@ df_ur_transfer_function (struct dataflow *dflow, int bb_index) static void df_ur_free (struct dataflow *dflow) { - unsigned int i; - - for (i = 0; i < dflow->block_info_size; i++) + if (dflow->block_info) { - struct df_ur_bb_info *bb_info = df_ur_get_bb_info (dflow, i); - if (bb_info) + unsigned int i; + + for (i = 0; i < dflow->block_info_size; i++) { - BITMAP_FREE (bb_info->gen); - BITMAP_FREE (bb_info->kill); - BITMAP_FREE (bb_info->in); - BITMAP_FREE (bb_info->out); + struct df_ur_bb_info *bb_info = df_ur_get_bb_info (dflow, i); + if (bb_info) + { + BITMAP_FREE (bb_info->gen); + BITMAP_FREE (bb_info->kill); + BITMAP_FREE (bb_info->in); + BITMAP_FREE (bb_info->out); + } } + + free_alloc_pool (dflow->block_pool); + dflow->block_info_size = 0; + free (dflow->block_info); } - - free_alloc_pool (dflow->block_pool); - dflow->block_info_size = 0; - free (dflow->block_info); free (dflow); } @@ -2039,7 +2059,9 @@ df_urec_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_urec_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_urec_free_bb_info (struct dataflow *dflow, + basic_block bb ATTRIBUTE_UNUSED, + void *vbb_info) { struct df_urec_bb_info *bb_info = (struct df_urec_bb_info *) vbb_info; if (bb_info) @@ -2529,26 +2551,29 @@ df_urec_transfer_function (struct dataflow *dflow, int bb_index) static void df_urec_free (struct dataflow *dflow) { - unsigned int i; - - for (i = 0; i < dflow->block_info_size; i++) + if (dflow->block_info) { - struct df_urec_bb_info *bb_info = df_urec_get_bb_info (dflow, i); - if (bb_info) + unsigned int i; + + for (i = 0; i < dflow->block_info_size; i++) { - BITMAP_FREE (bb_info->gen); - BITMAP_FREE (bb_info->kill); - BITMAP_FREE (bb_info->in); - BITMAP_FREE (bb_info->out); - BITMAP_FREE (bb_info->earlyclobber); + struct df_urec_bb_info *bb_info = df_urec_get_bb_info (dflow, i); + if (bb_info) + { + BITMAP_FREE (bb_info->gen); + BITMAP_FREE (bb_info->kill); + BITMAP_FREE (bb_info->in); + BITMAP_FREE (bb_info->out); + BITMAP_FREE (bb_info->earlyclobber); + } } + + free_alloc_pool (dflow->block_pool); + + dflow->block_info_size = 0; + free (dflow->block_info); + free (dflow->problem_data); } - - free_alloc_pool (dflow->block_pool); - - dflow->block_info_size = 0; - free (dflow->block_info); - free (dflow->problem_data); free (dflow); } diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 82de4a8..8f19956 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -181,11 +181,14 @@ df_scan_set_bb_info (struct dataflow *dflow, unsigned int index, /* Free basic block info. */ static void -df_scan_free_bb_info (struct dataflow *dflow, void *vbb_info) +df_scan_free_bb_info (struct dataflow *dflow, basic_block bb, void *vbb_info) { struct df_scan_bb_info *bb_info = (struct df_scan_bb_info *) vbb_info; if (bb_info) - pool_free (dflow->block_pool, bb_info); + { + df_bb_refs_delete (dflow, bb->index); + pool_free (dflow->block_pool, bb_info); + } } @@ -222,7 +225,6 @@ df_scan_alloc (struct dataflow *dflow, bitmap blocks_to_rescan) problem_data->insn_pool = create_alloc_pool ("df_scan_insn pool", sizeof (struct df_insn_info), block_size); - problem_data->reg_pool = create_alloc_pool ("df_scan_reg pool", sizeof (struct df_reg_info), block_size); @@ -261,14 +263,18 @@ df_scan_free (struct dataflow *dflow) { struct df *df = dflow->df; - df_scan_free_internal (dflow); + if (dflow->problem_data) + { + df_scan_free_internal (dflow); + free (dflow->problem_data); + } + if (df->blocks_to_scan) BITMAP_FREE (df->blocks_to_scan); if (df->blocks_to_analyze) BITMAP_FREE (df->blocks_to_analyze); - free (dflow->problem_data); free (dflow); } @@ -412,7 +418,7 @@ df_rescan_blocks (struct df *df, bitmap blocks) { bitmap local_blocks_to_scan = BITMAP_ALLOC (NULL); - struct dataflow *dflow = df->problems_by_index [DF_SCAN]; + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; basic_block bb; df->def_info.refs_organized = false; @@ -655,7 +661,7 @@ df_reg_chain_unlink (struct dataflow *dflow, struct df_ref *ref) void df_ref_remove (struct df *df, struct df_ref *ref) { - struct dataflow *dflow = df->problems_by_index [DF_SCAN]; + struct dataflow *dflow = df->problems_by_index[DF_SCAN]; if (DF_REF_REG_DEF_P (ref)) { if (DF_REF_FLAGS (ref) & DF_REF_ARTIFICIAL) @@ -713,7 +719,8 @@ df_insn_create_insn_record (struct dataflow *dflow, rtx insn) return insn_rec; } -/* Delete all of the refs information from BLOCKS. */ + +/* Delete all of the refs information from INSN. */ void df_insn_refs_delete (struct dataflow *dflow, rtx insn) @@ -741,6 +748,42 @@ df_insn_refs_delete (struct dataflow *dflow, rtx insn) } +/* Delete all of the refs information from basic_block with BB_INDEX. */ + +void +df_bb_refs_delete (struct dataflow *dflow, int bb_index) +{ + struct df_ref *def; + struct df_ref *use; + + struct df_scan_bb_info *bb_info + = df_scan_get_bb_info (dflow, bb_index); + rtx insn; + basic_block bb = BASIC_BLOCK (bb_index); + FOR_BB_INSNS (bb, insn) + { + if (INSN_P (insn)) + { + /* Record defs within INSN. */ + df_insn_refs_delete (dflow, insn); + } + } + + /* Get rid of any artifical uses. */ + if (bb_info) + { + def = bb_info->artificial_defs; + while (def) + def = df_reg_chain_unlink (dflow, def); + bb_info->artificial_defs = NULL; + use = bb_info->artificial_uses; + while (use) + use = df_reg_chain_unlink (dflow, use); + bb_info->artificial_uses = NULL; + } +} + + /* Delete all of the refs information from BLOCKS. */ void @@ -748,36 +791,10 @@ df_refs_delete (struct dataflow *dflow, bitmap blocks) { bitmap_iterator bi; unsigned int bb_index; - struct df_ref *def; - struct df_ref *use; EXECUTE_IF_SET_IN_BITMAP (blocks, 0, bb_index, bi) { - struct df_scan_bb_info *bb_info - = df_scan_get_bb_info (dflow, bb_index); - rtx insn; - basic_block bb = BASIC_BLOCK (bb_index); - FOR_BB_INSNS (bb, insn) - { - if (INSN_P (insn)) - { - /* Record defs within INSN. */ - df_insn_refs_delete (dflow, insn); - } - } - - /* Get rid of any artifical uses. */ - if (bb_info) - { - def = bb_info->artificial_defs; - while (def) - def = df_reg_chain_unlink (dflow, def); - bb_info->artificial_defs = NULL; - use = bb_info->artificial_uses; - while (use) - use = df_reg_chain_unlink (dflow, use); - bb_info->artificial_uses = NULL; - } + df_bb_refs_delete (dflow, bb_index); } } @@ -1568,7 +1585,7 @@ df_bb_refs_record (struct dataflow *dflow, basic_block bb) /* Any reference to any pseudo before reload is a potential reference of the frame pointer. */ - df_uses_record (dflow, ®no_reg_rtx [FRAME_POINTER_REGNUM], + df_uses_record (dflow, ®no_reg_rtx[FRAME_POINTER_REGNUM], DF_REF_REG_USE, bb, NULL, DF_REF_ARTIFICIAL); #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM diff --git a/gcc/df.h b/gcc/df.h index 09a1127..a353d36 100644 --- a/gcc/df.h +++ b/gcc/df.h @@ -69,7 +69,7 @@ typedef void (*df_alloc_function) (struct dataflow *, bitmap); /* Free the basic block info. Called from the block reordering code to get rid of the blocks that have been squished down. */ -typedef void (*df_free_bb_function) (struct dataflow *, void *); +typedef void (*df_free_bb_function) (struct dataflow *, basic_block, void *); /* Local compute function. */ typedef void (*df_local_compute_function) (struct dataflow *, bitmap, bitmap); @@ -569,6 +569,7 @@ extern void df_reg_chain_create (struct df_reg_info *, struct df_ref *); extern struct df_ref *df_reg_chain_unlink (struct dataflow *, struct df_ref *); extern void df_ref_remove (struct df *, struct df_ref *); extern void df_insn_refs_delete (struct dataflow *, rtx); +extern void df_bb_refs_delete (struct dataflow *, int); extern void df_refs_delete (struct dataflow *, bitmap); extern void df_reorganize_refs (struct df_ref_info *); extern void df_set_state (int); -- 2.7.4