jdk-sandbox: comparison hotspot/src/cpu/x86/vm/macroAssembler

equal deleted inserted replaced

-:389ec536ece9
+:80d91e264baf
 //       : clear z flag if retry count exceeded
 // tmp_Reg, scr_Reg, flags are killed
 void MacroAssembler::rtm_retry_lock_on_busy(Register retry_count_Reg, Register box_Reg,
 Register tmp_Reg, Register scr_Reg, Label& retryLabel) {
 Label SpinLoop, SpinExit, doneRetry;
-// Clean monitor_value bit to get valid pointer
+int owner_offset = OM_OFFSET_NO_MONITOR_VALUE_TAG(owner);
-int owner_offset = ObjectMonitor::owner_offset_in_bytes() - markOopDesc::monitor_value;
 testl(retry_count_Reg, retry_count_Reg);
 jccb(Assembler::zero, doneRetry);
 decrementl(retry_count_Reg);
 movptr(scr_Reg, RTMSpinLoopCount);
 }
 // Use RTM for inflating locks
 // inputs: objReg (object to lock)
 //         boxReg (on-stack box address (displaced header location) - KILLED)
-//         tmpReg (ObjectMonitor address + 2(monitor_value))
+//         tmpReg (ObjectMonitor address + markOopDesc::monitor_value)
 void MacroAssembler::rtm_inflated_locking(Register objReg, Register boxReg, Register tmpReg,
 Register scrReg, Register retry_on_busy_count_Reg,
 Register retry_on_abort_count_Reg,
 RTMLockingCounters* rtm_counters,
 Metadata* method_data, bool profile_rtm,
 Label& DONE_LABEL) {
 assert(UseRTMLocking, "why call this otherwise?");
 assert(tmpReg == rax, "");
 assert(scrReg == rdx, "");
 Label L_rtm_retry, L_decrement_retry, L_on_abort;
-// Clean monitor_value bit to get valid pointer
+int owner_offset = OM_OFFSET_NO_MONITOR_VALUE_TAG(owner);
-int owner_offset = ObjectMonitor::owner_offset_in_bytes() - markOopDesc::monitor_value;
 // Without cast to int32_t a movptr will destroy r10 which is typically obj
 movptr(Address(boxReg, 0), (int32_t)intptr_t(markOopDesc::unused_mark()));
 movptr(boxReg, tmpReg); // Save ObjectMonitor address
 if (counters != NULL) {
 atomic_incl(ExternalAddress((address)counters->total_entry_count_addr()), scrReg);
 }
 if (EmitSync & 1) {
-// set box->dhw = unused_mark (3)
+// set box->dhw = markOopDesc::unused_mark()
 // Force all sync thru slow-path: slow_enter() and slow_exit()
 movptr (Address(boxReg, 0), (int32_t)intptr_t(markOopDesc::unused_mark()));
 cmpptr (rsp, (int32_t)NULL_WORD);
 } else
 if (EmitSync & 2) {
 ExternalAddress((address)counters->fast_path_entry_count_addr()));
 }
 jmp(DONE_LABEL);
 bind(IsInflated);
-// The object is inflated. tmpReg contains pointer to ObjectMonitor* + 2(monitor_value)
+// The object is inflated. tmpReg contains pointer to ObjectMonitor* + markOopDesc::monitor_value
 #if INCLUDE_RTM_OPT
 // Use the same RTM locking code in 32- and 64-bit VM.
 if (use_rtm) {
 rtm_inflated_locking(objReg, boxReg, tmpReg, scrReg, cx1Reg, cx2Reg,
 } else {
 #endif // INCLUDE_RTM_OPT
 #ifndef _LP64
 // The object is inflated.
-//
-// TODO-FIXME: eliminate the ugly use of manifest constants:
-//   Use markOopDesc::monitor_value instead of "2".
-//   use markOop::unused_mark() instead of "3".
-// The tmpReg value is an objectMonitor reference ORed with
-// markOopDesc::monitor_value (2).   We can either convert tmpReg to an
-// objectmonitor pointer by masking off the "2" bit or we can just
-// use tmpReg as an objectmonitor pointer but bias the objectmonitor
-// field offsets with "-2" to compensate for and annul the low-order tag bit.
-//
-// I use the latter as it avoids AGI stalls.
-// As such, we write "mov r, [tmpReg+OFFSETOF(Owner)-2]"
-// instead of "mov r, [tmpReg+OFFSETOF(Owner)]".
-//
-#define OFFSET_SKEWED(f) ((ObjectMonitor::f ## _offset_in_bytes())-2)
 // boxReg refers to the on-stack BasicLock in the current frame.
 // We'd like to write:
-//   set box->_displaced_header = markOop::unused_mark().  Any non-0 value suffices.
+//   set box->_displaced_header = markOopDesc::unused_mark().  Any non-0 value suffices.
 // This is convenient but results a ST-before-CAS penalty.  The following CAS suffers
 // additional latency as we have another ST in the store buffer that must drain.
 if (EmitSync & 8192) {
 movptr(Address(boxReg, 0), 3);            // results in ST-before-CAS penalty
 movptr(boxReg, tmpReg);                    // consider: LEA box, [tmp-2]
 movptr(tmpReg, NULL_WORD);                 // consider: xor vs mov
 if (os::is_MP()) {
 lock();
 }
-cmpxchgptr(scrReg, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(scrReg, Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 } else
 if ((EmitSync & 128) == 0) {                      // avoid ST-before-CAS
 movptr(scrReg, boxReg);
 movptr(boxReg, tmpReg);                   // consider: LEA box, [tmp-2]
 // Using a prefetchw helps avoid later RTS->RTO upgrades and cache probes
 if ((EmitSync & 2048) && VM_Version::supports_3dnow_prefetch() && os::is_MP()) {
 // prefetchw [eax + Offset(_owner)-2]
-prefetchw(Address(tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+prefetchw(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 }
 if ((EmitSync & 64) == 0) {
 // Optimistic form: consider XORL tmpReg,tmpReg
 movptr(tmpReg, NULL_WORD);
 } else {
 // Can suffer RTS->RTO upgrades on shared or cold $ lines
 // Test-And-CAS instead of CAS
-movptr(tmpReg, Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));   // rax, = m->_owner
+movptr(tmpReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));   // rax, = m->_owner
 testptr(tmpReg, tmpReg);                   // Locked ?
 jccb  (Assembler::notZero, DONE_LABEL);
 }
 // Appears unlocked - try to swing _owner from null to non-null.
 // (rsp or the address of the box) into  m->owner is harmless.
 // Invariant: tmpReg == 0.  tmpReg is EAX which is the implicit cmpxchg comparand.
 if (os::is_MP()) {
 lock();
 }
-cmpxchgptr(scrReg, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(scrReg, Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 movptr(Address(scrReg, 0), 3);          // box->_displaced_header = 3
 jccb  (Assembler::notZero, DONE_LABEL);
 get_thread (scrReg);                    // beware: clobbers ICCs
-movptr(Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2), scrReg);
+movptr(Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), scrReg);
 xorptr(boxReg, boxReg);                 // set icc.ZFlag = 1 to indicate success
 // If the CAS fails we can either retry or pass control to the slow-path.
 // We use the latter tactic.
 // Pass the CAS result in the icc.ZFlag into DONE_LABEL
 movptr(boxReg, tmpReg);
 // Using a prefetchw helps avoid later RTS->RTO upgrades and cache probes
 if ((EmitSync & 2048) && VM_Version::supports_3dnow_prefetch() && os::is_MP()) {
 // prefetchw [eax + Offset(_owner)-2]
-prefetchw(Address(tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+prefetchw(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 }
 if ((EmitSync & 64) == 0) {
 // Optimistic form
 xorptr  (tmpReg, tmpReg);
 } else {
 // Can suffer RTS->RTO upgrades on shared or cold $ lines
-movptr(tmpReg, Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));   // rax, = m->_owner
+movptr(tmpReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));   // rax, = m->_owner
 testptr(tmpReg, tmpReg);                   // Locked ?
 jccb  (Assembler::notZero, DONE_LABEL);
 }
 // Appears unlocked - try to swing _owner from null to non-null.
 // Invariant: tmpReg == 0.  tmpReg is EAX which is the implicit cmpxchg comparand.
 get_thread (scrReg);
 if (os::is_MP()) {
 lock();
 }
-cmpxchgptr(scrReg, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(scrReg, Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 // If the CAS fails we can either retry or pass control to the slow-path.
 // We use the latter tactic.
 // Pass the CAS result in the icc.ZFlag into DONE_LABEL
 // If the CAS was successful ...
 // Without cast to int32_t a movptr will destroy r10 which is typically obj
 movptr(Address(boxReg, 0), (int32_t)intptr_t(markOopDesc::unused_mark()));
 movptr (boxReg, tmpReg);
-movptr (tmpReg, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+movptr(tmpReg, Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 testptr(tmpReg, tmpReg);
 jccb   (Assembler::notZero, DONE_LABEL);
 // It's inflated and appears unlocked
 if (os::is_MP()) {
 lock();
 }
-cmpxchgptr(r15_thread, Address(boxReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(r15_thread, Address(boxReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 // Intentional fall-through into DONE_LABEL ...
 #endif // _LP64
 #if INCLUDE_RTM_OPT
 } // use_rtm()
 // It's inflated.
 #if INCLUDE_RTM_OPT
 if (use_rtm) {
 Label L_regular_inflated_unlock;
-// Clean monitor_value bit to get valid pointer
+int owner_offset = OM_OFFSET_NO_MONITOR_VALUE_TAG(owner);
-int owner_offset = ObjectMonitor::owner_offset_in_bytes() - markOopDesc::monitor_value;
 movptr(boxReg, Address(tmpReg, owner_offset));
 testptr(boxReg, boxReg);
 jccb(Assembler::notZero, L_regular_inflated_unlock);
 xend();
 jmpb(DONE_LABEL);
 // See also http://gee.cs.oswego.edu/dl/jmm/cookbook.html.
 #ifndef _LP64
 get_thread (boxReg);
 if ((EmitSync & 4096) && VM_Version::supports_3dnow_prefetch() && os::is_MP()) {
 // prefetchw [ebx + Offset(_owner)-2]
-prefetchw(Address(tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+prefetchw(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 }
 // Note that we could employ various encoding schemes to reduce
 // the number of loads below (currently 4) to just 2 or 3.
 // Refer to the comments in synchronizer.cpp.
 // In practice the chain of fetches doesn't seem to impact performance, however.
 if ((EmitSync & 65536) == 0 && (EmitSync & 256)) {
 // Attempt to reduce branch density - AMD's branch predictor.
-xorptr(boxReg, Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+xorptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
-orptr(boxReg, Address (tmpReg, ObjectMonitor::recursions_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)));
-orptr(boxReg, Address (tmpReg, ObjectMonitor::EntryList_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(EntryList)));
-orptr(boxReg, Address (tmpReg, ObjectMonitor::cxq_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(cxq)));
 jccb  (Assembler::notZero, DONE_LABEL);
-movptr(Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), NULL_WORD);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), NULL_WORD);
 jmpb  (DONE_LABEL);
 } else {
-xorptr(boxReg, Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+xorptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
-orptr(boxReg, Address (tmpReg, ObjectMonitor::recursions_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)));
 jccb  (Assembler::notZero, DONE_LABEL);
-movptr(boxReg, Address (tmpReg, ObjectMonitor::EntryList_offset_in_bytes()-2));
+movptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(EntryList)));
-orptr(boxReg, Address (tmpReg, ObjectMonitor::cxq_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(cxq)));
 jccb  (Assembler::notZero, CheckSucc);
-movptr(Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), NULL_WORD);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), NULL_WORD);
 jmpb  (DONE_LABEL);
 }
 // The Following code fragment (EmitSync & 65536) improves the performance of
 // contended applications and contended synchronization microbenchmarks.
 bind  (CheckSucc);
 // Optional pre-test ... it's safe to elide this
 if ((EmitSync & 16) == 0) {
-cmpptr(Address (tmpReg, ObjectMonitor::succ_offset_in_bytes()-2), (int32_t)NULL_WORD);
+cmpptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(succ)), (int32_t)NULL_WORD);
 jccb  (Assembler::zero, LGoSlowPath);
 }
 // We have a classic Dekker-style idiom:
 //    ST m->_owner = 0 ; MEMBAR; LD m->_succ
 //     remains in M-state for the lock:orl.
 //
 // We currently use (3), although it's likely that switching to (2)
 // is correct for the future.
-movptr(Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), NULL_WORD);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), NULL_WORD);
 if (os::is_MP()) {
 if (VM_Version::supports_sse2() && 1 == FenceInstruction) {
 mfence();
 } else {
 lock (); addptr(Address(rsp, 0), 0);
 }
 }
 // Ratify _succ remains non-null
-cmpptr(Address (tmpReg, ObjectMonitor::succ_offset_in_bytes()-2), 0);
+cmpptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(succ)), 0);
 jccb  (Assembler::notZero, LSuccess);
 xorptr(boxReg, boxReg);                  // box is really EAX
 if (os::is_MP()) { lock(); }
-cmpxchgptr(rsp, Address(tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(rsp, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 jccb  (Assembler::notEqual, LSuccess);
 // Since we're low on registers we installed rsp as a placeholding in _owner.
 // Now install Self over rsp.  This is safe as we're transitioning from
 // non-null to non=null
 get_thread (boxReg);
-movptr(Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), boxReg);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), boxReg);
 // Intentional fall-through into LGoSlowPath ...
 bind  (LGoSlowPath);
 orptr(boxReg, 1);                      // set ICC.ZF=0 to indicate failure
 jmpb  (DONE_LABEL);
 if ((EmitSync & 65536) == 0) {
 bind (CheckSucc);
 }
 #else // _LP64
 // It's inflated
-movptr(boxReg, Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+movptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 xorptr(boxReg, r15_thread);
-orptr (boxReg, Address (tmpReg, ObjectMonitor::recursions_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(recursions)));
 jccb  (Assembler::notZero, DONE_LABEL);
-movptr(boxReg, Address (tmpReg, ObjectMonitor::cxq_offset_in_bytes()-2));
+movptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(cxq)));
-orptr (boxReg, Address (tmpReg, ObjectMonitor::EntryList_offset_in_bytes()-2));
+orptr(boxReg, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(EntryList)));
 jccb  (Assembler::notZero, CheckSucc);
-movptr(Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), (int32_t)NULL_WORD);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), (int32_t)NULL_WORD);
 jmpb  (DONE_LABEL);
 if ((EmitSync & 65536) == 0) {
 Label LSuccess, LGoSlowPath ;
 bind  (CheckSucc);
-cmpptr(Address (tmpReg, ObjectMonitor::succ_offset_in_bytes()-2), (int32_t)NULL_WORD);
+cmpptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(succ)), (int32_t)NULL_WORD);
 jccb  (Assembler::zero, LGoSlowPath);
 // I'd much rather use lock:andl m->_owner, 0 as it's faster than the
 // the explicit ST;MEMBAR combination, but masm doesn't currently support
 // "ANDQ M,IMM".  Don't use MFENCE here.  lock:add to TOS, xchg, etc
 // are all faster when the write buffer is populated.
-movptr (Address (tmpReg, ObjectMonitor::owner_offset_in_bytes()-2), (int32_t)NULL_WORD);
+movptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)), (int32_t)NULL_WORD);
 if (os::is_MP()) {
 lock (); addl (Address(rsp, 0), 0);
 }
-cmpptr(Address (tmpReg, ObjectMonitor::succ_offset_in_bytes()-2), (int32_t)NULL_WORD);
+cmpptr(Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(succ)), (int32_t)NULL_WORD);
 jccb  (Assembler::notZero, LSuccess);
 movptr (boxReg, (int32_t)NULL_WORD);                   // box is really EAX
 if (os::is_MP()) { lock(); }
-cmpxchgptr(r15_thread, Address(tmpReg, ObjectMonitor::owner_offset_in_bytes()-2));
+cmpxchgptr(r15_thread, Address(tmpReg, OM_OFFSET_NO_MONITOR_VALUE_TAG(owner)));
 jccb  (Assembler::notEqual, LSuccess);
 // Intentional fall-through into slow-path
 bind  (LGoSlowPath);
 orl   (boxReg, 1);                      // set ICC.ZF=0 to indicate failure

changeset 27608	80d91e264baf
parent 26434	09ad55e5f486
child 27636	2d749ba03ff5