diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c33e2d95f07..26b721b5e85 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2009-04-22 Laurynas Biveinis + + * cfghooks.c (tidy_fallthru_edges): Remove find_basic_blocks + references from comments. + * cfgbuild.c: (count_basic_blocks): Delete. + (find_basic_blocks_1): Delete. + (find_basic_blocks): Delete. + * except.c (finish_eh_generation): Make static. Move comment from + except.h here. Remove find_basic_blocks references from + comments. + * except.h (finish_eh_generation): Delete. + * basic-block.h (find_basic_blocks): Delete. + * config/sh/sh.c (sh_output_mi_thunk): Delete a "#if 0" block. + 2009-04-22 Dave Korn * sdbout.c (sdbout_symbol): Pass VOIDmode to eliminate_regs. diff --git a/gcc/basic-block.h b/gcc/basic-block.h index dfde67391d4..198fbefc0eb 100644 --- a/gcc/basic-block.h +++ b/gcc/basic-block.h @@ -896,7 +896,6 @@ extern bool purge_dead_edges (basic_block); /* In cfgbuild.c. */ extern void find_many_sub_basic_blocks (sbitmap); extern void rtl_make_eh_edge (sbitmap, basic_block, rtx); -extern void find_basic_blocks (rtx); /* In cfgcleanup.c. */ extern bool cleanup_cfg (int); diff --git a/gcc/cfgbuild.c b/gcc/cfgbuild.c index 519108e51dc..1c91ddbf32d 100644 --- a/gcc/cfgbuild.c +++ b/gcc/cfgbuild.c @@ -19,16 +19,6 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* find_basic_blocks divides the current function's rtl into basic - blocks and constructs the CFG. The blocks are recorded in the - basic_block_info array; the CFG exists in the edge structures - referenced by the blocks. - - find_basic_blocks also finds any unreachable loops and deletes them. - - Available functionality: - - CFG construction - find_basic_blocks */ #include "config.h" #include "system.h" @@ -46,8 +36,6 @@ along with GCC; see the file COPYING3. If not see #include "toplev.h" #include "timevar.h" -static int count_basic_blocks (const_rtx); -static void find_basic_blocks_1 (rtx); static void make_edges (basic_block, basic_block, int); static void make_label_edge (sbitmap, basic_block, rtx, int); static void find_bb_boundaries (basic_block); @@ -138,45 +126,6 @@ control_flow_insn_p (const_rtx insn) } } -/* Count the basic blocks of the function. */ - -static int -count_basic_blocks (const_rtx f) -{ - int count = NUM_FIXED_BLOCKS; - bool saw_insn = false; - const_rtx insn; - - for (insn = f; insn; insn = NEXT_INSN (insn)) - { - /* Code labels and barriers causes current basic block to be - terminated at previous real insn. */ - if ((LABEL_P (insn) || BARRIER_P (insn)) - && saw_insn) - count++, saw_insn = false; - - /* Start basic block if needed. */ - if (!saw_insn && inside_basic_block_p (insn)) - saw_insn = true; - - /* Control flow insn causes current basic block to be terminated. */ - if (saw_insn && control_flow_insn_p (insn)) - count++, saw_insn = false; - } - - if (saw_insn) - count++; - - /* The rest of the compiler works a bit smoother when we don't have to - check for the edge case of do-nothing functions with no basic blocks. */ - if (count == NUM_FIXED_BLOCKS) - { - emit_use (const0_rtx); - count = NUM_FIXED_BLOCKS + 1; - } - - return count; -} /* Create an edge between two basic blocks. FLAGS are auxiliary information about the edge that is accumulated between calls. */ @@ -418,157 +367,6 @@ make_edges (basic_block min, basic_block max, int update_p) sbitmap_vector_free (edge_cache); } -/* Find all basic blocks of the function whose first insn is F. - - Collect and return a list of labels whose addresses are taken. This - will be used in make_edges for use with computed gotos. */ - -static void -find_basic_blocks_1 (rtx f) -{ - rtx insn, next; - rtx bb_note = NULL_RTX; - rtx head = NULL_RTX; - rtx end = NULL_RTX; - basic_block prev = ENTRY_BLOCK_PTR; - - /* We process the instructions in a slightly different way than we did - previously. This is so that we see a NOTE_BASIC_BLOCK after we have - closed out the previous block, so that it gets attached at the proper - place. Since this form should be equivalent to the previous, - count_basic_blocks continues to use the old form as a check. */ - - for (insn = f; insn; insn = next) - { - enum rtx_code code = GET_CODE (insn); - - next = NEXT_INSN (insn); - - if ((LABEL_P (insn) || BARRIER_P (insn)) - && head) - { - prev = create_basic_block_structure (head, end, bb_note, prev); - head = end = NULL_RTX; - bb_note = NULL_RTX; - } - - if (inside_basic_block_p (insn)) - { - if (head == NULL_RTX) - head = insn; - end = insn; - } - - if (head && control_flow_insn_p (insn)) - { - prev = create_basic_block_structure (head, end, bb_note, prev); - head = end = NULL_RTX; - bb_note = NULL_RTX; - } - - switch (code) - { - case NOTE: - /* Look for basic block notes with which to keep the - basic_block_info pointers stable. Unthread the note now; - we'll put it back at the right place in create_basic_block. - Or not at all if we've already found a note in this block. */ - if (NOTE_INSN_BASIC_BLOCK_P (insn)) - { - if (bb_note == NULL_RTX) - bb_note = insn; - else - next = delete_insn (insn); - } - break; - - case CODE_LABEL: - case JUMP_INSN: - case CALL_INSN: - case INSN: - case BARRIER: - break; - - default: - gcc_unreachable (); - } - } - - if (head != NULL_RTX) - create_basic_block_structure (head, end, bb_note, prev); - else if (bb_note) - delete_insn (bb_note); - - gcc_assert (last_basic_block == n_basic_blocks); - - clear_aux_for_blocks (); -} - - -/* Find basic blocks of the current function. - F is the first insn of the function. */ - -void -find_basic_blocks (rtx f) -{ - basic_block bb; - - timevar_push (TV_CFG); - - /* Flush out existing data. */ - if (basic_block_info != NULL) - { - clear_edges (); - - /* Clear bb->aux on all extant basic blocks. We'll use this as a - tag for reuse during create_basic_block, just in case some pass - copies around basic block notes improperly. */ - FOR_EACH_BB (bb) - bb->aux = NULL; - - basic_block_info = NULL; - } - - n_basic_blocks = count_basic_blocks (f); - last_basic_block = NUM_FIXED_BLOCKS; - ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR; - EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR; - - - /* Size the basic block table. The actual structures will be allocated - by find_basic_blocks_1, since we want to keep the structure pointers - stable across calls to find_basic_blocks. */ - /* ??? This whole issue would be much simpler if we called find_basic_blocks - exactly once, and thereafter we don't have a single long chain of - instructions at all until close to the end of compilation when we - actually lay them out. */ - - basic_block_info = VEC_alloc (basic_block, gc, n_basic_blocks); - VEC_safe_grow_cleared (basic_block, gc, basic_block_info, n_basic_blocks); - SET_BASIC_BLOCK (ENTRY_BLOCK, ENTRY_BLOCK_PTR); - SET_BASIC_BLOCK (EXIT_BLOCK, EXIT_BLOCK_PTR); - - find_basic_blocks_1 (f); - - profile_status = PROFILE_ABSENT; - - /* Tell make_edges to examine every block for out-going edges. */ - FOR_EACH_BB (bb) - SET_STATE (bb, BLOCK_NEW); - - /* Discover the edges of our cfg. */ - make_edges (ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR->prev_bb, 0); - - /* Do very simple cleanup now, for the benefit of code that runs between - here and cleanup_cfg, e.g. thread_prologue_and_epilogue_insns. */ - tidy_fallthru_edges (); - -#ifdef ENABLE_CHECKING - verify_flow_info (); -#endif - timevar_pop (TV_CFG); -} - static void mark_tablejump_edge (rtx label) { diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index 10c04a8b057..2c65726fe17 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -829,7 +829,7 @@ tidy_fallthru_edge (edge e) /* Fix up edges that now fall through, or rather should now fall through but previously required a jump around now deleted blocks. Simplify the search by only examining blocks numerically adjacent, since this - is how find_basic_blocks created them. */ + is how they were created. */ void tidy_fallthru_edges (void) @@ -852,9 +852,9 @@ tidy_fallthru_edges (void) a single successor. If we had a conditional branch to the next instruction when - find_basic_blocks was called, then there will only be one - out edge for the block which ended with the conditional - branch (since we do not create duplicate edges). + CFG was built, then there will only be one out edge for the + block which ended with the conditional branch (since we do + not create duplicate edges). Furthermore, the edge will be marked as a fallthru because we merge the flags for the duplicate edges. So we do not want to diff --git a/gcc/config/sh/sh.c b/gcc/config/sh/sh.c index cf6e1a76b4d..9d573e044cb 100644 --- a/gcc/config/sh/sh.c +++ b/gcc/config/sh/sh.c @@ -10623,41 +10623,12 @@ sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, insn_locators_alloc (); insns = get_insns (); -#if 0 - if (optimize > 0) - { - /* Initialize the bitmap obstacks. */ - bitmap_obstack_initialize (NULL); - bitmap_obstack_initialize (®_obstack); - if (! cfun->cfg) - init_flow (); - rtl_register_cfg_hooks (); - init_rtl_bb_info (ENTRY_BLOCK_PTR); - init_rtl_bb_info (EXIT_BLOCK_PTR); - ENTRY_BLOCK_PTR->flags |= BB_RTL; - EXIT_BLOCK_PTR->flags |= BB_RTL; - find_basic_blocks (insns); - - if (flag_schedule_insns_after_reload) - { - life_analysis (PROP_FINAL); - - split_all_insns (1); - - schedule_insns (); - } - /* We must split jmp insn in PIC case. */ - else if (flag_pic) - split_all_insns_noflow (); - } -#else if (optimize > 0) { if (! cfun->cfg) init_flow (cfun); split_all_insns_noflow (); } -#endif sh_reorg (); diff --git a/gcc/except.c b/gcc/except.c index bc3b8c495a2..5a04fa68a8e 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -2117,7 +2117,10 @@ sjlj_build_landing_pads (void) free (lp_info); } -void +/* After initial rtl generation, call back to finish generating + exception support code. */ + +static void finish_eh_generation (void) { basic_block bb; @@ -2126,14 +2129,15 @@ finish_eh_generation (void) if (cfun->eh->region_tree == NULL) return; - /* The object here is to provide find_basic_blocks with detailed - information (via reachable_handlers) on how exception control - flows within the function. In this first pass, we can include - type information garnered from ERT_THROW and ERT_ALLOWED_EXCEPTIONS - regions, and hope that it will be useful in deleting unreachable - handlers. Subsequently, we will generate landing pads which will - connect many of the handlers, and then type information will not - be effective. Still, this is a win over previous implementations. */ + /* The object here is to provide detailed information (via + reachable_handlers) on how exception control flows within the + function for the CFG construction. In this first pass, we can + include type information garnered from ERT_THROW and + ERT_ALLOWED_EXCEPTIONS regions, and hope that it will be useful + in deleting unreachable handlers. Subsequently, we will generate + landing pads which will connect many of the handlers, and then + type information will not be effective. Still, this is a win + over previous implementations. */ /* These registers are used by the landing pads. Make sure they have been generated. */ diff --git a/gcc/except.h b/gcc/except.h index 18c36b01987..cf83af944a6 100644 --- a/gcc/except.h +++ b/gcc/except.h @@ -151,10 +151,6 @@ extern bool can_throw_external (const_rtx); /* Set TREE_NOTHROW and cfun->all_throwers_are_sibcalls. */ extern unsigned int set_nothrow_function_flags (void); -/* After initial rtl generation, call back to finish generating - exception support code. */ -extern void finish_eh_generation (void); - extern void init_eh (void); extern void init_eh_for_function (void);