Mercurial > hg > truffle
diff src/share/vm/opto/locknode.cpp @ 4970:33df1aeaebbf
Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/
author | Thomas Wuerthinger <thomas.wuerthinger@oracle.com> |
---|---|
date | Mon, 27 Feb 2012 13:10:13 +0100 |
parents | 89d0a5d40008 |
children | b9a9ed0f8eeb |
line wrap: on
line diff
--- a/src/share/vm/opto/locknode.cpp Fri Feb 24 18:30:42 2012 -0800 +++ b/src/share/vm/opto/locknode.cpp Mon Feb 27 13:10:13 2012 +0100 @@ -49,18 +49,22 @@ //-----------------------------hash-------------------------------------------- uint BoxLockNode::hash() const { + if (EliminateNestedLocks) + return NO_HASH; // Each locked region has own BoxLock node return Node::hash() + _slot + (_is_eliminated ? Compile::current()->fixed_slots() : 0); } //------------------------------cmp-------------------------------------------- uint BoxLockNode::cmp( const Node &n ) const { + if (EliminateNestedLocks) + return (&n == this); // Always fail except on self const BoxLockNode &bn = (const BoxLockNode &)n; return bn._slot == _slot && bn._is_eliminated == _is_eliminated; } -OptoReg::Name BoxLockNode::stack_slot(Node* box_node) { - // Chase down the BoxNode - while (!box_node->is_BoxLock()) { +BoxLockNode* BoxLockNode::box_node(Node* box) { + // Chase down the BoxNode after RA which may spill box nodes. + while (!box->is_BoxLock()) { // if (box_node->is_SpillCopy()) { // Node *m = box_node->in(1); // if (m->is_Mach() && m->as_Mach()->ideal_Opcode() == Op_StoreP) { @@ -68,10 +72,64 @@ // continue; // } // } - assert(box_node->is_SpillCopy() || box_node->is_Phi(), "Bad spill of Lock."); - box_node = box_node->in(1); + assert(box->is_SpillCopy() || box->is_Phi(), "Bad spill of Lock."); + // Only BoxLock nodes with the same stack slot are merged. + // So it is enough to trace one path to find the slot value. + box = box->in(1); } - return box_node->in_RegMask(0).find_first_elem(); + return box->as_BoxLock(); +} + +OptoReg::Name BoxLockNode::reg(Node* box) { + return box_node(box)->in_RegMask(0).find_first_elem(); +} + +// Is BoxLock node used for one simple lock region (same box and obj)? +bool BoxLockNode::is_simple_lock_region(LockNode** unique_lock, Node* obj) { + LockNode* lock = NULL; + bool has_one_lock = false; + for (uint i = 0; i < this->outcnt(); i++) { + Node* n = this->raw_out(i); + assert(!n->is_Phi(), "should not merge BoxLock nodes"); + if (n->is_AbstractLock()) { + AbstractLockNode* alock = n->as_AbstractLock(); + // Check lock's box since box could be referenced by Lock's debug info. + if (alock->box_node() == this) { + if (alock->obj_node()->eqv_uncast(obj)) { + if ((unique_lock != NULL) && alock->is_Lock()) { + if (lock == NULL) { + lock = alock->as_Lock(); + has_one_lock = true; + } else if (lock != alock->as_Lock()) { + has_one_lock = false; + } + } + } else { + return false; // Different objects + } + } + } + } +#ifdef ASSERT + // Verify that FastLock and Safepoint reference only this lock region. + for (uint i = 0; i < this->outcnt(); i++) { + Node* n = this->raw_out(i); + if (n->is_FastLock()) { + FastLockNode* flock = n->as_FastLock(); + assert((flock->box_node() == this) && flock->obj_node()->eqv_uncast(obj),""); + } + // Don't check monitor info in safepoints since the referenced object could + // be different from the locked object. It could be Phi node of different + // cast nodes which point to this locked object. + // We assume that no other objects could be referenced in monitor info + // associated with this BoxLock node because all associated locks and + // unlocks are reference only this one object. + } +#endif + if (unique_lock != NULL && has_one_lock) { + *unique_lock = lock; + } + return true; } //=============================================================================