[patch] Change type of instruction pointers for cfghooks
Zdenek Dvorak
rakdver@atrey.karlin.mff.cuni.cz
Mon Dec 12 22:34:00 GMT 2005
Hello,
cfg hooks currently use void * pointers when expression or position of
an instruction needs to be passed to them, so that they can be used for
both trees and rtl. This patch makes them use union containing rtx and
tree instead, for the following reasons:
1) Better for type checking -- we would now get a warning or error if
an argument of wrong type is passed to them.
2) It might turn out useful to change the type for trees to
block_stmt_iterator, in which case this change makes it easier to
spot the places where the change needs to be done.
Bootstrapped & regtested on i686.
Zdenek
* tree-complex.c (expand_complex_div_wide): Convert operand of a cfg
hook to the correct type.
stmt_to_cfg_instruction.
* cfgloopmanip.c (split_loop_bb, lv_adjust_loop_entry_edge): Ditto.
* value-prof.c (tree_divmod_fixed_value, tree_mod_pow2,
tree_mod_subtract): Ditto.
* cfgbuild.c (find_bb_boundaries): Ditto.
* recog.c (peephole2_optimize): Ditto.
* except.c (emit_to_new_bb_before): Ditto.
* cfgexpand.c (expand_gimple_cond_expr, expand_gimple_tailcall,
construct_init_block, construct_exit_block): Ditto.
* tree-cfgcleanup.c (cleanup_control_flow): Ditto.
* cfgcleanup.c (try_crossjump_to_edge): Ditto.
* tree-mudflap.c (mf_build_check_statement_for): Ditto.
* cfglayout.c (fixup_fallthru_exit_predecessor,
cfg_layout_duplicate_bb): Ditto.
* tree-inline.c (copy_bb, copy_edges_for_bb, expand_call_inline): Ditto.
* bb-reorder.c (fix_crossing_conditional_branches): Ditto.
* tree-cfg.c (make_blocks, tree_flow_call_edges_add): Ditto.
(create_bb, tree_split_block, tree_lv_add_condition_to_bb): Changed
type.
* cfgrtl.c (cfg_layout_split_block, rtl_split_block,
rtl_create_basic_block, cfg_layout_create_basic_block,
rtl_split_block, cfg_layout_split_block, rtl_lv_add_condition_to_bb):
Changed type.
(force_nonfallthru_and_redirect, rtl_split_edge, cfg_layout_split_edge,
rtl_flow_call_edges_add): Convert operand of a cfg hook to the
correct type.
* cfghooks.c (split_block_after_labels, create_empty_bb): Use
empty_cfg_instruction.
(split_block, create_basic_block, lv_add_condition_to_bb): Changed
type.
* cfghooks.h (union instruction, union expression): Declare.
(struct cfg_hooks): Changed types of create_basic_block,
split_block and lv_add_condition_to_bb.
(create_basic_block, split_block, lv_add_condition_to_bb): Change type.
(insn_to_cfg_instruction, stmt_to_cfg_instruction,
empty_cfg_instruction, rtx_to_cfg_expression, tree_to_cfg_expression):
New functions.
Index: tree-complex.c
===================================================================
*** tree-complex.c (revision 108411)
--- tree-complex.c (working copy)
*************** expand_complex_div_wide (block_stmt_iter
*** 1059,1065 ****
bsi_insert_before (bsi, cond, BSI_SAME_STMT);
/* Split the original block, and create the TRUE and FALSE blocks. */
! e = split_block (bsi->bb, cond);
bb_cond = e->src;
bb_join = e->dest;
bb_true = create_empty_bb (bb_cond);
--- 1059,1065 ----
bsi_insert_before (bsi, cond, BSI_SAME_STMT);
/* Split the original block, and create the TRUE and FALSE blocks. */
! e = split_block (bsi->bb, stmt_to_cfg_instruction (cond));
bb_cond = e->src;
bb_join = e->dest;
bb_true = create_empty_bb (bb_cond);
Index: cfgloopmanip.c
===================================================================
*** cfgloopmanip.c (revision 108411)
--- cfgloopmanip.c (working copy)
*************** split_loop_bb (basic_block bb, void *ins
*** 60,66 ****
edge e;
/* Split the block. */
! e = split_block (bb, insn);
/* Add dest to loop. */
add_bb_to_loop (e->dest, e->src->loop_father);
--- 60,66 ----
edge e;
/* Split the block. */
! e = split_block (bb, insn_to_cfg_instruction (insn));
/* Add dest to loop. */
add_bb_to_loop (e->dest, e->src->loop_father);
*************** lv_adjust_loop_entry_edge (basic_block f
*** 1417,1423 ****
lv_add_condition_to_bb (first_head, second_head, new_head,
! cond_expr);
e1 = make_edge (new_head, first_head, EDGE_TRUE_VALUE);
set_immediate_dominator (CDI_DOMINATORS, first_head, new_head);
--- 1417,1423 ----
lv_add_condition_to_bb (first_head, second_head, new_head,
! tree_to_cfg_expression (cond_expr));
e1 = make_edge (new_head, first_head, EDGE_TRUE_VALUE);
set_immediate_dominator (CDI_DOMINATORS, first_head, new_head);
Index: value-prof.c
===================================================================
*** value-prof.c (revision 108411)
--- value-prof.c (working copy)
*************** tree_divmod_fixed_value (tree stmt, tree
*** 226,238 ****
/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
! e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = count;
! e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count;
! e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = all;
--- 226,238 ----
/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
! e12 = split_block (bb, stmt_to_cfg_instruction (bb1end));
bb2 = e12->dest;
bb2->count = count;
! e23 = split_block (bb2, stmt_to_cfg_instruction (bb2end));
bb3 = e23->dest;
bb3->count = all - count;
! e34 = split_block (bb3, stmt_to_cfg_instruction (bb3end));
bb4 = e34->dest;
bb4->count = all;
*************** tree_mod_pow2 (tree stmt, tree operation
*** 395,407 ****
/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
! e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = count;
! e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count;
! e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = all;
--- 395,407 ----
/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
! e12 = split_block (bb, stmt_to_cfg_instruction (bb1end));
bb2 = e12->dest;
bb2->count = count;
! e23 = split_block (bb2, stmt_to_cfg_instruction (bb2end));
bb3 = e23->dest;
bb3->count = all - count;
! e34 = split_block (bb3, stmt_to_cfg_instruction (bb3end));
bb4 = e34->dest;
bb4->count = all;
*************** tree_mod_subtract (tree stmt, tree opera
*** 566,583 ****
/* Edge e23 connects bb2 to bb3, etc. */
/* However block 3 is optional; if it is not there, references
to 3 really refer to block 2. */
! e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = all - count1;
if (ncounts) /* Assumed to be 0 or 1. */
{
! e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = all - count1 - count2;
}
! e34 = split_block (ncounts ? bb3 : bb2, bb3end);
bb4 = e34->dest;
bb4->count = all;
--- 566,583 ----
/* Edge e23 connects bb2 to bb3, etc. */
/* However block 3 is optional; if it is not there, references
to 3 really refer to block 2. */
! e12 = split_block (bb, stmt_to_cfg_instruction (bb1end));
bb2 = e12->dest;
bb2->count = all - count1;
if (ncounts) /* Assumed to be 0 or 1. */
{
! e23 = split_block (bb2, stmt_to_cfg_instruction (bb2end));
bb3 = e23->dest;
bb3->count = all - count1 - count2;
}
! e34 = split_block (ncounts ? bb3 : bb2, stmt_to_cfg_instruction (bb3end));
bb4 = e34->dest;
bb4->count = all;
Index: cfghooks.c
===================================================================
*** cfghooks.c (revision 108411)
--- cfghooks.c (working copy)
*************** redirect_edge_and_branch_force (edge e,
*** 316,322 ****
is returned. The new basic block is created just after the old one. */
edge
! split_block (basic_block bb, void *i)
{
basic_block new_bb;
--- 316,322 ----
is returned. The new basic block is created just after the old one. */
edge
! split_block (basic_block bb, union instruction i)
{
basic_block new_bb;
*************** split_block (basic_block bb, void *i)
*** 345,351 ****
edge
split_block_after_labels (basic_block bb)
{
! return split_block (bb, NULL);
}
/* Moves block BB immediately after block AFTER. Returns false if the
--- 345,351 ----
edge
split_block_after_labels (basic_block bb)
{
! return split_block (bb, empty_cfg_instruction ());
}
/* Moves block BB immediately after block AFTER. Returns false if the
*************** split_edge (edge e)
*** 458,464 ****
to the block. If both are NULL, an empty block is created. */
basic_block
! create_basic_block (void *head, void *end, basic_block after)
{
basic_block ret;
--- 458,465 ----
to the block. If both are NULL, an empty block is created. */
basic_block
! create_basic_block (union instruction head, union instruction end,
! basic_block after)
{
basic_block ret;
*************** create_basic_block (void *head, void *en
*** 480,486 ****
basic_block
create_empty_bb (basic_block after)
{
! return create_basic_block (NULL, NULL, after);
}
/* Checks whether we may merge blocks BB1 and BB2. */
--- 481,488 ----
basic_block
create_empty_bb (basic_block after)
{
! return create_basic_block (empty_cfg_instruction (), empty_cfg_instruction (),
! after);
}
/* Checks whether we may merge blocks BB1 and BB2. */
*************** execute_on_shrinking_pred (edge e)
*** 829,834 ****
--- 831,837 ----
/* This is used inside loop versioning when we want to insert
stmts/insns on the edges, which have a different behavior
in tree's and in RTL, so we made a CFG hook. */
+
void
lv_flush_pending_stmts (edge e)
{
*************** lv_flush_pending_stmts (edge e)
*** 843,848 ****
--- 846,852 ----
additional work to maintain ssa information that's why there is
a need to call the tree_duplicate_loop_to_header_edge rather
than duplicate_loop_to_header_edge when we are in tree mode. */
+
bool
cfg_hook_duplicate_loop_to_header_edge (struct loop *loop, edge e,
struct loops *loops, unsigned int ndupl,
*************** cfg_hook_duplicate_loop_to_header_edge (
*** 861,866 ****
--- 865,871 ----
this hook takes a basic block that is known to have a cond jump
at its end and extracts the taken and not taken eges out of it
and store it in E1 and E2 respectively. */
+
void
extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
{
*************** extract_cond_bb_edges (basic_block b, ed
*** 870,875 ****
--- 875,881 ----
/* Responsible for updating the ssa info (PHI nodes) on the
new condition basic block that guards the versioned loop. */
+
void
lv_adjust_loop_header_phi (basic_block first, basic_block second,
basic_block new, edge e)
*************** lv_adjust_loop_header_phi (basic_block f
*** 881,889 ****
/* Conditions in trees and RTL are different so we need
a different handling when we add the condition to the
versioning code. */
void
lv_add_condition_to_bb (basic_block first, basic_block second,
! basic_block new, void *cond)
{
gcc_assert (cfg_hooks->lv_add_condition_to_bb);
cfg_hooks->lv_add_condition_to_bb (first, second, new, cond);
--- 887,896 ----
/* Conditions in trees and RTL are different so we need
a different handling when we add the condition to the
versioning code. */
+
void
lv_add_condition_to_bb (basic_block first, basic_block second,
! basic_block new, union expression cond)
{
gcc_assert (cfg_hooks->lv_add_condition_to_bb);
cfg_hooks->lv_add_condition_to_bb (first, second, new, cond);
Index: cfghooks.h
===================================================================
*** cfghooks.h (revision 108411)
--- cfghooks.h (working copy)
*************** Boston, MA 02110-1301, USA. */
*** 22,27 ****
--- 22,43 ----
#ifndef GCC_CFGHOOKS_H
#define GCC_CFGHOOKS_H
+ /* Position in the instruction stream. */
+
+ union instruction
+ {
+ rtx insn; /* On rtl. */
+ tree stmt; /* On trees. */
+ };
+
+ /* Expression. */
+
+ union expression
+ {
+ rtx r; /* On rtl. */
+ tree t; /* On trees. */
+ };
+
struct cfg_hooks
{
/* Name of the corresponding ir. */
*************** struct cfg_hooks
*** 34,40 ****
/* Basic CFG manipulation. */
/* Return new basic block. */
! basic_block (*create_basic_block) (void *head, void *end, basic_block after);
/* Redirect edge E to the given basic block B and update underlying program
representation. Returns edge representing redirected branch (that may not
--- 50,58 ----
/* Basic CFG manipulation. */
/* Return new basic block. */
! basic_block (*create_basic_block) (union instruction head,
! union instruction end,
! basic_block after);
/* Redirect edge E to the given basic block B and update underlying program
representation. Returns edge representing redirected branch (that may not
*************** struct cfg_hooks
*** 52,58 ****
/* Creates a new basic block just after basic block B by splitting
everything after specified instruction I. */
! basic_block (*split_block) (basic_block b, void * i);
/* Move block B immediately after block A. */
bool (*move_block_after) (basic_block b, basic_block a);
--- 70,76 ----
/* Creates a new basic block just after basic block B by splitting
everything after specified instruction I. */
! basic_block (*split_block) (basic_block b, union instruction i);
/* Move block B immediately after block A. */
bool (*move_block_after) (basic_block b, basic_block a);
*************** struct cfg_hooks
*** 122,128 ****
/* Add condition to new basic block and update CFG used in loop
versioning. */
void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
! void *);
/* Update the PHI nodes in case of loop versioning. */
void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
basic_block, edge);
--- 140,146 ----
/* Add condition to new basic block and update CFG used in loop
versioning. */
void (*lv_add_condition_to_bb) (basic_block, basic_block, basic_block,
! union expression);
/* Update the PHI nodes in case of loop versioning. */
void (*lv_adjust_loop_header_phi) (basic_block, basic_block,
basic_block, edge);
*************** extern void verify_flow_info (void);
*** 141,152 ****
extern void dump_bb (basic_block, FILE *, int);
extern edge redirect_edge_and_branch (edge, basic_block);
extern basic_block redirect_edge_and_branch_force (edge, basic_block);
! extern edge split_block (basic_block, void *);
extern edge split_block_after_labels (basic_block);
extern bool move_block_after (basic_block, basic_block);
extern void delete_basic_block (basic_block);
extern basic_block split_edge (edge);
! extern basic_block create_basic_block (void *, void *, basic_block);
extern basic_block create_empty_bb (basic_block);
extern bool can_merge_blocks_p (basic_block, basic_block);
extern void merge_blocks (basic_block, basic_block);
--- 159,170 ----
extern void dump_bb (basic_block, FILE *, int);
extern edge redirect_edge_and_branch (edge, basic_block);
extern basic_block redirect_edge_and_branch_force (edge, basic_block);
! extern edge split_block (basic_block, union instruction);
extern edge split_block_after_labels (basic_block);
extern bool move_block_after (basic_block, basic_block);
extern void delete_basic_block (basic_block);
extern basic_block split_edge (edge);
! extern basic_block create_basic_block (union instruction, union instruction, basic_block);
extern basic_block create_empty_bb (basic_block);
extern bool can_merge_blocks_p (basic_block, basic_block);
extern void merge_blocks (basic_block, basic_block);
*************** extern void extract_cond_bb_edges (basic
*** 176,182 ****
extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
edge);
extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
! void *);
/* Hooks containers. */
extern struct cfg_hooks tree_cfg_hooks;
--- 194,200 ----
extern void lv_adjust_loop_header_phi (basic_block, basic_block, basic_block,
edge);
extern void lv_add_condition_to_bb (basic_block, basic_block, basic_block,
! union expression);
/* Hooks containers. */
extern struct cfg_hooks tree_cfg_hooks;
*************** extern void rtl_register_cfg_hooks (void
*** 189,192 ****
--- 207,250 ----
extern void cfg_layout_rtl_register_cfg_hooks (void);
extern void tree_register_cfg_hooks (void);
+ /* Constructors for instruction and expression objects. */
+
+ static inline union instruction
+ insn_to_cfg_instruction (rtx insn)
+ {
+ union instruction ci;
+ ci.insn = insn;
+ return ci;
+ }
+
+ static inline union instruction
+ stmt_to_cfg_instruction (tree stmt)
+ {
+ union instruction ci;
+ ci.stmt = stmt;
+ return ci;
+ }
+
+ static inline union instruction
+ empty_cfg_instruction (void)
+ {
+ return ir_type () ? stmt_to_cfg_instruction (NULL) : insn_to_cfg_instruction (NULL);
+ }
+
+ static inline union expression
+ rtx_to_cfg_expression (rtx r)
+ {
+ union expression ce;
+ ce.r = r;
+ return ce;
+ }
+
+ static inline union expression
+ tree_to_cfg_expression (tree t)
+ {
+ union expression ce;
+ ce.t = t;
+ return ce;
+ }
+
#endif /* GCC_CFGHOOKS_H */
Index: cfgbuild.c
===================================================================
*** cfgbuild.c (revision 108411)
--- cfgbuild.c (working copy)
*************** find_bb_boundaries (basic_block bb)
*** 644,650 ****
/* On code label, split current basic block. */
if (code == CODE_LABEL)
{
! fallthru = split_block (bb, PREV_INSN (insn));
if (flow_transfer_insn)
BB_END (bb) = flow_transfer_insn;
--- 644,650 ----
/* On code label, split current basic block. */
if (code == CODE_LABEL)
{
! fallthru = split_block (bb, insn_to_cfg_instruction (PREV_INSN (insn)));
if (flow_transfer_insn)
BB_END (bb) = flow_transfer_insn;
*************** find_bb_boundaries (basic_block bb)
*** 659,665 ****
flow transfer, split the block. */
if (flow_transfer_insn && inside_basic_block_p (insn))
{
! fallthru = split_block (bb, PREV_INSN (insn));
BB_END (bb) = flow_transfer_insn;
bb = fallthru->dest;
remove_edge (fallthru);
--- 659,665 ----
flow transfer, split the block. */
if (flow_transfer_insn && inside_basic_block_p (insn))
{
! fallthru = split_block (bb, insn_to_cfg_instruction (PREV_INSN (insn)));
BB_END (bb) = flow_transfer_insn;
bb = fallthru->dest;
remove_edge (fallthru);
Index: recog.c
===================================================================
*** recog.c (revision 108411)
--- recog.c (working copy)
*************** peephole2_optimize (FILE *dump_file ATTR
*** 3205,3211 ****
edge nfte, nehe;
int flags;
! nfte = split_block (bb, x);
flags = (eh_edge->flags
& (EDGE_EH | EDGE_ABNORMAL));
if (CALL_P (x))
--- 3205,3211 ----
edge nfte, nehe;
int flags;
! nfte = split_block (bb, insn_to_cfg_instruction (x));
flags = (eh_edge->flags
& (EDGE_EH | EDGE_ABNORMAL));
if (CALL_P (x))
Index: except.c
===================================================================
*** except.c (revision 108411)
--- except.c (working copy)
*************** emit_to_new_bb_before (rtx seq, rtx insn
*** 1278,1284 ****
last = emit_insn_before (seq, insn);
if (BARRIER_P (last))
last = PREV_INSN (last);
! bb = create_basic_block (seq, last, BLOCK_FOR_INSN (insn)->prev_bb);
update_bb_for_insn (bb);
bb->flags |= BB_SUPERBLOCK;
return bb;
--- 1278,1286 ----
last = emit_insn_before (seq, insn);
if (BARRIER_P (last))
last = PREV_INSN (last);
! bb = create_basic_block (insn_to_cfg_instruction (seq),
! insn_to_cfg_instruction (last),
! BLOCK_FOR_INSN (insn)->prev_bb);
update_bb_for_insn (bb);
bb->flags |= BB_SUPERBLOCK;
return bb;
Index: cfgexpand.c
===================================================================
*** cfgexpand.c (revision 108411)
--- cfgexpand.c (working copy)
*************** expand_gimple_cond_expr (basic_block bb,
*** 1102,1108 ****
BB_END (bb) = PREV_INSN (BB_END (bb));
update_bb_for_insn (bb);
! new_bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
dest = false_edge->dest;
redirect_edge_succ (false_edge, new_bb);
false_edge->flags |= EDGE_FALLTHRU;
--- 1102,1109 ----
BB_END (bb) = PREV_INSN (BB_END (bb));
update_bb_for_insn (bb);
! new_bb = create_basic_block (insn_to_cfg_instruction (NEXT_INSN (last)),
! insn_to_cfg_instruction (get_last_insn ()), bb);
dest = false_edge->dest;
redirect_edge_succ (false_edge, new_bb);
false_edge->flags |= EDGE_FALLTHRU;
*************** expand_gimple_tailcall (basic_block bb,
*** 1218,1224 ****
if (NEXT_INSN (last))
{
! bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
last = BB_END (bb);
if (BARRIER_P (last))
--- 1219,1227 ----
if (NEXT_INSN (last))
{
! bb = create_basic_block (insn_to_cfg_instruction (NEXT_INSN (last)),
! insn_to_cfg_instruction (get_last_insn ()),
! bb);
last = BB_END (bb);
if (BARRIER_P (last))
*************** construct_init_block (void)
*** 1376,1383 ****
else
flags = EDGE_FALLTHRU;
! init_block = create_basic_block (NEXT_INSN (get_insns ()),
! get_last_insn (),
ENTRY_BLOCK_PTR);
init_block->frequency = ENTRY_BLOCK_PTR->frequency;
init_block->count = ENTRY_BLOCK_PTR->count;
--- 1379,1386 ----
else
flags = EDGE_FALLTHRU;
! init_block = create_basic_block (insn_to_cfg_instruction (NEXT_INSN (get_insns ())),
! insn_to_cfg_instruction (get_last_insn ()),
ENTRY_BLOCK_PTR);
init_block->frequency = ENTRY_BLOCK_PTR->frequency;
init_block->count = ENTRY_BLOCK_PTR->count;
*************** construct_exit_block (void)
*** 1429,1435 ****
return;
while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
head = NEXT_INSN (head);
! exit_block = create_basic_block (NEXT_INSN (head), end,
EXIT_BLOCK_PTR->prev_bb);
exit_block->frequency = EXIT_BLOCK_PTR->frequency;
exit_block->count = EXIT_BLOCK_PTR->count;
--- 1432,1439 ----
return;
while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
head = NEXT_INSN (head);
! exit_block = create_basic_block (insn_to_cfg_instruction (NEXT_INSN (head)),
! insn_to_cfg_instruction (end),
EXIT_BLOCK_PTR->prev_bb);
exit_block->frequency = EXIT_BLOCK_PTR->frequency;
exit_block->count = EXIT_BLOCK_PTR->count;
Index: tree-cfgcleanup.c
===================================================================
*** tree-cfgcleanup.c (revision 108411)
--- tree-cfgcleanup.c (working copy)
*************** cleanup_control_flow (void)
*** 150,156 ****
stmt = VEC_pop (tree, modified_noreturn_calls);
bb = bb_for_stmt (stmt);
if (bb != NULL && last_stmt (bb) != stmt && noreturn_call_p (stmt))
! split_block (bb, stmt);
}
FOR_EACH_BB (bb)
--- 150,156 ----
stmt = VEC_pop (tree, modified_noreturn_calls);
bb = bb_for_stmt (stmt);
if (bb != NULL && last_stmt (bb) != stmt && noreturn_call_p (stmt))
! split_block (bb, stmt_to_cfg_instruction (stmt));
}
FOR_EACH_BB (bb)
Index: cfgcleanup.c
===================================================================
*** cfgcleanup.c (revision 108411)
--- cfgcleanup.c (working copy)
*************** try_crossjump_to_edge (int mode, edge e1
*** 1282,1288 ****
if (dump_file)
fprintf (dump_file, "Splitting bb %i before %i insns\n",
src2->index, nmatch);
! redirect_to = split_block (src2, PREV_INSN (newpos2))->dest;
}
if (dump_file)
--- 1282,1288 ----
if (dump_file)
fprintf (dump_file, "Splitting bb %i before %i insns\n",
src2->index, nmatch);
! redirect_to = split_block (src2, insn_to_cfg_instruction (PREV_INSN (newpos2)))->dest;
}
if (dump_file)
*************** try_crossjump_to_edge (int mode, edge e1
*** 1359,1365 ****
if (NOTE_P (newpos1))
newpos1 = NEXT_INSN (newpos1);
! redirect_from = split_block (src1, PREV_INSN (newpos1))->src;
to_remove = single_succ (redirect_from);
redirect_edge_and_branch_force (single_succ_edge (redirect_from), redirect_to);
--- 1359,1365 ----
if (NOTE_P (newpos1))
newpos1 = NEXT_INSN (newpos1);
! redirect_from = split_block (src1, insn_to_cfg_instruction (PREV_INSN (newpos1)))->src;
to_remove = single_succ (redirect_from);
redirect_edge_and_branch_force (single_succ_edge (redirect_from), redirect_to);
Index: tree-mudflap.c
===================================================================
*** tree-mudflap.c (revision 108411)
--- tree-mudflap.c (working copy)
*************** mf_build_check_statement_for (tree base,
*** 510,516 ****
bsi = *instr_bsi;
bsi_prev (&bsi);
if (! bsi_end_p (bsi))
! e = split_block (cond_bb, bsi_stmt (bsi));
else
e = split_block_after_labels (cond_bb);
cond_bb = e->src;
--- 510,516 ----
bsi = *instr_bsi;
bsi_prev (&bsi);
if (! bsi_end_p (bsi))
! e = split_block (cond_bb, stmt_to_cfg_instruction (bsi_stmt (bsi)));
else
e = split_block_after_labels (cond_bb);
cond_bb = e->src;
Index: cfglayout.c
===================================================================
*** cfglayout.c (revision 108411)
--- cfglayout.c (working copy)
*************** fixup_fallthru_exit_predecessor (void)
*** 919,925 ****
edge, we have to split that block. */
if (c == bb)
{
! bb = split_block (bb, NULL)->dest;
bb->aux = c->aux;
c->aux = bb;
bb->il.rtl->footer = c->il.rtl->footer;
--- 919,925 ----
edge, we have to split that block. */
if (c == bb)
{
! bb = split_block (bb, insn_to_cfg_instruction (NULL_RTX))->dest;
bb->aux = c->aux;
c->aux = bb;
bb->il.rtl->footer = c->il.rtl->footer;
*************** cfg_layout_duplicate_bb (basic_block bb)
*** 1069,1076 ****
basic_block new_bb;
insn = duplicate_insn_chain (BB_HEAD (bb), BB_END (bb));
! new_bb = create_basic_block (insn,
! insn ? get_last_insn () : NULL,
EXIT_BLOCK_PTR->prev_bb);
BB_COPY_PARTITION (new_bb, bb);
--- 1069,1076 ----
basic_block new_bb;
insn = duplicate_insn_chain (BB_HEAD (bb), BB_END (bb));
! new_bb = create_basic_block (insn_to_cfg_instruction (insn),
! insn_to_cfg_instruction (insn ? get_last_insn () : NULL_RTX),
EXIT_BLOCK_PTR->prev_bb);
BB_COPY_PARTITION (new_bb, bb);
Index: tree-inline.c
===================================================================
*** tree-inline.c (revision 108411)
--- tree-inline.c (working copy)
*************** copy_bb (inline_data *id, basic_block bb
*** 724,730 ****
/* create_basic_block() will append every new block to
basic_block_info automatically. */
! copy_basic_block = create_basic_block (NULL, (void *) 0, bb->prev_bb->aux);
copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
copy_basic_block->frequency = (bb->frequency
* frequency_scale / REG_BR_PROB_BASE);
--- 724,730 ----
/* create_basic_block() will append every new block to
basic_block_info automatically. */
! copy_basic_block = create_empty_bb (bb->prev_bb->aux);
copy_basic_block->count = bb->count * count_scale / REG_BR_PROB_BASE;
copy_basic_block->frequency = (bb->frequency
* frequency_scale / REG_BR_PROB_BASE);
*************** copy_edges_for_bb (basic_block bb, int c
*** 881,887 ****
/* Note that bb's predecessor edges aren't necessarily
right at this point; split_block doesn't care. */
{
! edge e = split_block (new_bb, copy_stmt);
new_bb = e->dest;
bsi = bsi_start (new_bb);
}
--- 881,888 ----
/* Note that bb's predecessor edges aren't necessarily
right at this point; split_block doesn't care. */
{
! edge e = split_block (new_bb,
! stmt_to_cfg_instruction (copy_stmt));
new_bb = e->dest;
bsi = bsi_start (new_bb);
}
*************** expand_call_inline (basic_block bb, tree
*** 2050,2056 ****
/* Split the block holding the CALL_EXPR. */
! e = split_block (bb, stmt);
bb = e->src;
return_block = e->dest;
remove_edge (e);
--- 2051,2057 ----
/* Split the block holding the CALL_EXPR. */
! e = split_block (bb, stmt_to_cfg_instruction (stmt));
bb = e->src;
return_block = e->dest;
remove_edge (e);
Index: bb-reorder.c
===================================================================
*** bb-reorder.c (revision 108411)
--- bb-reorder.c (working copy)
*************** fix_crossing_conditional_branches (void)
*** 1601,1607 ****
/* Create new basic block to be dest for
conditional jump. */
! new_bb = create_basic_block (NULL, NULL, last_bb);
new_bb->aux = last_bb->aux;
last_bb->aux = new_bb;
prev_bb = last_bb;
--- 1601,1609 ----
/* Create new basic block to be dest for
conditional jump. */
! new_bb = create_basic_block (insn_to_cfg_instruction (NULL_RTX),
! insn_to_cfg_instruction (NULL_RTX),
! last_bb);
new_bb->aux = last_bb->aux;
last_bb->aux = new_bb;
prev_bb = last_bb;
Index: tree-cfg.c
===================================================================
*** tree-cfg.c (revision 108411)
--- tree-cfg.c (working copy)
*************** static struct cfg_stats_d cfg_stats;
*** 93,99 ****
static bool found_computed_goto;
/* Basic blocks and flowgraphs. */
! static basic_block create_bb (void *, void *, basic_block);
static void make_blocks (tree);
static void factor_computed_gotos (void);
--- 93,99 ----
static bool found_computed_goto;
/* Basic blocks and flowgraphs. */
! static basic_block create_bb (union instruction, union instruction, basic_block);
static void make_blocks (tree);
static void factor_computed_gotos (void);
*************** make_blocks (tree stmt_list)
*** 334,340 ****
{
if (!first_stmt_of_list)
stmt_list = tsi_split_statement_list_before (&i);
! bb = create_basic_block (stmt_list, NULL, bb);
start_new_block = false;
}
--- 334,341 ----
{
if (!first_stmt_of_list)
stmt_list = tsi_split_statement_list_before (&i);
! bb = create_basic_block (stmt_to_cfg_instruction (stmt_list),
! stmt_to_cfg_instruction (NULL), bb);
start_new_block = false;
}
*************** make_blocks (tree stmt_list)
*** 359,369 ****
/* Create and return a new empty basic block after bb AFTER. */
static basic_block
! create_bb (void *h, void *e, basic_block after)
{
basic_block bb;
! gcc_assert (!e);
/* Create and initialize a new basic block. Since alloc_block uses
ggc_alloc_cleared to allocate a basic block, we do not have to
--- 360,370 ----
/* Create and return a new empty basic block after bb AFTER. */
static basic_block
! create_bb (union instruction h, union instruction e, basic_block after)
{
basic_block bb;
! gcc_assert (!e.stmt);
/* Create and initialize a new basic block. Since alloc_block uses
ggc_alloc_cleared to allocate a basic block, we do not have to
*************** create_bb (void *h, void *e, basic_block
*** 372,378 ****
bb->index = last_basic_block;
bb->flags = BB_NEW;
! bb->stmt_list = h ? h : alloc_stmt_list ();
/* Add the new block to the linked list of blocks. */
link_block (bb, after);
--- 373,379 ----
bb->index = last_basic_block;
bb->flags = BB_NEW;
! bb->stmt_list = h.stmt ? h.stmt : alloc_stmt_list ();
/* Add the new block to the linked list of blocks. */
link_block (bb, after);
*************** tree_redirect_edge_and_branch_force (edg
*** 4082,4088 ****
labels). If STMT is NULL, BB is split just after the labels. */
static basic_block
! tree_split_block (basic_block bb, void *stmt)
{
block_stmt_iterator bsi, bsi_tgt;
tree act;
--- 4083,4089 ----
labels). If STMT is NULL, BB is split just after the labels. */
static basic_block
! tree_split_block (basic_block bb, union instruction stmt)
{
block_stmt_iterator bsi, bsi_tgt;
tree act;
*************** tree_split_block (basic_block bb, void *
*** 4098,4105 ****
FOR_EACH_EDGE (e, ei, new_bb->succs)
e->src = new_bb;
! if (stmt && TREE_CODE ((tree) stmt) == LABEL_EXPR)
! stmt = NULL;
/* Move everything from BSI to the new basic block. */
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
--- 4099,4106 ----
FOR_EACH_EDGE (e, ei, new_bb->succs)
e->src = new_bb;
! if (stmt.stmt && TREE_CODE (stmt.stmt) == LABEL_EXPR)
! stmt.stmt = NULL;
/* Move everything from BSI to the new basic block. */
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
*************** tree_split_block (basic_block bb, void *
*** 4108,4117 ****
if (TREE_CODE (act) == LABEL_EXPR)
continue;
! if (!stmt)
break;
! if (stmt == act)
{
bsi_next (&bsi);
break;
--- 4109,4118 ----
if (TREE_CODE (act) == LABEL_EXPR)
continue;
! if (!stmt.stmt)
break;
! if (stmt.stmt == act)
{
bsi_next (&bsi);
break;
*************** tree_flow_call_edges_add (sbitmap blocks
*** 4821,4827 ****
and renumber the existing basic blocks. */
if (stmt != last_stmt)
{
! e = split_block (bb, stmt);
if (e)
blocks_split++;
}
--- 4822,4828 ----
and renumber the existing basic blocks. */
if (stmt != last_stmt)
{
! e = split_block (bb, stmt_to_cfg_instruction (stmt));
if (e)
blocks_split++;
}
*************** tree_lv_adjust_loop_header_phi (basic_bl
*** 4962,4974 ****
the destination of the ELSE part. */
static void
tree_lv_add_condition_to_bb (basic_block first_head, basic_block second_head,
! basic_block cond_bb, void *cond_e)
{
block_stmt_iterator bsi;
tree goto1 = NULL_TREE;
tree goto2 = NULL_TREE;
tree new_cond_expr = NULL_TREE;
! tree cond_expr = (tree) cond_e;
edge e0;
/* Build new conditional expr */
--- 4963,4975 ----
the destination of the ELSE part. */
static void
tree_lv_add_condition_to_bb (basic_block first_head, basic_block second_head,
! basic_block cond_bb, union expression cond_e)
{
block_stmt_iterator bsi;
tree goto1 = NULL_TREE;
tree goto2 = NULL_TREE;
tree new_cond_expr = NULL_TREE;
! tree cond_expr = cond_e.t;
edge e0;
/* Build new conditional expr */
Index: cfgrtl.c
===================================================================
*** cfgrtl.c (revision 108411)
--- cfgrtl.c (working copy)
*************** static bool back_edge_of_syntactic_loop_
*** 69,82 ****
static basic_block rtl_split_edge (edge);
static bool rtl_move_block_after (basic_block, basic_block);
static int rtl_verify_flow_info (void);
! static basic_block cfg_layout_split_block (basic_block, void *);
static edge cfg_layout_redirect_edge_and_branch (edge, basic_block);
static basic_block cfg_layout_redirect_edge_and_branch_force (edge, basic_block);
static void cfg_layout_delete_block (basic_block);
static void rtl_delete_block (basic_block);
static basic_block rtl_redirect_edge_and_branch_force (edge, basic_block);
static edge rtl_redirect_edge_and_branch (edge, basic_block);
! static basic_block rtl_split_block (basic_block, void *);
static void rtl_dump_bb (basic_block, FILE *, int);
static int rtl_verify_flow_info_1 (void);
static void mark_killed_regs (rtx, rtx, void *);
--- 69,82 ----
static basic_block rtl_split_edge (edge);
static bool rtl_move_block_after (basic_block, basic_block);
static int rtl_verify_flow_info (void);
! static basic_block cfg_layout_split_block (basic_block, union instruction);
static edge cfg_layout_redirect_edge_and_branch (edge, basic_block);
static basic_block cfg_layout_redirect_edge_and_branch_force (edge, basic_block);
static void cfg_layout_delete_block (basic_block);
static void rtl_delete_block (basic_block);
static basic_block rtl_redirect_edge_and_branch_force (edge, basic_block);
static edge rtl_redirect_edge_and_branch (edge, basic_block);
! static basic_block rtl_split_block (basic_block, union instruction);
static void rtl_dump_bb (basic_block, FILE *, int);
static int rtl_verify_flow_info_1 (void);
static void mark_killed_regs (rtx, rtx, void *);
*************** create_basic_block_structure (rtx head,
*** 322,330 ****
create basic block at the end of INSN chain. */
static basic_block
! rtl_create_basic_block (void *headp, void *endp, basic_block after)
{
! rtx head = headp, end = endp;
basic_block bb;
/* Grow the basic block array if needed. */
--- 322,331 ----
create basic block at the end of INSN chain. */
static basic_block
! rtl_create_basic_block (union instruction headp, union instruction endp,
! basic_block after)
{
! rtx head = headp.insn, end = endp.insn;
basic_block bb;
/* Grow the basic block array if needed. */
*************** rtl_create_basic_block (void *headp, voi
*** 342,348 ****
}
static basic_block
! cfg_layout_create_basic_block (void *head, void *end, basic_block after)
{
basic_block newbb = rtl_create_basic_block (head, end, after);
--- 343,350 ----
}
static basic_block
! cfg_layout_create_basic_block (union instruction head, union instruction end,
! basic_block after)
{
basic_block newbb = rtl_create_basic_block (head, end, after);
*************** update_bb_for_insn (basic_block bb)
*** 463,472 ****
everything after specified instruction I. */
static basic_block
! rtl_split_block (basic_block bb, void *insnp)
{
basic_block new_bb;
! rtx insn = insnp;
edge e;
edge_iterator ei;
--- 465,474 ----
everything after specified instruction I. */
static basic_block
! rtl_split_block (basic_block bb, union instruction insnp)
{
basic_block new_bb;
! rtx insn = insnp.insn;
edge e;
edge_iterator ei;
*************** rtl_split_block (basic_block bb, void *i
*** 487,493 ****
emit_note_after (NOTE_INSN_DELETED, insn);
/* Create the new basic block. */
! new_bb = create_basic_block (NEXT_INSN (insn), BB_END (bb), bb);
BB_COPY_PARTITION (new_bb, bb);
BB_END (bb) = insn;
--- 489,496 ----
emit_note_after (NOTE_INSN_DELETED, insn);
/* Create the new basic block. */
! new_bb = create_basic_block (insn_to_cfg_instruction (NEXT_INSN (insn)),
! insn_to_cfg_instruction (BB_END (bb)), bb);
BB_COPY_PARTITION (new_bb, bb);
BB_END (bb) = insn;
*************** force_nonfallthru_and_redirect (edge e,
*** 1064,1070 ****
edge_iterator ei;
bool found = false;
! basic_block bb = create_basic_block (BB_HEAD (e->dest), NULL, ENTRY_BLOCK_PTR);
/* Change the existing edge's source to be the new block, and add
a new edge from the entry block to the new block. */
--- 1067,1075 ----
edge_iterator ei;
bool found = false;
! basic_block bb = create_basic_block (insn_to_cfg_instruction (BB_HEAD (e->dest)),
! insn_to_cfg_instruction (NULL_RTX),
! ENTRY_BLOCK_PTR);
/* Change the existing edge's source to be the new block, and add
a new edge from the entry block to the new block. */
*************** force_nonfallthru_and_redirect (edge e,
*** 1102,1108 ****
note = last_loop_beg_note (note);
note = NEXT_INSN (note);
! jump_block = create_basic_block (note, NULL, e->src);
jump_block->count = e->count;
jump_block->frequency = EDGE_FREQUENCY (e);
jump_block->loop_depth = target->loop_depth;
--- 1107,1115 ----
note = last_loop_beg_note (note);
note = NEXT_INSN (note);
! jump_block = create_basic_block (insn_to_cfg_instruction (note),
! insn_to_cfg_instruction (NULL_RTX),
! e->src);
jump_block->count = e->count;
jump_block->frequency = EDGE_FREQUENCY (e);
jump_block->loop_depth = target->loop_depth;
*************** rtl_split_edge (edge edge_in)
*** 1364,1375 ****
&& NOTE_P (before)
&& NOTE_LINE_NUMBER (before) == NOTE_INSN_LOOP_END)
before = NEXT_INSN (before);
! bb = create_basic_block (before, NULL, edge_in->src);
BB_COPY_PARTITION (bb, edge_in->src);
}
else
{
! bb = create_basic_block (before, NULL, edge_in->dest->prev_bb);
/* ??? Why not edge_in->dest->prev_bb here? */
BB_COPY_PARTITION (bb, edge_in->dest);
}
--- 1371,1386 ----
&& NOTE_P (before)
&& NOTE_LINE_NUMBER (before) == NOTE_INSN_LOOP_END)
before = NEXT_INSN (before);
! bb = create_basic_block (insn_to_cfg_instruction (before),
! insn_to_cfg_instruction (NULL_RTX),
! edge_in->src);
BB_COPY_PARTITION (bb, edge_in->src);
}
else
{
! bb = create_basic_block (insn_to_cfg_instruction (before),
! insn_to_cfg_instruction (NULL_RTX),
! edge_in->dest->prev_bb);
/* ??? Why not edge_in->dest->prev_bb here? */
BB_COPY_PARTITION (bb, edge_in->dest);
}
*************** purge_all_dead_edges (void)
*** 2506,2515 ****
/* Same as split_block but update cfg_layout structures. */
static basic_block
! cfg_layout_split_block (basic_block bb, void *insnp)
{
! rtx insn = insnp;
! basic_block new_bb = rtl_split_block (bb, insn);
new_bb->il.rtl->footer = bb->il.rtl->footer;
bb->il.rtl->footer = NULL;
--- 2517,2525 ----
/* Same as split_block but update cfg_layout structures. */
static basic_block
! cfg_layout_split_block (basic_block bb, union instruction insnp)
{
! basic_block new_bb = rtl_split_block (bb, insnp);
new_bb->il.rtl->footer = bb->il.rtl->footer;
bb->il.rtl->footer = NULL;
*************** static basic_block
*** 2822,2830 ****
cfg_layout_split_edge (edge e)
{
basic_block new_bb =
! create_basic_block (e->src != ENTRY_BLOCK_PTR
! ? NEXT_INSN (BB_END (e->src)) : get_insns (),
! NULL_RTX, e->src);
/* ??? This info is likely going to be out of date very soon, but we must
create it to avoid getting an ICE later. */
--- 2832,2841 ----
cfg_layout_split_edge (edge e)
{
basic_block new_bb =
! create_basic_block (insn_to_cfg_instruction (e->src != ENTRY_BLOCK_PTR
! ? NEXT_INSN (BB_END (e->src))
! : get_insns ()),
! insn_to_cfg_instruction (NULL_RTX), e->src);
/* ??? This info is likely going to be out of date very soon, but we must
create it to avoid getting an ICE later. */
*************** rtl_flow_call_edges_add (sbitmap blocks)
*** 3004,3010 ****
and renumber the existing basic blocks. */
if (split_at_insn != BB_END (bb))
{
! e = split_block (bb, split_at_insn);
if (e)
blocks_split++;
}
--- 3015,3021 ----
and renumber the existing basic blocks. */
if (split_at_insn != BB_END (bb))
{
! e = split_block (bb, insn_to_cfg_instruction (split_at_insn));
if (e)
blocks_split++;
}
*************** rtl_flow_call_edges_add (sbitmap blocks)
*** 3031,3042 ****
static void
rtl_lv_add_condition_to_bb (basic_block first_head ,
basic_block second_head ATTRIBUTE_UNUSED,
! basic_block cond_bb, void *comp_rtx)
{
rtx label, seq, jump;
! rtx op0 = XEXP ((rtx)comp_rtx, 0);
! rtx op1 = XEXP ((rtx)comp_rtx, 1);
! enum rtx_code comp = GET_CODE ((rtx)comp_rtx);
enum machine_mode mode;
--- 3042,3053 ----
static void
rtl_lv_add_condition_to_bb (basic_block first_head ,
basic_block second_head ATTRIBUTE_UNUSED,
! basic_block cond_bb, union expression comp_rtx)
{
rtx label, seq, jump;
! rtx op0 = XEXP (comp_rtx.r, 0);
! rtx op1 = XEXP (comp_rtx.r, 1);
! enum rtx_code comp = GET_CODE (comp_rtx.r);
enum machine_mode mode;
More information about the Gcc-patches
mailing list