//------------------------------catch_cleanup_find_cloned_def------------------
Node* PhaseCFG::catch_cleanup_find_cloned_def(Block *use_blk, Node *def, Block *def_blk, int n_clone_idx) {
assert( use_blk != def_blk, "Inter-block cleanup only");
// The use is some block below the Catch. Find and return the clone of the def
// that dominates the use. If there is no clone in a dominating block, then
// create a phi for the def in a dominating block.
// Find which successor block dominates this use. The successor
// blocks must all be single-entry (from the Catch only; I will have
// split blocks to make this so), hence they all dominate.
while( use_blk->_dom_depth > def_blk->_dom_depth+1 )
use_blk = use_blk->_idom;
// Find the successor
Node *fixup = NULL;
uint j;
for( j = 0; j < def_blk->_num_succs; j++ )
if( use_blk == def_blk->_succs[j] )
break;
if( j == def_blk->_num_succs ) {
// Block at same level in dom-tree is not a successor. It needs a
// PhiNode, the PhiNode uses from the def and IT's uses need fixup.
Node_Array inputs = new Node_List(Thread::current()->resource_area());
for(uint k = 1; k < use_blk->num_preds(); k++) {
Block* block = get_block_for_node(use_blk->pred(k));
inputs.map(k, catch_cleanup_find_cloned_def(block, def, def_blk, n_clone_idx));
}
// Check to see if the use_blk already has an identical phi inserted.
// If it exists, it will be at the first position since all uses of a
// def are processed together.
Node *phi = use_blk->get_node(1);
if( phi->is_Phi() ) {
fixup = phi;
for (uint k = 1; k < use_blk->num_preds(); k++) {
if (phi->in(k) != inputs[k]) {
// Not a match
fixup = NULL;
break;
}
}
}
// If an existing PhiNode was not found, make a new one.
if (fixup == NULL) {
Node *new_phi = PhiNode::make(use_blk->head(), def);
use_blk->insert_node(new_phi, 1);
map_node_to_block(new_phi, use_blk);
for (uint k = 1; k < use_blk->num_preds(); k++) {
new_phi->set_req(k, inputs[k]);
}
fixup = new_phi;
}
} else {
// Found the use just below the Catch. Make it use the clone.
fixup = use_blk->get_node(n_clone_idx);
}
return fixup;
}
void set_map_phi(int idx, PhiNode *p) { _node_map.map(idx, (Node *) p); }
void set_map(Node* from, Node* to) {
ideal_nodes.push(from);
_node_map.map(from->_idx, to);
}
// manage entries in _node_map
void set_map(int idx, Node *n) { _node_map.map(idx, n); }