| /* |
| * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| #include "precompiled.hpp" |
| #include "ci/ciMethodBlocks.hpp" |
| #include "ci/ciStreams.hpp" |
| #include "interpreter/bytecode.hpp" |
| #include "utilities/copy.hpp" |
| |
| // ciMethodBlocks |
| |
| |
| |
| ciBlock *ciMethodBlocks::block_containing(int bci) { |
| ciBlock *blk = _bci_to_block[bci]; |
| return blk; |
| } |
| |
| bool ciMethodBlocks::is_block_start(int bci) { |
| assert(bci >=0 && bci < _code_size, "valid bytecode range"); |
| ciBlock *b = _bci_to_block[bci]; |
| assert(b != NULL, "must have block for bytecode"); |
| return b->start_bci() == bci; |
| } |
| |
| // ------------------------------------------------------------------ |
| // ciMethodBlocks::split_block_at |
| // |
| // Split the block spanning bci into two separate ranges. The former |
| // block becomes the second half and a new range is created for the |
| // first half. Returns the range beginning at bci. |
| ciBlock *ciMethodBlocks::split_block_at(int bci) { |
| ciBlock *former_block = block_containing(bci); |
| ciBlock *new_block = new(_arena) ciBlock(_method, _num_blocks++, former_block->start_bci()); |
| _blocks->append(new_block); |
| assert(former_block != NULL, "must not be NULL"); |
| new_block->set_limit_bci(bci); |
| former_block->set_start_bci(bci); |
| for (int pos=bci-1; pos >= 0; pos--) { |
| ciBlock *current_block = block_containing(pos); |
| if (current_block == former_block) { |
| // Replace it. |
| _bci_to_block[pos] = new_block; |
| } else if (current_block == NULL) { |
| // Non-bytecode start. Skip. |
| continue; |
| } else { |
| // We are done with our backwards walk |
| break; |
| } |
| } |
| // Move an exception handler information if needed. |
| if (former_block->is_handler()) { |
| int ex_start = former_block->ex_start_bci(); |
| int ex_end = former_block->ex_limit_bci(); |
| new_block->set_exception_range(ex_start, ex_end); |
| // Clear information in former_block. |
| former_block->clear_exception_handler(); |
| } |
| return former_block; |
| } |
| |
| ciBlock *ciMethodBlocks::make_block_at(int bci) { |
| ciBlock *cb = block_containing(bci); |
| if (cb == NULL ) { |
| // This is our first time visiting this bytecode. Create |
| // a fresh block and assign it this starting point. |
| ciBlock *nb = new(_arena) ciBlock(_method, _num_blocks++, bci); |
| _blocks->append(nb); |
| _bci_to_block[bci] = nb; |
| return nb; |
| } else if (cb->start_bci() == bci) { |
| // The block begins at bci. Simply return it. |
| return cb; |
| } else { |
| // We have already created a block containing bci but |
| // not starting at bci. This existing block needs to |
| // be split into two. |
| return split_block_at(bci); |
| } |
| } |
| |
| ciBlock *ciMethodBlocks::make_dummy_block() { |
| ciBlock *dum = new(_arena) ciBlock(_method, -1, 0); |
| return dum; |
| } |
| |
| void ciMethodBlocks::do_analysis() { |
| ciBytecodeStream s(_method); |
| ciBlock *cur_block = block_containing(0); |
| int limit_bci = _method->code_size(); |
| |
| while (s.next() != ciBytecodeStream::EOBC()) { |
| int bci = s.cur_bci(); |
| // Determine if a new block has been made at the current bci. If |
| // this block differs from our current range, switch to the new |
| // one and end the old one. |
| assert(cur_block != NULL, "must always have a current block"); |
| ciBlock *new_block = block_containing(bci); |
| if (new_block == NULL || new_block == cur_block) { |
| // We have not marked this bci as the start of a new block. |
| // Keep interpreting the current_range. |
| _bci_to_block[bci] = cur_block; |
| } else { |
| cur_block->set_limit_bci(bci); |
| cur_block = new_block; |
| } |
| |
| switch (s.cur_bc()) { |
| 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 : |
| { |
| cur_block->set_control_bci(bci); |
| ciBlock *fall_through = make_block_at(s.next_bci()); |
| int dest_bci = s.get_dest(); |
| ciBlock *dest = make_block_at(dest_bci); |
| break; |
| } |
| |
| case Bytecodes::_goto : |
| { |
| cur_block->set_control_bci(bci); |
| if (s.next_bci() < limit_bci) { |
| (void) make_block_at(s.next_bci()); |
| } |
| int dest_bci = s.get_dest(); |
| ciBlock *dest = make_block_at(dest_bci); |
| break; |
| } |
| |
| case Bytecodes::_jsr : |
| { |
| cur_block->set_control_bci(bci); |
| ciBlock *ret = make_block_at(s.next_bci()); |
| int dest_bci = s.get_dest(); |
| ciBlock *dest = make_block_at(dest_bci); |
| break; |
| } |
| |
| case Bytecodes::_tableswitch : |
| { |
| cur_block->set_control_bci(bci); |
| Bytecode_tableswitch sw(&s); |
| int len = sw.length(); |
| ciBlock *dest; |
| int dest_bci; |
| for (int i = 0; i < len; i++) { |
| dest_bci = s.cur_bci() + sw.dest_offset_at(i); |
| dest = make_block_at(dest_bci); |
| } |
| dest_bci = s.cur_bci() + sw.default_offset(); |
| make_block_at(dest_bci); |
| if (s.next_bci() < limit_bci) { |
| dest = make_block_at(s.next_bci()); |
| } |
| } |
| break; |
| |
| case Bytecodes::_lookupswitch: |
| { |
| cur_block->set_control_bci(bci); |
| Bytecode_lookupswitch sw(&s); |
| int len = sw.number_of_pairs(); |
| ciBlock *dest; |
| int dest_bci; |
| for (int i = 0; i < len; i++) { |
| dest_bci = s.cur_bci() + sw.pair_at(i).offset(); |
| dest = make_block_at(dest_bci); |
| } |
| dest_bci = s.cur_bci() + sw.default_offset(); |
| dest = make_block_at(dest_bci); |
| if (s.next_bci() < limit_bci) { |
| dest = make_block_at(s.next_bci()); |
| } |
| } |
| break; |
| |
| case Bytecodes::_goto_w : |
| { |
| cur_block->set_control_bci(bci); |
| if (s.next_bci() < limit_bci) { |
| (void) make_block_at(s.next_bci()); |
| } |
| int dest_bci = s.get_far_dest(); |
| ciBlock *dest = make_block_at(dest_bci); |
| break; |
| } |
| |
| case Bytecodes::_jsr_w : |
| { |
| cur_block->set_control_bci(bci); |
| ciBlock *ret = make_block_at(s.next_bci()); |
| int dest_bci = s.get_far_dest(); |
| ciBlock *dest = make_block_at(dest_bci); |
| break; |
| } |
| |
| case Bytecodes::_athrow : |
| cur_block->set_may_throw(); |
| // fall-through |
| case Bytecodes::_ret : |
| case Bytecodes::_ireturn : |
| case Bytecodes::_lreturn : |
| case Bytecodes::_freturn : |
| case Bytecodes::_dreturn : |
| case Bytecodes::_areturn : |
| case Bytecodes::_return : |
| cur_block->set_control_bci(bci); |
| if (s.next_bci() < limit_bci) { |
| (void) make_block_at(s.next_bci()); |
| } |
| break; |
| } |
| } |
| // End the last block |
| cur_block->set_limit_bci(limit_bci); |
| } |
| |
| ciMethodBlocks::ciMethodBlocks(Arena *arena, ciMethod *meth): _method(meth), |
| _arena(arena), _num_blocks(0), _code_size(meth->code_size()) { |
| int block_estimate = _code_size / 8; |
| |
| _blocks = new(_arena) GrowableArray<ciBlock *>(_arena, block_estimate, 0, NULL); |
| int b2bsize = _code_size * sizeof(ciBlock **); |
| _bci_to_block = (ciBlock **) arena->Amalloc(b2bsize); |
| Copy::zero_to_words((HeapWord*) _bci_to_block, b2bsize / sizeof(HeapWord)); |
| |
| // create initial block covering the entire method |
| ciBlock *b = new(arena) ciBlock(_method, _num_blocks++, 0); |
| _blocks->append(b); |
| _bci_to_block[0] = b; |
| |
| // create blocks for exception handlers |
| if (meth->has_exception_handlers()) { |
| for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) { |
| ciExceptionHandler* handler = str.handler(); |
| ciBlock *eb = make_block_at(handler->handler_bci()); |
| // |
| // Several exception handlers can have the same handler_bci: |
| // |
| // try { |
| // if (a.foo(b) < 0) { |
| // return a.error(); |
| // } |
| // return CoderResult.UNDERFLOW; |
| // } finally { |
| // a.position(b); |
| // } |
| // |
| // The try block above is divided into 2 exception blocks |
| // separated by 'areturn' bci. |
| // |
| int ex_start = handler->start(); |
| int ex_end = handler->limit(); |
| // ensure a block at the start of exception range and start of following code |
| (void) make_block_at(ex_start); |
| if (ex_end < _code_size) |
| (void) make_block_at(ex_end); |
| |
| if (eb->is_handler()) { |
| // Extend old handler exception range to cover additional range. |
| int old_ex_start = eb->ex_start_bci(); |
| int old_ex_end = eb->ex_limit_bci(); |
| if (ex_start > old_ex_start) |
| ex_start = old_ex_start; |
| if (ex_end < old_ex_end) |
| ex_end = old_ex_end; |
| eb->clear_exception_handler(); // Reset exception information |
| } |
| eb->set_exception_range(ex_start, ex_end); |
| } |
| } |
| |
| // scan the bytecodes and identify blocks |
| do_analysis(); |
| |
| // mark blocks that have exception handlers |
| if (meth->has_exception_handlers()) { |
| for(ciExceptionHandlerStream str(meth); !str.is_done(); str.next()) { |
| ciExceptionHandler* handler = str.handler(); |
| int ex_start = handler->start(); |
| int ex_end = handler->limit(); |
| |
| int bci = ex_start; |
| while (bci < ex_end) { |
| ciBlock *b = block_containing(bci); |
| b->set_has_handler(); |
| bci = b->limit_bci(); |
| } |
| } |
| } |
| } |
| |
| void ciMethodBlocks::clear_processed() { |
| for (int i = 0; i < _blocks->length(); i++) |
| _blocks->at(i)->clear_processed(); |
| } |
| |
| #ifndef PRODUCT |
| void ciMethodBlocks::dump() { |
| tty->print("---- blocks for method: "); |
| _method->print(); |
| tty->cr(); |
| for (int i = 0; i < _blocks->length(); i++) { |
| tty->print(" B%d: ", i); _blocks->at(i)->dump(); |
| } |
| } |
| #endif |
| |
| |
| ciBlock::ciBlock(ciMethod *method, int index, int start_bci) : |
| #ifndef PRODUCT |
| _method(method), |
| #endif |
| _idx(index), _flags(0), _start_bci(start_bci), _limit_bci(-1), _control_bci(fall_through_bci), |
| _ex_start_bci(-1), _ex_limit_bci(-1) { |
| } |
| |
| void ciBlock::set_exception_range(int start_bci, int limit_bci) { |
| assert(limit_bci >= start_bci, "valid range"); |
| assert(!is_handler() && _ex_start_bci == -1 && _ex_limit_bci == -1, "must not be handler"); |
| _ex_start_bci = start_bci; |
| _ex_limit_bci = limit_bci; |
| set_handler(); |
| } |
| |
| #ifndef PRODUCT |
| static const char *flagnames[] = { |
| "Processed", |
| "Handler", |
| "MayThrow", |
| "Jsr", |
| "Ret", |
| "RetTarget", |
| "HasHandler", |
| }; |
| |
| void ciBlock::dump() { |
| tty->print(" [%d .. %d), {", _start_bci, _limit_bci); |
| for (int i = 0; i < 8; i++) { |
| if ((_flags & (1 << i)) != 0) { |
| tty->print(" %s", flagnames[i]); |
| } |
| } |
| tty->print(" ]"); |
| if (is_handler()) |
| tty->print(" handles(%d..%d)", _ex_start_bci, _ex_limit_bci); |
| tty->cr(); |
| } |
| |
| // ------------------------------------------------------------------ |
| // ciBlock::print_on |
| void ciBlock::print_on(outputStream* st) const { |
| st->print_cr("--------------------------------------------------------"); |
| st->print ("ciBlock [%d - %d) control : ", start_bci(), limit_bci()); |
| if (control_bci() == fall_through_bci) { |
| st->print_cr("%d:fall through", limit_bci()); |
| } else { |
| st->print_cr("%d:%s", control_bci(), |
| Bytecodes::name(method()->java_code_at_bci(control_bci()))); |
| } |
| |
| if (Verbose || WizardMode) { |
| method()->print_codes_on(start_bci(), limit_bci(), st); |
| } |
| } |
| #endif |
