jdk8-mips64-public/hotspot: comparison src/share/vm/opto/callnode.cpp

-:5da7201222d5
+:e9a5e0a812c8
 }
 for (i = 0; (int)i < nof_monitors(); i++) {
 Node *box = mcall->monitor_box(this, i);
 Node *obj = mcall->monitor_obj(this, i);
 if ( OptoReg::is_valid(regalloc->get_reg_first(box)) ) {
-while( !box->is_BoxLock() )  box = box->in(1);
+box = BoxLockNode::box_node(box);
 format_helper( regalloc, st, box, "MON-BOX[", i, &scobjs );
 } else {
-OptoReg::Name box_reg = BoxLockNode::stack_slot(box);
+OptoReg::Name box_reg = BoxLockNode::reg(box);
 st->print(" MON-BOX%d=%s+%d",
 i,
 OptoReg::regname(OptoReg::c_frame_pointer),
 regalloc->reg2offset(box_reg));
 }
 const char* obj_msg = "MON-OBJ[";
 if (EliminateLocks) {
-while( !box->is_BoxLock() )  box = box->in(1);
+if (BoxLockNode::box_node(box)->is_eliminated())
-if (box->as_BoxLock()->is_eliminated())
 obj_msg = "MON-OBJ(LOCK ELIMINATED)[";
 }
 format_helper( regalloc, st, obj, obj_msg, i, &scobjs );
 }
 if (ctrl_proj != NULL && ctrl_proj->_con == TypeFunc::Control) {
 Node *n = ctrl_proj->in(0);
 if (n != NULL && n->is_Unlock()) {
 UnlockNode *unlock = n->as_Unlock();
 if ((lock->obj_node() == unlock->obj_node()) &&
-(lock->box_node() == unlock->box_node()) && !unlock->is_eliminated()) {
+BoxLockNode::same_slot(lock->box_node(), unlock->box_node()) &&
+!unlock->is_eliminated()) {
 lock_ops.append(unlock);
 return true;
 }
 }
 }
 }
 }
 if (ctrl->is_Lock()) {
 LockNode *lock = ctrl->as_Lock();
 if ((lock->obj_node() == unlock->obj_node()) &&
-(lock->box_node() == unlock->box_node())) {
+BoxLockNode::same_slot(lock->box_node(), unlock->box_node())) {
 lock_result = lock;
 }
 }
 return lock_result;
 }
 }
 }
 if (lock1_node != NULL && lock1_node->is_Lock()) {
 LockNode *lock1 = lock1_node->as_Lock();
 if ((lock->obj_node() == lock1->obj_node()) &&
-(lock->box_node() == lock1->box_node()) && !lock1->is_eliminated()) {
+BoxLockNode::same_slot(lock->box_node(), lock1->box_node()) &&
+!lock1->is_eliminated()) {
 lock_ops.append(lock1);
 return true;
 }
 }
 }
 // Create a counter which counts the number of times this lock is acquired
 //
 void AbstractLockNode::create_lock_counter(JVMState* state) {
 _counter = OptoRuntime::new_named_counter(state, NamedCounter::LockCounter);
 }
-#endif
+void AbstractLockNode::set_eliminated_lock_counter() {
-void AbstractLockNode::set_eliminated() {
-_eliminate = true;
-#ifndef PRODUCT
 if (_counter) {
 // Update the counter to indicate that this lock was eliminated.
 // The counter update code will stay around even though the
 // optimizer will eliminate the lock operation itself.
 _counter->set_tag(NamedCounter::EliminatedLockCounter);
 }
+}
 #endif
-}
 //=============================================================================
 Node *LockNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 // perform any generic optimizations first (returns 'this' or NULL)
 // Now see if we can optimize away this lock.  We don't actually
 // remove the locking here, we simply set the _eliminate flag which
 // prevents macro expansion from expanding the lock.  Since we don't
 // modify the graph, the value returned from this function is the
 // one computed above.
-if (can_reshape && EliminateLocks && (!is_eliminated() || is_coarsened())) {
+if (can_reshape && EliminateLocks && !is_non_esc_obj()) {
 //
 // If we are locking an unescaped object, the lock/unlock is unnecessary
 //
 ConnectionGraph *cgr = phase->C->congraph();
 PointsToNode::EscapeState es = PointsToNode::GlobalEscape;
 if (cgr != NULL)
 es = cgr->escape_state(obj_node());
 if (es != PointsToNode::UnknownEscape && es != PointsToNode::GlobalEscape) {
-if (!is_eliminated()) {
+assert(!is_eliminated() || is_coarsened(), "sanity");
-// Mark it eliminated to update any counters
+// The lock could be marked eliminated by lock coarsening
-this->set_eliminated();
+// code during first IGVN before EA. Replace coarsened flag
-} else {
+// to eliminate all associated locks/unlocks.
-assert(is_coarsened(), "sanity");
+this->set_non_esc_obj();
-// The lock could be marked eliminated by lock coarsening
-// code during first IGVN before EA. Clear coarsened flag
-// to eliminate all associated locks/unlocks.
-this->clear_coarsened();
-}
 return result;
 }
 //
 // Try lock coarsening
 // for each of the identified locks, mark them
 // as eliminatable
 for (int i = 0; i < lock_ops.length(); i++) {
 AbstractLockNode* lock = lock_ops.at(i);
-// Mark it eliminated to update any counters
+// Mark it eliminated by coarsening and update any counters
-lock->set_eliminated();
 lock->set_coarsened();
 }
 } else if (ctrl->is_Region() &&
 iter->_worklist.member(ctrl)) {
 // We weren't able to find any opportunities but the region this
 return result;
 }
 //=============================================================================
+bool LockNode::is_nested_lock_region() {
+Node* box = box_node();
+if (!box->is_BoxLock() || box->as_BoxLock()->stack_slot() <= 0)
+return false; // External lock or it is not Box (Phi node).
+// Ignore complex cases: merged locks or multiple locks.
+BoxLockNode* box_lock = box->as_BoxLock();
+Node* obj = obj_node();
+LockNode* unique_lock = NULL;
+if (!box_lock->is_simple_lock_region(&unique_lock, obj) ||
+(unique_lock != this)) {
+return false;
+}
+// Look for external lock for the same object.
+int stk_slot = box_lock->stack_slot();
+SafePointNode* sfn = this->as_SafePoint();
+JVMState* youngest_jvms = sfn->jvms();
+int max_depth = youngest_jvms->depth();
+for (int depth = 1; depth <= max_depth; depth++) {
+JVMState* jvms = youngest_jvms->of_depth(depth);
+int num_mon  = jvms->nof_monitors();
+// Loop over monitors
+for (int idx = 0; idx < num_mon; idx++) {
+Node* obj_node = sfn->monitor_obj(jvms, idx);
+BoxLockNode* box_node = BoxLockNode::box_node(sfn->monitor_box(jvms, idx));
+if ((obj_node == obj) && (box_node->stack_slot() < stk_slot)) {
+return true;
+}
+}
+}
+return false;
+}
+//=============================================================================
 uint UnlockNode::size_of() const { return sizeof(*this); }
 //=============================================================================
 Node *UnlockNode::Ideal(PhaseGVN *phase, bool can_reshape) {
 // remove the unlocking here, we simply set the _eliminate flag which
 // prevents macro expansion from expanding the unlock.  Since we don't
 // modify the graph, the value returned from this function is the
 // one computed above.
 // Escape state is defined after Parse phase.
-if (can_reshape && EliminateLocks && (!is_eliminated() || is_coarsened())) {
+if (can_reshape && EliminateLocks && !is_non_esc_obj()) {
 //
 // If we are unlocking an unescaped object, the lock/unlock is unnecessary.
 //
 ConnectionGraph *cgr = phase->C->congraph();
 PointsToNode::EscapeState es = PointsToNode::GlobalEscape;
 if (cgr != NULL)
 es = cgr->escape_state(obj_node());
 if (es != PointsToNode::UnknownEscape && es != PointsToNode::GlobalEscape) {
-if (!is_eliminated()) {
+assert(!is_eliminated() || is_coarsened(), "sanity");
-// Mark it eliminated to update any counters
+// The lock could be marked eliminated by lock coarsening
-this->set_eliminated();
+// code during first IGVN before EA. Replace coarsened flag
-} else {
+// to eliminate all associated locks/unlocks.
-assert(is_coarsened(), "sanity");
+this->set_non_esc_obj();
-// The lock could be marked eliminated by lock coarsening
-// code during first IGVN before EA. Clear coarsened flag
-// to eliminate all associated locks/unlocks.
-this->clear_coarsened();
-}
 }
 }
 return result;
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/callnode.cpp

src/share/vm/opto/callnode.cpp