OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cfghooks.c (tidy_fallthru_edges): Remove find_basic_blocks references from comments.

Browse Source 
2009-04-22  Laurynas Biveinis  <laurynas.biveinis@gmail.com>

	* 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.

From-SVN: r146544
This commit is contained in:
Laurynas Biveinis 2009-04-22 04:48:34 +00:00 committed by Laurynas Biveinis
parent 270d1bcd87
commit 3cabd6d17c
7 changed files with 31 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
gcc/ChangeLog
View File

@ -1,3 +1,17 @@
2009-04-22 Laurynas Biveinis <laurynas.biveinis@gmail.com>
* 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 <dave.korn.cygwin@gmail.com>
* sdbout.c (sdbout_symbol): Pass VOIDmode to eliminate_regs.

1
gcc/basic-block.h
View File

@ -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);

202
gcc/cfgbuild.c
View File

@ -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
<http://www.gnu.org/licenses/>. */
/* 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)
{

8
gcc/cfghooks.c
View File

@ -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

29
gcc/config/sh/sh.c
View File

@ -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 (&reg_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 ();

22
gcc/except.c
View File

@ -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. */

4
gcc/except.h
View File

@ -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);