void MultiBranchData::post_initialize(BytecodeStream* stream,
methodDataOop mdo) {
assert(stream->bci() == bci(), "wrong pos");
int target;
int my_di;
int target_di;
int offset;
if (stream->code() == Bytecodes::_tableswitch) {
Bytecode_tableswitch* sw = Bytecode_tableswitch_at(stream->bcp());
int len = sw->length();
assert(array_len() == per_case_cell_count * (len + 1), "wrong len");
for (int count = 0; count < len; count++) {
target = sw->dest_offset_at(count) + bci();
my_di = mdo->dp_to_di(dp());
target_di = mdo->bci_to_di(target);
offset = target_di - my_di;
set_displacement_at(count, offset);
}
target = sw->default_offset() + bci();
my_di = mdo->dp_to_di(dp());
target_di = mdo->bci_to_di(target);
offset = target_di - my_di;
set_default_displacement(offset);
} else {
Bytecode_lookupswitch* sw = Bytecode_lookupswitch_at(stream->bcp());
int npairs = sw->number_of_pairs();
assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len");
for (int count = 0; count < npairs; count++) {
LookupswitchPair *pair = sw->pair_at(count);
target = pair->offset() + bci();
my_di = mdo->dp_to_di(dp());
target_di = mdo->bci_to_di(target);
offset = target_di - my_di;
set_displacement_at(count, offset);
}
target = sw->default_offset() + bci();
my_di = mdo->dp_to_di(dp());
target_di = mdo->bci_to_di(target);
offset = target_di - my_di;
set_default_displacement(offset);
}
}
MethodLiveness::MethodLiveness(Arena* arena, ciMethod* method)
#ifdef COMPILER1
: _bci_block_start((uintptr_t*)arena->Amalloc((method->code_size() >> LogBitsPerByte) + 1), method->code_size())
#endif
{
_arena = arena;
_method = method;
_bit_map_size_bits = method->max_locals();
_bit_map_size_words = (_bit_map_size_bits / sizeof(unsigned int)) + 1;
#ifdef COMPILER1
_bci_block_start.clear();
#endif
}
void MethodLiveness::compute_liveness() {
#ifndef PRODUCT
if (TraceLivenessGen) {
tty->print_cr("################################################################");
tty->print("# Computing liveness information for ");
method()->print_short_name();
}
if (TimeLivenessAnalysis) _time_total.start();
#endif
{
TraceTime buildGraph(NULL, &_time_build_graph, TimeLivenessAnalysis);
init_basic_blocks();
}
{
TraceTime genKill(NULL, &_time_gen_kill, TimeLivenessAnalysis);
init_gen_kill();
}
{
TraceTime flow(NULL, &_time_flow, TimeLivenessAnalysis);
propagate_liveness();
}
#ifndef PRODUCT
if (TimeLivenessAnalysis) _time_total.stop();
if (TimeLivenessAnalysis) {
// Collect statistics
_total_bytes += method()->code_size();
_total_methods++;
int num_blocks = _block_count;
_total_blocks += num_blocks;
_max_method_blocks = MAX2(num_blocks,_max_method_blocks);
for (int i=0; i<num_blocks; i++) {
BasicBlock *block = _block_list[i];
int numEdges = block->_normal_predecessors->length();
int numExcEdges = block->_exception_predecessors->length();
_total_edges += numEdges;
_total_exc_edges += numExcEdges;
_max_block_edges = MAX2(numEdges,_max_block_edges);
_max_block_exc_edges = MAX2(numExcEdges,_max_block_exc_edges);
}
int numLocals = _bit_map_size_bits;
_total_method_locals += numLocals;
_max_method_locals = MAX2(numLocals,_max_method_locals);
}
#endif
}
void MethodLiveness::init_basic_blocks() {
bool bailout = false;
int method_len = method()->code_size();
ciMethodBlocks *mblocks = method()->get_method_blocks();
// Create an array to store the bci->BasicBlock mapping.
_block_map = new (arena()) GrowableArray<BasicBlock*>(arena(), method_len, method_len, NULL);
_block_count = mblocks->num_blocks();
_block_list = (BasicBlock **) arena()->Amalloc(sizeof(BasicBlock *) * _block_count);
// Used for patching up jsr/ret control flow.
GrowableArray<BasicBlock*>* jsr_exit_list = new GrowableArray<BasicBlock*>(5);
GrowableArray<BasicBlock*>* ret_list = new GrowableArray<BasicBlock*>(5);
// generate our block list from ciMethodBlocks
for (int blk = 0; blk < _block_count; blk++) {
ciBlock *cib = mblocks->block(blk);
int start_bci = cib->start_bci();
_block_list[blk] = new (arena()) BasicBlock(this, start_bci, cib->limit_bci());
_block_map->at_put(start_bci, _block_list[blk]);
#ifdef COMPILER1
// mark all bcis where a new basic block starts
_bci_block_start.set_bit(start_bci);
#endif // COMPILER1
}
// fill in the predecessors of blocks
ciBytecodeStream bytes(method());
for (int blk = 0; blk < _block_count; blk++) {
BasicBlock *current_block = _block_list[blk];
int bci = mblocks->block(blk)->control_bci();
if (bci == ciBlock::fall_through_bci) {
int limit = current_block->limit_bci();
if (limit < method_len) {
BasicBlock *next = _block_map->at(limit);
assert( next != NULL, "must be a block immediately following this one.");
next->add_normal_predecessor(current_block);
}
continue;
}
bytes.reset_to_bci(bci);
Bytecodes::Code code = bytes.next();
BasicBlock *dest;
// Now we need to interpret the instruction's effect
// on control flow.
assert (current_block != NULL, "we must have a current block");
switch (code) {
case Bytecodes::_ifeq:
case Bytecodes::_ifne:
case Bytecodes::_iflt:
case Bytecodes::_ifge:
case Bytecodes::_ifgt:
case Bytecodes::_ifle:
case Bytecodes::_if_icmpeq:
case Bytecodes::_if_icmpne:
case Bytecodes::_if_icmplt:
case Bytecodes::_if_icmpge:
case Bytecodes::_if_icmpgt:
case Bytecodes::_if_icmple:
case Bytecodes::_if_acmpeq:
case Bytecodes::_if_acmpne:
case Bytecodes::_ifnull:
case Bytecodes::_ifnonnull:
// Two way branch. Set predecessors at each destination.
dest = _block_map->at(bytes.next_bci());
assert(dest != NULL, "must be a block immediately following this one.");
dest->add_normal_predecessor(current_block);
dest = _block_map->at(bytes.get_dest());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
break;
case Bytecodes::_goto:
dest = _block_map->at(bytes.get_dest());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
break;
case Bytecodes::_goto_w:
dest = _block_map->at(bytes.get_far_dest());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
break;
case Bytecodes::_tableswitch:
{
Bytecode_tableswitch *tableswitch =
Bytecode_tableswitch_at(bytes.cur_bcp());
int len = tableswitch->length();
dest = _block_map->at(bci + tableswitch->default_offset());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
while (--len >= 0) {
dest = _block_map->at(bci + tableswitch->dest_offset_at(len));
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
}
break;
}
case Bytecodes::_lookupswitch:
{
Bytecode_lookupswitch *lookupswitch =
Bytecode_lookupswitch_at(bytes.cur_bcp());
int npairs = lookupswitch->number_of_pairs();
dest = _block_map->at(bci + lookupswitch->default_offset());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
while(--npairs >= 0) {
LookupswitchPair *pair = lookupswitch->pair_at(npairs);
dest = _block_map->at( bci + pair->offset());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
}
break;
}
case Bytecodes::_jsr:
{
assert(bytes.is_wide()==false, "sanity check");
dest = _block_map->at(bytes.get_dest());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
BasicBlock *jsrExit = _block_map->at(current_block->limit_bci());
assert(jsrExit != NULL, "jsr return bci must start a block.");
jsr_exit_list->append(jsrExit);
break;
}
case Bytecodes::_jsr_w:
{
dest = _block_map->at(bytes.get_far_dest());
assert(dest != NULL, "branch desination must start a block.");
dest->add_normal_predecessor(current_block);
BasicBlock *jsrExit = _block_map->at(current_block->limit_bci());
assert(jsrExit != NULL, "jsr return bci must start a block.");
jsr_exit_list->append(jsrExit);
break;
}
case Bytecodes::_wide:
assert(false, "wide opcodes should not be seen here");
break;
case Bytecodes::_athrow:
case Bytecodes::_ireturn:
case Bytecodes::_lreturn:
case Bytecodes::_freturn:
case Bytecodes::_dreturn:
case Bytecodes::_areturn:
case Bytecodes::_return:
// These opcodes are not the normal predecessors of any other opcodes.
break;
case Bytecodes::_ret:
// We will patch up jsr/rets in a subsequent pass.
ret_list->append(current_block);
break;
case Bytecodes::_breakpoint:
// Bail out of there are breakpoints in here.
bailout = true;
break;
default:
// Do nothing.
break;
}
}
// Patch up the jsr/ret's. We conservatively assume that any ret
// can return to any jsr site.
int ret_list_len = ret_list->length();
int jsr_exit_list_len = jsr_exit_list->length();
if (ret_list_len > 0 && jsr_exit_list_len > 0) {
for (int i = jsr_exit_list_len - 1; i >= 0; i--) {
BasicBlock *jsrExit = jsr_exit_list->at(i);
for (int i = ret_list_len - 1; i >= 0; i--) {
jsrExit->add_normal_predecessor(ret_list->at(i));
}
}
}
// Compute exception edges.
for (int b=_block_count-1; b >= 0; b--) {
BasicBlock *block = _block_list[b];
int block_start = block->start_bci();
int block_limit = block->limit_bci();
ciExceptionHandlerStream handlers(method());
for (; !handlers.is_done(); handlers.next()) {
ciExceptionHandler* handler = handlers.handler();
int start = handler->start();
int limit = handler->limit();
int handler_bci = handler->handler_bci();
int intersect_start = MAX2(block_start, start);
int intersect_limit = MIN2(block_limit, limit);
if (intersect_start < intersect_limit) {
// The catch range has a nonempty intersection with this
// basic block. That means this basic block can be an
// exceptional predecessor.
_block_map->at(handler_bci)->add_exception_predecessor(block);
if (handler->is_catch_all()) {
// This is a catch-all block.
if (intersect_start == block_start && intersect_limit == block_limit) {
// The basic block is entirely contained in this catch-all block.
// Skip the rest of the exception handlers -- they can never be
// reached in execution.
break;
}
}
}
}
}
}
void MethodLiveness::init_basic_blocks() {
bool bailout = false;
int method_len = method()->code_size();
// Create an array to store the bci->BasicBlock mapping.
_block_map = new (arena()) GrowableArray<BasicBlock*>(arena(), method_len, method_len, NULL);
_block_list = new (arena()) GrowableArray<BasicBlock*>(arena(), 128, 0, NULL);
// Used for patching up jsr/ret control flow.
GrowableArray<BasicBlock*>* jsr_exit_list = new GrowableArray<BasicBlock*>(5);
GrowableArray<BasicBlock*>* ret_list = new GrowableArray<BasicBlock*>(5);
// Make blocks begin at all exception handling instructions.
{
ciExceptionHandlerStream handlers(method());
for (; !handlers.is_done(); handlers.next()) {
ciExceptionHandler* handler = handlers.handler();
int handler_bci = handler->handler_bci();
make_block_at(handler_bci, NULL);
}
}
BasicBlock *current_block = NULL;
ciByteCodeStream bytes(method());
Bytecodes::Code code;
while ((code = bytes.next()) != ciByteCodeStream::EOBC && !bailout) {
int bci = bytes.cur_bci();
// Should we start a new block here?
BasicBlock *other = _block_map->at(bci);
if (other == NULL) {
// This bci has not yet been marked as the start of
// a new basic block. If current_block is NULL, then
// we are beginning a new block. Otherwise, we continue
// with the old block.
if (current_block == NULL) {
// Make a new block with no predecessors.
current_block = make_block_at(bci, NULL);
}
// Mark this index as belonging to the current block.
_block_map->at_put(bci, current_block);
} else {
// This bci has been marked as the start of a new basic
// block.
if (current_block != NULL) {
other->add_normal_predecessor(current_block);
current_block->set_limit_bci(bci);
}
current_block = other;
}
// Now we need to interpret the instruction's effect
// on control flow.
switch (code) {
assert (current_block != NULL, "we must have a current block");
case Bytecodes::_ifeq:
case Bytecodes::_ifne:
case Bytecodes::_iflt:
case Bytecodes::_ifge:
case Bytecodes::_ifgt:
case Bytecodes::_ifle:
case Bytecodes::_if_icmpeq:
case Bytecodes::_if_icmpne:
case Bytecodes::_if_icmplt:
case Bytecodes::_if_icmpge:
case Bytecodes::_if_icmpgt:
case Bytecodes::_if_icmple:
case Bytecodes::_if_acmpeq:
case Bytecodes::_if_acmpne:
case Bytecodes::_ifnull:
case Bytecodes::_ifnonnull:
// Two way branch. Make a new block at each destination.
make_block_at(bytes.next_bci(), current_block);
make_block_at(bytes.get_dest(), current_block);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
case Bytecodes::_goto:
make_block_at(bytes.get_dest(), current_block);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
case Bytecodes::_goto_w:
make_block_at(bytes.get_far_dest(), current_block);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
case Bytecodes::_tableswitch:
{
Bytecode_tableswitch *tableswitch =
Bytecode_tableswitch_at(bytes.cur_bcp());
int len = tableswitch->length();
make_block_at(bci + tableswitch->default_offset(), current_block);
while (--len >= 0) {
make_block_at(bci + tableswitch->dest_offset_at(len),
current_block);
}
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
}
// Some synthetic opcodes here
case Bytecodes::_fast_linearswitch:
case Bytecodes::_fast_binaryswitch:
case Bytecodes::_lookupswitch:
{
Bytecode_lookupswitch *lookupswitch =
Bytecode_lookupswitch_at(bytes.cur_bcp());
int npairs = lookupswitch->number_of_pairs();
make_block_at(bci + lookupswitch->default_offset(), current_block);
while(--npairs >= 0) {
LookupswitchPair *pair = lookupswitch->pair_at(npairs);
make_block_at(bci + pair->offset(), current_block);
}
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
}
case Bytecodes::_jsr:
{
assert(bytes.is_wide()==false, "sanity check");
make_block_at(bytes.get_dest(), current_block);
BasicBlock *jsrExit = make_block_at(bci + 3, NULL);
jsr_exit_list->append(jsrExit);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
}
case Bytecodes::_jsr_w:
{
make_block_at(bytes.get_far_dest(), current_block);
BasicBlock *jsrExit = make_block_at(bci + 5, NULL);
jsr_exit_list->append(jsrExit);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
}
case Bytecodes::_wide:
assert(false, "wide opcodes should not be seen here");
break;
case Bytecodes::_athrow:
case Bytecodes::_ireturn:
case Bytecodes::_lreturn:
case Bytecodes::_freturn:
case Bytecodes::_dreturn:
case Bytecodes::_areturn:
case Bytecodes::_return:
// We are done with the current block. These opcodes are
// not the normal predecessors of any other opcodes.
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
case Bytecodes::_ret:
// We will patch up jsr/rets in a subsequent pass.
ret_list->append(current_block);
current_block->set_limit_bci(bytes.next_bci());
current_block = NULL;
break;
case Bytecodes::_breakpoint:
// Bail out of there are breakpoints in here.
bailout = true;
break;
default:
// Do nothing.
break;
}
}
if (bailout) {
_block_list->clear();
_block_map = NULL; // do not use this field now!
return;
}
// Patch up the jsr/ret's. We conservatively assume that any ret
// can return to any jsr site.
int ret_list_len = ret_list->length();
int jsr_exit_list_len = jsr_exit_list->length();
if (ret_list_len > 0 && jsr_exit_list_len > 0) {
for (int i = jsr_exit_list_len - 1; i >= 0; i--) {
BasicBlock *jsrExit = jsr_exit_list->at(i);
for (int i = ret_list_len - 1; i >= 0; i--) {
jsrExit->add_normal_predecessor(ret_list->at(i));
}
}
}
// Compute exception edges.
for (int b=_block_list->length()-1; b >= 0; b--) {
BasicBlock *block = _block_list->at(b);
int block_start = block->start_bci();
int block_limit = block->limit_bci();
ciExceptionHandlerStream handlers(method());
for (; !handlers.is_done(); handlers.next()) {
ciExceptionHandler* handler = handlers.handler();
int start = handler->start();
int limit = handler->limit();
int handler_bci = handler->handler_bci();
int intersect_start = MAX2(block_start, start);
int intersect_limit = MIN2(block_limit, limit);
if (intersect_start < intersect_limit) {
// The catch range has a nonempty intersection with this
// basic block. That means this basic block can be an
// exceptional predecessor.
_block_map->at(handler_bci)->add_exception_predecessor(block);
if (handler->is_catch_all()) {
// This is a catch-all block.
if (intersect_start == block_start && intersect_limit == block_limit) {
// The basic block is entirely contained in this catch-all block.
// Skip the rest of the exception handlers -- they can never be
// reached in execution.
break;
}
}
}
}
}
}