truffle: src/share/vm/ci/ciTypeFlow.cpp comparison

comparison src/share/vm/ci/ciTypeFlow.cpp @ 367:194b8e3a2fc4

6384206: Phis which are later unneeded are impairing our ability to inline based on static types Reviewed-by: rasbold, jrose

author	never
date	Wed, 17 Sep 2008 12:59:52 -0700
parents	a61af66fc99e
children	ad8c8ca4ab0f

comparison

equal deleted inserted replaced

-:8261ee795323
+:194b8e3a2fc4
 for (int i=0; i<max_cells; i++) {
 _types[i] = top_type();
 }
 _trap_bci = -1;
 _trap_index = 0;
-}
+_def_locals.clear();
+}
 // ------------------------------------------------------------------
 // ciTypeFlow::get_start_state
 //
 // Set this vector to the method entry state.
 // ------------------------------------------------------------------
 // ciTypeFlow::StateVector::do_new
 void ciTypeFlow::StateVector::do_new(ciBytecodeStream* str) {
 bool will_link;
 ciKlass* klass = str->get_klass(will_link);
-if (!will_link) {
+if (!will_link || str->is_unresolved_klass()) {
 trap(str, klass, str->get_klass_index());
 } else {
 push_object(klass);
 }
 }
 pop_int();
 break;
 }
 case Bytecodes::_iinc:
 {
-check_int(local(str->get_index()));
+int lnum = str->get_index();
+check_int(local(lnum));
+store_to_local(lnum);
 break;
 }
 case Bytecodes::_iload:   load_local_int(str->get_index()); break;
 case Bytecodes::_iload_0: load_local_int(0);                      break;
 case Bytecodes::_iload_1: load_local_int(1);                      break;
 }
 }
 }
 #endif
+// ------------------------------------------------------------------
+// ciTypeFlow::SuccIter::next
+//
+void ciTypeFlow::SuccIter::next() {
+int succ_ct = _pred->successors()->length();
+int next = _index + 1;
+if (next < succ_ct) {
+_index = next;
+_succ = _pred->successors()->at(next);
+return;
+}
+for (int i = next - succ_ct; i < _pred->exceptions()->length(); i++) {
+// Do not compile any code for unloaded exception types.
+// Following compiler passes are responsible for doing this also.
+ciInstanceKlass* exception_klass = _pred->exc_klasses()->at(i);
+if (exception_klass->is_loaded()) {
+_index = next;
+_succ = _pred->exceptions()->at(i);
+return;
+}
+next++;
+}
+_index = -1;
+_succ = NULL;
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::SuccIter::set_succ
+//
+void ciTypeFlow::SuccIter::set_succ(Block* succ) {
+int succ_ct = _pred->successors()->length();
+if (_index < succ_ct) {
+_pred->successors()->at_put(_index, succ);
+} else {
+int idx = _index - succ_ct;
+_pred->exceptions()->at_put(idx, succ);
+}
+}
 // ciTypeFlow::Block
 //
 // A basic block.
 // ------------------------------------------------------------------
 new (outer->arena()) JsrSet(outer->arena(), jsrs->size());
 jsrs->copy_into(new_jsrs);
 _jsrs = new_jsrs;
 _next = NULL;
 _on_work_list = false;
-_pre_order = -1; assert(!has_pre_order(), "");
+_backedge_copy = false;
-_private_copy = false;
+_exception_entry = false;
 _trap_bci = -1;
 _trap_index = 0;
+df_init();
 if (CITraceTypeFlow) {
 tty->print_cr(">> Created new block");
 print_on(tty);
 }
 assert(this->outer() == outer, "outer link set up");
 assert(!outer->have_block_count(), "must not have mapped blocks yet");
 }
 // ------------------------------------------------------------------
-// ciTypeFlow::Block::clone_loop_head
+// ciTypeFlow::Block::df_init
-//
+void ciTypeFlow::Block::df_init() {
-ciTypeFlow::Block*
+_pre_order = -1; assert(!has_pre_order(), "");
-ciTypeFlow::Block::clone_loop_head(ciTypeFlow* analyzer,
+_post_order = -1; assert(!has_post_order(), "");
-int branch_bci,
+_loop = NULL;
-ciTypeFlow::Block* target,
+_irreducible_entry = false;
-ciTypeFlow::JsrSet* jsrs) {
+_rpo_next = NULL;
-// Loop optimizations are not performed on Tier1 compiles. Do nothing.
-if (analyzer->env()->comp_level() < CompLevel_full_optimization) {
-return target;
-}
-// The current block ends with a branch.
-//
-// If the target block appears to be the test-clause of a for loop, and
-// it is not too large, and it has not yet been cloned, clone it.
-// The pre-existing copy becomes the private clone used only by
-// the initial iteration of the loop.  (We know we are simulating
-// the initial iteration right now, since we have never calculated
-// successors before for this block.)
-if (branch_bci <= start()
-&& (target->limit() - target->start()) <= CICloneLoopTestLimit
-&& target->private_copy_count() == 0) {
-// Setting the private_copy bit ensures that the target block cannot be
-// reached by any other paths, such as fall-in from the loop body.
-// The private copy will be accessible only on successor lists
-// created up to this point.
-target->set_private_copy(true);
-if (CITraceTypeFlow) {
-tty->print(">> Cloning a test-clause block ");
-print_value_on(tty);
-tty->cr();
-}
-// If the target is the current block, then later on a new copy of the
-// target block will be created when its bytecodes are reached by
-// an alternate path. (This is the case for loops with the loop
-// head at the bci-wise bottom of the loop, as with pre-1.4.2 javac.)
-//
-// Otherwise, duplicate the target block now and use it immediately.
-// (The case for loops with the loop head at the bci-wise top of the
-// loop, as with 1.4.2 javac.)
-//
-// In either case, the new copy of the block will remain public.
-if (target != this) {
-target = analyzer->block_at(branch_bci, jsrs);
-}
-}
-return target;
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::Block::successors
 //
 case Bytecodes::_if_icmpgt:    case Bytecodes::_if_icmple:
 case Bytecodes::_if_acmpeq:    case Bytecodes::_if_acmpne:
 case Bytecodes::_ifnull:       case Bytecodes::_ifnonnull:
 // Our successors are the branch target and the next bci.
 branch_bci = str->get_dest();
-clone_loop_head(analyzer, branch_bci, this, jsrs);
 _successors =
 new (arena) GrowableArray<Block*>(arena, 2, 0, NULL);
 assert(_successors->length() == IF_NOT_TAKEN, "");
 _successors->append(analyzer->block_at(next_bci, jsrs));
 assert(_successors->length() == IF_TAKEN, "");
 case Bytecodes::_goto:
 branch_bci = str->get_dest();
 _successors =
 new (arena) GrowableArray<Block*>(arena, 1, 0, NULL);
 assert(_successors->length() == GOTO_TARGET, "");
-target = analyzer->block_at(branch_bci, jsrs);
+_successors->append(analyzer->block_at(branch_bci, jsrs));
-// If the target block has not been visited yet, and looks like
-// a two-way branch, attempt to clone it if it is a loop head.
-if (target->_successors != NULL
-&& target->_successors->length() == (IF_TAKEN + 1)) {
-target = clone_loop_head(analyzer, branch_bci, target, jsrs);
-}
-_successors->append(target);
 break;
 case Bytecodes::_jsr:
 branch_bci = str->get_dest();
 _successors =
 _exc_klasses->append(klass);
 }
 }
 // ------------------------------------------------------------------
-// ciTypeFlow::Block::is_simpler_than
+// ciTypeFlow::Block::set_backedge_copy
-//
+// Use this only to make a pre-existing public block into a backedge copy.
-// A relation used to order our work list.  We work on a block earlier
+void ciTypeFlow::Block::set_backedge_copy(bool z) {
-// if it has a smaller jsr stack or it occurs earlier in the program
+assert(z || (z == is_backedge_copy()), "cannot make a backedge copy public");
-// text.
+_backedge_copy = z;
-//
+}
-// Note: maybe we should redo this functionality to make blocks
-// which correspond to exceptions lower priority.
+// ------------------------------------------------------------------
-bool ciTypeFlow::Block::is_simpler_than(ciTypeFlow::Block* other) {
+// ciTypeFlow::Block::is_clonable_exit
-if (other == NULL) {
+//
-return true;
+// At most 2 normal successors, one of which continues looping,
-} else {
+// and all exceptional successors must exit.
-int size1 = _jsrs->size();
+bool ciTypeFlow::Block::is_clonable_exit(ciTypeFlow::Loop* lp) {
-int size2 = other->_jsrs->size();
+int normal_cnt  = 0;
-if (size1 < size2) {
+int in_loop_cnt = 0;
-return true;
+for (SuccIter iter(this); !iter.done(); iter.next()) {
-} else if (size2 < size1) {
+Block* succ = iter.succ();
-return false;
+if (iter.is_normal_ctrl()) {
+if (++normal_cnt > 2) return false;
+if (lp->contains(succ->loop())) {
+if (++in_loop_cnt > 1) return false;
+}
 } else {
-#if 0
+if (lp->contains(succ->loop())) return false;
-if (size1 > 0) {
+}
-int r1 = _jsrs->record_at(0)->return_address();
+}
-int r2 = _jsrs->record_at(0)->return_address();
+return in_loop_cnt == 1;
-if (r1 < r2) {
+}
-return true;
-} else if (r2 < r1) {
+// ------------------------------------------------------------------
-return false;
+// ciTypeFlow::Block::looping_succ
-} else {
+//
-int e1 = _jsrs->record_at(0)->return_address();
+ciTypeFlow::Block* ciTypeFlow::Block::looping_succ(ciTypeFlow::Loop* lp) {
-int e2 = _jsrs->record_at(0)->return_address();
+assert(successors()->length() <= 2, "at most 2 normal successors");
-if (e1 < e2) {
+for (SuccIter iter(this); !iter.done(); iter.next()) {
-return true;
+Block* succ = iter.succ();
-} else if (e2 < e1) {
+if (lp->contains(succ->loop())) {
-return false;
+return succ;
 }
 }
-}
+return NULL;
-#endif
-return (start() <= other->start());
-}
-}
-}
-// ------------------------------------------------------------------
-// ciTypeFlow::Block::set_private_copy
-// Use this only to make a pre-existing public block into a private copy.
-void ciTypeFlow::Block::set_private_copy(bool z) {
-assert(z || (z == is_private_copy()), "cannot make a private copy public");
-_private_copy = z;
 }
 #ifndef PRODUCT
 // ------------------------------------------------------------------
 // ciTypeFlow::Block::print_value_on
 void ciTypeFlow::Block::print_value_on(outputStream* st) const {
-if (has_pre_order())  st->print("#%-2d ", pre_order());
+if (has_pre_order()) st->print("#%-2d ", pre_order());
+if (has_rpo())       st->print("rpo#%-2d ", rpo());
 st->print("[%d - %d)", start(), limit());
+if (is_loop_head()) st->print(" lphd");
+if (is_irreducible_entry()) st->print(" irred");
 if (_jsrs->size() > 0) { st->print("/");  _jsrs->print_on(st); }
-if (is_private_copy())  st->print("/private_copy");
+if (is_backedge_copy())  st->print("/backedge_copy");
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::Block::print_on
 void ciTypeFlow::Block::print_on(outputStream* st) const {
 outer()->method()->print_codes_on(start(), limit(), st);
 }
 st->print_cr("  ====================================================  ");
 st->print ("  ");
 print_value_on(st);
+st->print(" Stored locals: "); def_locals()->print_on(st, outer()->method()->max_locals()); tty->cr();
+if (loop() && loop()->parent() != NULL) {
+st->print(" loops:");
+Loop* lp = loop();
+do {
+st->print(" %d<-%d", lp->head()->pre_order(),lp->tail()->pre_order());
+if (lp->is_irreducible()) st->print("(ir)");
+lp = lp->parent();
+} while (lp->parent() != NULL);
+}
 st->cr();
 _state->print_on(st);
 if (_successors == NULL) {
 st->print_cr("  No successor information");
 } else {
 }
 st->print_cr("  ====================================================  ");
 }
 #endif
+#ifndef PRODUCT
+// ------------------------------------------------------------------
+// ciTypeFlow::LocalSet::print_on
+void ciTypeFlow::LocalSet::print_on(outputStream* st, int limit) const {
+st->print("{");
+for (int i = 0; i < max; i++) {
+if (test(i)) st->print(" %d", i);
+}
+if (limit > max) {
+st->print(" %d..%d ", max, limit);
+}
+st->print(" }");
+}
+#endif
 // ciTypeFlow
 //
 // This is a pass over the bytecodes which computes the following:
 //   basic block structure
 //   interpreter type-states (a la the verifier)
 _method = method;
 _methodBlocks = method->get_method_blocks();
 _max_locals = method->max_locals();
 _max_stack = method->max_stack();
 _code_size = method->code_size();
+_has_irreducible_entry = false;
 _osr_bci = osr_bci;
 _failure_reason = NULL;
 assert(start_bci() >= 0 && start_bci() < code_size() , "correct osr_bci argument");
 _work_list = NULL;
-_next_pre_order = 0;
 _ciblock_count = _methodBlocks->num_blocks();
 _idx_to_blocklist = NEW_ARENA_ARRAY(arena(), GrowableArray<Block*>*, _ciblock_count);
 for (int i = 0; i < _ciblock_count; i++) {
 _idx_to_blocklist[i] = NULL;
 assert(!work_list_empty(), "work list must not be empty");
 Block* next_block = _work_list;
 _work_list = next_block->next();
 next_block->set_next(NULL);
 next_block->set_on_work_list(false);
-if (!next_block->has_pre_order()) {
-// Assign "pre_order" as each new block is taken from the work list.
-// This number may be used by following phases to order block visits.
-assert(!have_block_count(), "must not have mapped blocks yet")
-next_block->set_pre_order(_next_pre_order++);
-}
 return next_block;
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::add_to_work_list
 //
 // Add a basic block to our work list.
+// List is sorted by decreasing postorder sort (same as increasing RPO)
 void ciTypeFlow::add_to_work_list(ciTypeFlow::Block* block) {
 assert(!block->is_on_work_list(), "must not already be on work list");
 if (CITraceTypeFlow) {
-tty->print(">> Adding block%s ", block->has_pre_order() ? " (again)" : "");
+tty->print(">> Adding block ");
 block->print_value_on(tty);
 tty->print_cr(" to the work list : ");
 }
 block->set_on_work_list(true);
-if (block->is_simpler_than(_work_list)) {
+// decreasing post order sort
+Block* prev = NULL;
+Block* current = _work_list;
+int po = block->post_order();
+while (current != NULL) {
+if (!current->has_post_order() || po > current->post_order())
+break;
+prev = current;
+current = current->next();
+}
+if (prev == NULL) {
 block->set_next(_work_list);
 _work_list = block;
 } else {
-Block *temp = _work_list;
+block->set_next(current);
-while (!block->is_simpler_than(temp->next())) {
+prev->set_next(block);
-if (CITraceTypeFlow) {
+}
-tty->print(".");
-}
-temp = temp->next();
-}
-block->set_next(temp->next());
-temp->set_next(block);
-}
 if (CITraceTypeFlow) {
 tty->cr();
 }
 }
 ciBlock* ciblk = _methodBlocks->block_containing(bci);
 assert(ciblk->start_bci() == bci, "bad ciBlock boundaries");
 Block* block = get_block_for(ciblk->index(), jsrs, option);
-assert(block == NULL? (option == no_create): block->is_private_copy() == (option == create_private_copy), "create option consistent with result");
+assert(block == NULL? (option == no_create): block->is_backedge_copy() == (option == create_backedge_copy), "create option consistent with result");
 if (CITraceTypeFlow) {
 if (block != NULL) {
 tty->print(">> Found block ");
 block->print_value_on(tty);
 // Following compiler passes are responsible for doing this also.
 continue;
 }
 if (block->meet_exception(exception_klass, state)) {
-// Block was modified.  Add it to the work list.
+// Block was modified and has PO.  Add it to the work list.
-if (!block->is_on_work_list()) {
+if (block->has_post_order() &&
+!block->is_on_work_list()) {
 add_to_work_list(block);
 }
 }
 }
 }
 ciTypeFlow::StateVector* state) {
 int len = successors->length();
 for (int i = 0; i < len; i++) {
 Block* block = successors->at(i);
 if (block->meet(state)) {
-// Block was modified.  Add it to the work list.
+// Block was modified and has PO.  Add it to the work list.
-if (!block->is_on_work_list()) {
+if (block->has_post_order() &&
+!block->is_on_work_list()) {
 add_to_work_list(block);
 }
 }
 }
 }
 }
 return true;
 }
+// ------------------------------------------------------------------
+// ciTypeFlow::clone_loop_heads
+//
+// Clone the loop heads
+bool ciTypeFlow::clone_loop_heads(Loop* lp, StateVector* temp_vector, JsrSet* temp_set) {
+bool rslt = false;
+for (PreorderLoops iter(loop_tree_root()); !iter.done(); iter.next()) {
+lp = iter.current();
+Block* head = lp->head();
+if (lp == loop_tree_root() ||
+lp->is_irreducible() ||
+!head->is_clonable_exit(lp))
+continue;
+// check not already cloned
+if (head->backedge_copy_count() != 0)
+continue;
+// check _no_ shared head below us
+Loop* ch;
+for (ch = lp->child(); ch != NULL && ch->head() != head; ch = ch->sibling());
+if (ch != NULL)
+continue;
+// Clone head
+Block* new_head = head->looping_succ(lp);
+Block* clone = clone_loop_head(lp, temp_vector, temp_set);
+// Update lp's info
+clone->set_loop(lp);
+lp->set_head(new_head);
+lp->set_tail(clone);
+// And move original head into outer loop
+head->set_loop(lp->parent());
+rslt = true;
+}
+return rslt;
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::clone_loop_head
+//
+// Clone lp's head and replace tail's successors with clone.
+//
+//  |
+//  v
+// head <-> body
+//  |
+//  v
+// exit
+//
+// new_head
+//
+//  |
+//  v
+// head ----------\
+//  |             |
+//  |             v
+//  |  clone <-> body
+//  |    |
+//  | /--/
+//  | |
+//  v v
+// exit
+//
+ciTypeFlow::Block* ciTypeFlow::clone_loop_head(Loop* lp, StateVector* temp_vector, JsrSet* temp_set) {
+Block* head = lp->head();
+Block* tail = lp->tail();
+if (CITraceTypeFlow) {
+tty->print(">> Requesting clone of loop head "); head->print_value_on(tty);
+tty->print("  for predecessor ");                tail->print_value_on(tty);
+tty->cr();
+}
+Block* clone = block_at(head->start(), head->jsrs(), create_backedge_copy);
+assert(clone->backedge_copy_count() == 1, "one backedge copy for all back edges");
+assert(!clone->has_pre_order(), "just created");
+clone->set_next_pre_order();
+// Insert clone after (orig) tail in reverse post order
+clone->set_rpo_next(tail->rpo_next());
+tail->set_rpo_next(clone);
+// tail->head becomes tail->clone
+for (SuccIter iter(tail); !iter.done(); iter.next()) {
+if (iter.succ() == head) {
+iter.set_succ(clone);
+break;
+}
+}
+flow_block(tail, temp_vector, temp_set);
+if (head == tail) {
+// For self-loops, clone->head becomes clone->clone
+flow_block(clone, temp_vector, temp_set);
+for (SuccIter iter(clone); !iter.done(); iter.next()) {
+if (iter.succ() == head) {
+iter.set_succ(clone);
+break;
+}
+}
+}
+flow_block(clone, temp_vector, temp_set);
+return clone;
+}
 // ------------------------------------------------------------------
 // ciTypeFlow::flow_block
 //
 // Interpret the effects of the bytecodes on the incoming state
 limit = control;
 }
 // Grab the state from the current block.
 block->copy_state_into(state);
+state->def_locals()->clear();
 GrowableArray<Block*>*           exceptions = block->exceptions();
 GrowableArray<ciInstanceKlass*>* exc_klasses = block->exc_klasses();
 bool has_exceptions = exceptions->length() > 0;
+bool exceptions_used = false;
 ciBytecodeStream str(method());
 str.reset_to_bci(start);
 Bytecodes::Code code;
 while ((code = str.next()) != ciBytecodeStream::EOBC() &&
 str.cur_bci() < limit) {
 // Check for exceptional control flow from this point.
 if (has_exceptions && can_trap(str)) {
 flow_exceptions(exceptions, exc_klasses, state);
+exceptions_used = true;
 }
 // Apply the effects of the current bytecode to our state.
 bool res = state->apply_one_bytecode(&str);
 // Watch for bailouts.
 if (CITraceTypeFlow) {
 tty->print_cr(">> Found trap");
 block->print_on(tty);
 }
+// Save set of locals defined in this block
+block->def_locals()->add(state->def_locals());
 // Record (no) successors.
 block->successors(&str, state, jsrs);
+assert(!has_exceptions || exceptions_used, "Not removing exceptions");
 // Discontinue interpretation of this Block.
 return;
 }
 }
 GrowableArray<Block*>* successors = NULL;
 if (control != ciBlock::fall_through_bci) {
 // Check for exceptional control flow from this point.
 if (has_exceptions && can_trap(str)) {
 flow_exceptions(exceptions, exc_klasses, state);
+exceptions_used = true;
 }
 // Fix the JsrSet to reflect effect of the bytecode.
 block->copy_jsrs_into(jsrs);
 jsrs->apply_control(this, &str, state);
 } else {
 // Fall through control
 successors = block->successors(&str, NULL, NULL);
 }
+// Save set of locals defined in this block
+block->def_locals()->add(state->def_locals());
+// Remove untaken exception paths
+if (!exceptions_used)
+exceptions->clear();
 // Pass our state to successors.
 flow_successors(successors, state);
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::PostOrderLoops::next
+//
+// Advance to next loop tree using a postorder, left-to-right traversal.
+void ciTypeFlow::PostorderLoops::next() {
+assert(!done(), "must not be done.");
+if (_current->sibling() != NULL) {
+_current = _current->sibling();
+while (_current->child() != NULL) {
+_current = _current->child();
+}
+} else {
+_current = _current->parent();
+}
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::PreOrderLoops::next
+//
+// Advance to next loop tree using a preorder, left-to-right traversal.
+void ciTypeFlow::PreorderLoops::next() {
+assert(!done(), "must not be done.");
+if (_current->child() != NULL) {
+_current = _current->child();
+} else if (_current->sibling() != NULL) {
+_current = _current->sibling();
+} else {
+while (_current != _root && _current->sibling() == NULL) {
+_current = _current->parent();
+}
+if (_current == _root) {
+_current = NULL;
+assert(done(), "must be done.");
+} else {
+assert(_current->sibling() != NULL, "must be more to do");
+_current = _current->sibling();
+}
+}
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::Loop::sorted_merge
+//
+// Merge the branch lp into this branch, sorting on the loop head
+// pre_orders. Returns the leaf of the merged branch.
+// Child and sibling pointers will be setup later.
+// Sort is (looking from leaf towards the root)
+//  descending on primary key: loop head's pre_order, and
+//  ascending  on secondary key: loop tail's pre_order.
+ciTypeFlow::Loop* ciTypeFlow::Loop::sorted_merge(Loop* lp) {
+Loop* leaf = this;
+Loop* prev = NULL;
+Loop* current = leaf;
+while (lp != NULL) {
+int lp_pre_order = lp->head()->pre_order();
+// Find insertion point for "lp"
+while (current != NULL) {
+if (current == lp)
+return leaf; // Already in list
+if (current->head()->pre_order() < lp_pre_order)
+break;
+if (current->head()->pre_order() == lp_pre_order &&
+current->tail()->pre_order() > lp->tail()->pre_order()) {
+break;
+}
+prev = current;
+current = current->parent();
+}
+Loop* next_lp = lp->parent(); // Save future list of items to insert
+// Insert lp before current
+lp->set_parent(current);
+if (prev != NULL) {
+prev->set_parent(lp);
+} else {
+leaf = lp;
+}
+prev = lp;     // Inserted item is new prev[ious]
+lp = next_lp;  // Next item to insert
+}
+return leaf;
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::build_loop_tree
+//
+// Incrementally build loop tree.
+void ciTypeFlow::build_loop_tree(Block* blk) {
+assert(!blk->is_post_visited(), "precondition");
+Loop* innermost = NULL; // merge of loop tree branches over all successors
+for (SuccIter iter(blk); !iter.done(); iter.next()) {
+Loop*  lp   = NULL;
+Block* succ = iter.succ();
+if (!succ->is_post_visited()) {
+// Found backedge since predecessor post visited, but successor is not
+assert(succ->pre_order() <= blk->pre_order(), "should be backedge");
+// Create a LoopNode to mark this loop.
+lp = new (arena()) Loop(succ, blk);
+if (succ->loop() == NULL)
+succ->set_loop(lp);
+// succ->loop will be updated to innermost loop on a later call, when blk==succ
+} else {  // Nested loop
+lp = succ->loop();
+// If succ is loop head, find outer loop.
+while (lp != NULL && lp->head() == succ) {
+lp = lp->parent();
+}
+if (lp == NULL) {
+// Infinite loop, it's parent is the root
+lp = loop_tree_root();
+}
+}
+// Check for irreducible loop.
+// Successor has already been visited. If the successor's loop head
+// has already been post-visited, then this is another entry into the loop.
+while (lp->head()->is_post_visited() && lp != loop_tree_root()) {
+_has_irreducible_entry = true;
+lp->set_irreducible(succ);
+if (!succ->is_on_work_list()) {
+// Assume irreducible entries need more data flow
+add_to_work_list(succ);
+}
+lp = lp->parent();
+assert(lp != NULL, "nested loop must have parent by now");
+}
+// Merge loop tree branch for all successors.
+innermost = innermost == NULL ? lp : innermost->sorted_merge(lp);
+} // end loop
+if (innermost == NULL) {
+assert(blk->successors()->length() == 0, "CFG exit");
+blk->set_loop(loop_tree_root());
+} else if (innermost->head() == blk) {
+// If loop header, complete the tree pointers
+if (blk->loop() != innermost) {
+#if ASSERT
+assert(blk->loop()->head() == innermost->head(), "same head");
+Loop* dl;
+for (dl = innermost; dl != NULL && dl != blk->loop(); dl = dl->parent());
+assert(dl == blk->loop(), "blk->loop() already in innermost list");
+#endif
+blk->set_loop(innermost);
+}
+innermost->def_locals()->add(blk->def_locals());
+Loop* l = innermost;
+Loop* p = l->parent();
+while (p && l->head() == blk) {
+l->set_sibling(p->child());  // Put self on parents 'next child'
+p->set_child(l);             // Make self the first child of parent
+p->def_locals()->add(l->def_locals());
+l = p;                       // Walk up the parent chain
+p = l->parent();
+}
+} else {
+blk->set_loop(innermost);
+innermost->def_locals()->add(blk->def_locals());
+}
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::Loop::contains
+//
+// Returns true if lp is nested loop.
+bool ciTypeFlow::Loop::contains(ciTypeFlow::Loop* lp) const {
+assert(lp != NULL, "");
+if (this == lp || head() == lp->head()) return true;
+int depth1 = depth();
+int depth2 = lp->depth();
+if (depth1 > depth2)
+return false;
+while (depth1 < depth2) {
+depth2--;
+lp = lp->parent();
+}
+return this == lp;
+}
+// ------------------------------------------------------------------
+// ciTypeFlow::Loop::depth
+//
+// Loop depth
+int ciTypeFlow::Loop::depth() const {
+int dp = 0;
+for (Loop* lp = this->parent(); lp != NULL; lp = lp->parent())
+dp++;
+return dp;
+}
+#ifndef PRODUCT
+// ------------------------------------------------------------------
+// ciTypeFlow::Loop::print
+void ciTypeFlow::Loop::print(outputStream* st, int indent) const {
+for (int i = 0; i < indent; i++) st->print(" ");
+st->print("%d<-%d %s",
+is_root() ? 0 : this->head()->pre_order(),
+is_root() ? 0 : this->tail()->pre_order(),
+is_irreducible()?" irr":"");
+st->print(" defs: ");
+def_locals()->print_on(st, _head->outer()->method()->max_locals());
+st->cr();
+for (Loop* ch = child(); ch != NULL; ch = ch->sibling())
+ch->print(st, indent+2);
+}
+#endif
+// ------------------------------------------------------------------
+// ciTypeFlow::df_flow_types
+//
+// Perform the depth first type flow analysis. Helper for flow_types.
+void ciTypeFlow::df_flow_types(Block* start,
+bool do_flow,
+StateVector* temp_vector,
+JsrSet* temp_set) {
+int dft_len = 100;
+GrowableArray<Block*> stk(arena(), dft_len, 0, NULL);
+ciBlock* dummy = _methodBlocks->make_dummy_block();
+JsrSet* root_set = new JsrSet(NULL, 0);
+Block* root_head = new (arena()) Block(this, dummy, root_set);
+Block* root_tail = new (arena()) Block(this, dummy, root_set);
+root_head->set_pre_order(0);
+root_head->set_post_order(0);
+root_tail->set_pre_order(max_jint);
+root_tail->set_post_order(max_jint);
+set_loop_tree_root(new (arena()) Loop(root_head, root_tail));
+stk.push(start);
+_next_pre_order = 0;  // initialize pre_order counter
+_rpo_list = NULL;
+int next_po = 0;      // initialize post_order counter
+// Compute RPO and the control flow graph
+int size;
+while ((size = stk.length()) > 0) {
+Block* blk = stk.top(); // Leave node on stack
+if (!blk->is_visited()) {
+// forward arc in graph
+assert (!blk->has_pre_order(), "");
+blk->set_next_pre_order();
+if (_next_pre_order >= MaxNodeLimit / 2) {
+// Too many basic blocks.  Bail out.
+// This can happen when try/finally constructs are nested to depth N,
+// and there is O(2**N) cloning of jsr bodies.  See bug 4697245!
+// "MaxNodeLimit / 2" is used because probably the parser will
+// generate at least twice that many nodes and bail out.
+record_failure("too many basic blocks");
+return;
+}
+if (do_flow) {
+flow_block(blk, temp_vector, temp_set);
+if (failing()) return; // Watch for bailouts.
+}
+} else if (!blk->is_post_visited()) {
+// cross or back arc
+for (SuccIter iter(blk); !iter.done(); iter.next()) {
+Block* succ = iter.succ();
+if (!succ->is_visited()) {
+stk.push(succ);
+}
+}
+if (stk.length() == size) {
+// There were no additional children, post visit node now
+stk.pop(); // Remove node from stack
+build_loop_tree(blk);
+blk->set_post_order(next_po++);   // Assign post order
+prepend_to_rpo_list(blk);
+assert(blk->is_post_visited(), "");
+if (blk->is_loop_head() && !blk->is_on_work_list()) {
+// Assume loop heads need more data flow
+add_to_work_list(blk);
+}
+}
+} else {
+stk.pop(); // Remove post-visited node from stack
+}
+}
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::flow_types
 //
 ResourceMark rm;
 StateVector* temp_vector = new StateVector(this);
 JsrSet* temp_set = new JsrSet(NULL, 16);
 // Create the method entry block.
-Block* block = block_at(start_bci(), temp_set);
+Block* start = block_at(start_bci(), temp_set);
-block->set_pre_order(_next_pre_order++);
-assert(block->is_start(), "start block must have order #0");
 // Load the initial state into it.
 const StateVector* start_state = get_start_state();
 if (failing())  return;
-block->meet(start_state);
+start->meet(start_state);
-add_to_work_list(block);
+// Depth first visit
-// Trickle away.
+df_flow_types(start, true /*do flow*/, temp_vector, temp_set);
+if (failing())  return;
+assert(_rpo_list == start, "must be start");
+// Any loops found?
+if (loop_tree_root()->child() != NULL &&
+env()->comp_level() >= CompLevel_full_optimization) {
+// Loop optimizations are not performed on Tier1 compiles.
+bool changed = clone_loop_heads(loop_tree_root(), temp_vector, temp_set);
+// If some loop heads were cloned, recompute postorder and loop tree
+if (changed) {
+loop_tree_root()->set_child(NULL);
+for (Block* blk = _rpo_list; blk != NULL;) {
+Block* next = blk->rpo_next();
+blk->df_init();
+blk = next;
+}
+df_flow_types(start, false /*no flow*/, temp_vector, temp_set);
+}
+}
+if (CITraceTypeFlow) {
+tty->print_cr("\nLoop tree");
+loop_tree_root()->print();
+}
+// Continue flow analysis until fixed point reached
+debug_only(int max_block = _next_pre_order;)
 while (!work_list_empty()) {
-Block* block = work_list_next();
+Block* blk = work_list_next();
-flow_block(block, temp_vector, temp_set);
+assert (blk->has_post_order(), "post order assigned above");
+flow_block(blk, temp_vector, temp_set);
-// NodeCountCutoff is the number of nodes at which the parser
-// will bail out.  Probably if we already have lots of BBs,
+assert (max_block == _next_pre_order, "no new blocks");
-// the parser will generate at least twice that many nodes and bail out.
+assert (!failing(), "no more bailouts");
-// Therefore, this is a conservatively large limit at which to
-// bail out in the pre-parse typeflow pass.
-int block_limit = MaxNodeLimit / 2;
-if (_next_pre_order >= block_limit) {
-// Too many basic blocks.  Bail out.
-//
-// This can happen when try/finally constructs are nested to depth N,
-// and there is O(2**N) cloning of jsr bodies.  See bug 4697245!
-record_failure("too many basic blocks");
-return;
-}
-// Watch for bailouts.
-if (failing())  return;
 }
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::map_blocks
 //
-// Create the block map, which indexes blocks in pre_order.
+// Create the block map, which indexes blocks in reverse post-order.
 void ciTypeFlow::map_blocks() {
 assert(_block_map == NULL, "single initialization");
-int pre_order_limit = _next_pre_order;
+int block_ct = _next_pre_order;
-_block_map = NEW_ARENA_ARRAY(arena(), Block*, pre_order_limit);
+_block_map = NEW_ARENA_ARRAY(arena(), Block*, block_ct);
-assert(pre_order_limit == block_count(), "");
+assert(block_ct == block_count(), "");
-int po;
-for (po = 0; po < pre_order_limit; po++) {
+Block* blk = _rpo_list;
-debug_only(_block_map[po] = NULL);
+for (int m = 0; m < block_ct; m++) {
-}
+int rpo = blk->rpo();
-ciMethodBlocks *mblks = _methodBlocks;
+assert(rpo == m, "should be sequential");
-ciBlock* current = NULL;
+_block_map[rpo] = blk;
-int limit_bci = code_size();
+blk = blk->rpo_next();
-for (int bci = 0; bci < limit_bci; bci++) {
+}
-ciBlock* ciblk = mblks->block_containing(bci);
+assert(blk == NULL, "should be done");
-if (ciblk != NULL && ciblk != current) {
-current = ciblk;
+for (int j = 0; j < block_ct; j++) {
-int curidx = ciblk->index();
+assert(_block_map[j] != NULL, "must not drop any blocks");
-int block_count = (_idx_to_blocklist[curidx] == NULL) ? 0 : _idx_to_blocklist[curidx]->length();
+Block* block = _block_map[j];
-for (int i = 0; i < block_count; i++) {
-Block* block = _idx_to_blocklist[curidx]->at(i);
-if (!block->has_pre_order())  continue;
-int po = block->pre_order();
-assert(_block_map[po] == NULL, "unique ref to block");
-assert(0 <= po && po < pre_order_limit, "");
-_block_map[po] = block;
-}
-}
-}
-for (po = 0; po < pre_order_limit; po++) {
-assert(_block_map[po] != NULL, "must not drop any blocks");
-Block* block = _block_map[po];
 // Remove dead blocks from successor lists:
 for (int e = 0; e <= 1; e++) {
 GrowableArray<Block*>* l = e? block->exceptions(): block->successors();
-for (int i = 0; i < l->length(); i++) {
+for (int k = 0; k < l->length(); k++) {
-Block* s = l->at(i);
+Block* s = l->at(k);
-if (!s->has_pre_order()) {
+if (!s->has_post_order()) {
 if (CITraceTypeFlow) {
 tty->print("Removing dead %s successor of #%d: ", (e? "exceptional":  "normal"), block->pre_order());
 s->print_value_on(tty);
 tty->cr();
 }
 l->remove(s);
---i;
+--k;
 }
 }
 }
 }
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::get_block_for
 //
 // Find a block with this ciBlock which has a compatible JsrSet.
 // If no such block exists, create it, unless the option is no_create.
-// If the option is create_private_copy, always create a fresh private copy.
+// If the option is create_backedge_copy, always create a fresh backedge copy.
 ciTypeFlow::Block* ciTypeFlow::get_block_for(int ciBlockIndex, ciTypeFlow::JsrSet* jsrs, CreateOption option) {
 Arena* a = arena();
 GrowableArray<Block*>* blocks = _idx_to_blocklist[ciBlockIndex];
 if (blocks == NULL) {
 // Query only?
 // Allocate the growable array.
 blocks = new (a) GrowableArray<Block*>(a, 4, 0, NULL);
 _idx_to_blocklist[ciBlockIndex] = blocks;
 }
-if (option != create_private_copy) {
+if (option != create_backedge_copy) {
 int len = blocks->length();
 for (int i = 0; i < len; i++) {
 Block* block = blocks->at(i);
-if (!block->is_private_copy() && block->is_compatible_with(jsrs)) {
+if (!block->is_backedge_copy() && block->is_compatible_with(jsrs)) {
 return block;
 }
 }
 }
 // Query only?
 if (option == no_create)  return NULL;
 // We did not find a compatible block.  Create one.
 Block* new_block = new (a) Block(this, _methodBlocks->block(ciBlockIndex), jsrs);
-if (option == create_private_copy)  new_block->set_private_copy(true);
+if (option == create_backedge_copy)  new_block->set_backedge_copy(true);
 blocks->append(new_block);
 return new_block;
 }
 // ------------------------------------------------------------------
-// ciTypeFlow::private_copy_count
+// ciTypeFlow::backedge_copy_count
 //
-int ciTypeFlow::private_copy_count(int ciBlockIndex, ciTypeFlow::JsrSet* jsrs) const {
+int ciTypeFlow::backedge_copy_count(int ciBlockIndex, ciTypeFlow::JsrSet* jsrs) const {
 GrowableArray<Block*>* blocks = _idx_to_blocklist[ciBlockIndex];
 if (blocks == NULL) {
 return 0;
 }
 int count = 0;
 int len = blocks->length();
 for (int i = 0; i < len; i++) {
 Block* block = blocks->at(i);
-if (block->is_private_copy() && block->is_compatible_with(jsrs)) {
+if (block->is_backedge_copy() && block->is_compatible_with(jsrs)) {
 count++;
 }
 }
 return count;
 flow_types();
 // Watch for bailouts.
 if (failing()) {
 return;
 }
+map_blocks();
 if (CIPrintTypeFlow || CITraceTypeFlow) {
-print_on(tty);
+rpo_print_on(tty);
 }
-map_blocks();
 }
 // ------------------------------------------------------------------
 // ciTypeFlow::record_failure()
 // The ciTypeFlow object keeps track of failure reasons separately from the ciEnv.
 }
 }
 st->print_cr("********************************************************");
 st->cr();
 }
+void ciTypeFlow::rpo_print_on(outputStream* st) const {
+st->print_cr("********************************************************");
+st->print   ("TypeFlow for ");
+method()->name()->print_symbol_on(st);
+int limit_bci = code_size();
+st->print_cr("  %d bytes", limit_bci);
+for (Block* blk = _rpo_list; blk != NULL; blk = blk->rpo_next()) {
+blk->print_on(st);
+st->print_cr("--------------------------------------------------------");
+st->cr();
+}
+st->print_cr("********************************************************");
+st->cr();
+}
 #endif

Mercurial > hg > truffle

comparison src/share/vm/ci/ciTypeFlow.cpp @ 367:194b8e3a2fc4