< prev index next >

src/hotspot/cpu/sparc/interp_masm_sparc.cpp

Print this page

        

@@ -27,11 +27,11 @@
 #include "interp_masm_sparc.hpp"
 #include "interpreter/interpreter.hpp"
 #include "interpreter/interpreterRuntime.hpp"
 #include "logging/log.hpp"
 #include "oops/arrayOop.hpp"
-#include "oops/markWord.hpp"
+#include "oops/markOop.hpp"
 #include "oops/methodData.hpp"
 #include "oops/method.hpp"
 #include "oops/methodCounters.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "prims/jvmtiThreadState.hpp"

@@ -1198,45 +1198,45 @@
 
     Label slow_case;
 
     assert_different_registers(lock_reg, obj_reg, mark_reg, temp_reg);
 
-    // load markWord from object into mark_reg
+    // load markOop from object into mark_reg
     ld_ptr(mark_addr, mark_reg);
 
     if (UseBiasedLocking) {
       biased_locking_enter(obj_reg, mark_reg, temp_reg, done, &slow_case);
     }
 
     // get the address of basicLock on stack that will be stored in the object
     // we need a temporary register here as we do not want to clobber lock_reg
     // (cas clobbers the destination register)
     mov(lock_reg, temp_reg);
-    // set mark reg to be (markWord of object | UNLOCK_VALUE)
-    or3(mark_reg, markWord::unlocked_value, mark_reg);
+    // set mark reg to be (markOop of object | UNLOCK_VALUE)
+    or3(mark_reg, markOopDesc::unlocked_value, mark_reg);
     // initialize the box  (Must happen before we update the object mark!)
     st_ptr(mark_reg, lock_addr, BasicLock::displaced_header_offset_in_bytes());
-    // compare and exchange object_addr, markWord | 1, stack address of basicLock
+    // compare and exchange object_addr, markOop | 1, stack address of basicLock
     assert(mark_addr.disp() == 0, "cas must take a zero displacement");
     cas_ptr(mark_addr.base(), mark_reg, temp_reg);
 
     // if the compare and exchange succeeded we are done (we saw an unlocked object)
     cmp_and_brx_short(mark_reg, temp_reg, Assembler::equal, Assembler::pt, done);
 
     // We did not see an unlocked object so try the fast recursive case
 
-    // Check if owner is self by comparing the value in the markWord of object
+    // Check if owner is self by comparing the value in the markOop of object
     // with the stack pointer
     sub(temp_reg, SP, temp_reg);
     sub(temp_reg, STACK_BIAS, temp_reg);
     assert(os::vm_page_size() > 0xfff, "page size too small - change the constant");
 
     // Composite "andcc" test:
     // (a) %sp -vs- markword proximity check, and,
     // (b) verify mark word LSBs == 0 (Stack-locked).
     //
-    // FFFFF003/FFFFFFFFFFFF003 is (markWord::lock_mask_in_place | -os::vm_page_size())
+    // FFFFF003/FFFFFFFFFFFF003 is (markOopDesc::lock_mask_in_place | -os::vm_page_size())
     // Note that the page size used for %sp proximity testing is arbitrary and is
     // unrelated to the actual MMU page size.  We use a 'logical' page size of
     // 4096 bytes.   F..FFF003 is designed to fit conveniently in the SIMM13 immediate
     // field of the andcc instruction.
     andcc (temp_reg, 0xFFFFF003, G0) ;
< prev index next >