Mercurial > hg > jdk9-shenandoah > hotspot

changeset 9453:1650eab95d25

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename interpreter barriers.
author rkennke
date Thu, 20 Aug 2015 17:52:12 +0200
parents f7786999dcd2
children 1538d2529fb8
files src/cpu/x86/vm/c1_LIRAssembler_x86.cpp src/cpu/x86/vm/interp_masm_x86.cpp src/cpu/x86/vm/jniFastGetField_x86_64.cpp src/cpu/x86/vm/macroAssembler_x86.cpp src/cpu/x86/vm/methodHandles_x86.cpp src/cpu/x86/vm/sharedRuntime_x86_64.cpp src/cpu/x86/vm/shenandoahBarrierSet_x86.cpp src/cpu/x86/vm/templateInterpreter_x86_64.cpp src/cpu/x86/vm/templateTable_x86.cpp src/share/vm/gc/shared/barrierSet.hpp src/share/vm/gc/shenandoah/shenandoahBarrierSet.hpp
diffstat 11 files changed, 82 insertions(+), 92 deletions(-) [+]
line wrap: on
line diff
--- a/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -2036,11 +2036,11 @@
           __ jcc(Assembler::equal, done);
 
           // Resolve the original cmp value.
-          oopDesc::bs()->compile_resolve_oop(masm(), op->tmp1()->as_register());
+          oopDesc::bs()->interpreter_read_barrier(masm(), op->tmp1()->as_register());
           // Resolve the old value at address. We get the old value in cmp/rax
           // when the comparison in cmpxchg failed.
           __ movptr(op->tmp2()->as_register(), cmpval);
-          oopDesc::bs()->compile_resolve_oop(masm(), op->tmp2()->as_register());
+          oopDesc::bs()->interpreter_read_barrier(masm(), op->tmp2()->as_register());
 
           // We're done if the expected/cmp value is not the same as old. It's a valid
           // cmpxchg failure then. Otherwise we need special treatment for Shenandoah
--- a/src/cpu/x86/vm/interp_masm_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/interp_masm_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -1063,7 +1063,7 @@
     movptr(obj_reg, Address(lock_reg, obj_offset));
 
     // Need to preemptively evacuate obj because we CAS the mark word later.
-    oopDesc::bs()->compile_resolve_oop_for_write(this, obj_reg, false, 0, 1, BarrierSet::ss_c_rarg1);
+    oopDesc::bs()->interpreter_write_barrier(this, obj_reg, false, 0, 1, BarrierSet::ss_c_rarg1);
 
     if (UseBiasedLocking) {
       biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp_reg, false, done, &slow_case);
@@ -1161,7 +1161,7 @@
     movptr(obj_reg, Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()));
 
     // Need to preemptively evacuate obj because we CAS the mark word later.
-    oopDesc::bs()->compile_resolve_oop_for_write(this, obj_reg, false, 0, 1, BarrierSet::ss_c_rarg1);
+    oopDesc::bs()->interpreter_write_barrier(this, obj_reg, false, 0, 1, BarrierSet::ss_c_rarg1);
 
     // Free entry
     movptr(Address(lock_reg, BasicObjectLock::obj_offset_in_bytes()), (int32_t)NULL_WORD);
--- a/src/cpu/x86/vm/jniFastGetField_x86_64.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/jniFastGetField_x86_64.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -81,7 +81,7 @@
                                                 // robj is data dependent on rcounter.
   }
   __ movptr(robj, Address(robj, 0));             // *obj
-  oopDesc::bs()->compile_resolve_oop(masm, robj);
+  oopDesc::bs()->interpreter_read_barrier(masm, robj);
   __ mov   (roffset, c_rarg2);
   __ shrptr(roffset, 2);                         // offset
 
@@ -180,7 +180,7 @@
                                                 // robj is data dependent on rcounter.
   }
   __ movptr(robj, Address(robj, 0));             // *obj
-  oopDesc::bs()->compile_resolve_oop(masm, robj);
+  oopDesc::bs()->interpreter_read_barrier(masm, robj);
   __ mov   (roffset, c_rarg2);
   __ shrptr(roffset, 2);                         // offset
 
--- a/src/cpu/x86/vm/macroAssembler_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/macroAssembler_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -3680,7 +3680,7 @@
     // NOTE: cmpl is plenty here to provoke a segv
 
     if (ShenandoahVerifyReadsToFromSpace) {
-      oopDesc::bs()->compile_resolve_oop(this, reg);
+      oopDesc::bs()->interpreter_read_barrier(this, reg);
     }
 
     cmpptr(rax, Address(reg, 0));
@@ -5657,7 +5657,7 @@
 
 void MacroAssembler::load_klass(Register dst, Register src) {
   if (ShenandoahVerifyReadsToFromSpace) {
-    oopDesc::bs()->compile_resolve_oop(this, src);
+    oopDesc::bs()->interpreter_read_barrier(this, src);
   }
 #ifdef _LP64
   if (UseCompressedClassPointers) {
--- a/src/cpu/x86/vm/methodHandles_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/methodHandles_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -165,10 +165,10 @@
   //NOT_PRODUCT({ FlagSetting fs(TraceMethodHandles, true); trace_method_handle(_masm, "LZMH"); });
 
   // Load the invoker, as MH -> MH.form -> LF.vmentry
-  oopDesc::bs()->compile_resolve_oop(_masm, recv);
+  oopDesc::bs()->interpreter_read_barrier(_masm, recv);
   __ verify_oop(recv);
   __ load_heap_oop(method_temp, Address(recv, NONZERO(java_lang_invoke_MethodHandle::form_offset_in_bytes())));
-  oopDesc::bs()->compile_resolve_oop(_masm, method_temp);
+  oopDesc::bs()->interpreter_read_barrier(_masm, method_temp);
   __ verify_oop(method_temp);
   __ load_heap_oop(method_temp, Address(method_temp, NONZERO(java_lang_invoke_LambdaForm::vmentry_offset_in_bytes())));
   __ verify_oop(method_temp);
@@ -183,7 +183,7 @@
                         sizeof(u2), /*is_signed*/ false);
     // assert(sizeof(u2) == sizeof(Method::_size_of_parameters), "");
     __ movptr(temp2, __ argument_address(temp2, -1));
-    oopDesc::bs()->compile_resolve_oop(_masm, temp2);
+    oopDesc::bs()->interpreter_read_barrier(_masm, temp2);
     Label L;
     __ cmpptr(recv, temp2);
     __ jcc(Assembler::equal, L);
@@ -380,7 +380,7 @@
     //  rsi/r13 - interpreter linkage (if interpreted)
     //  rcx, rdx, rsi, rdi, r8 - compiler arguments (if compiled)
 
-    oopDesc::bs()->compile_resolve_oop(_masm, member_reg);
+    oopDesc::bs()->interpreter_read_barrier(_masm, member_reg);
     Label L_incompatible_class_change_error;
     switch (iid) {
     case vmIntrinsics::_linkToSpecial:
--- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -2446,7 +2446,7 @@
 
     // Load the oop from the handle
     __ movptr(obj_reg, Address(oop_handle_reg, 0));
-    oopDesc::bs()->compile_resolve_oop(masm, obj_reg);
+    oopDesc::bs()->interpreter_read_barrier(masm, obj_reg);
     if (UseBiasedLocking) {
       __ biased_locking_enter(lock_reg, obj_reg, swap_reg, rscratch1, false, lock_done, &slow_path_lock);
     }
@@ -2615,7 +2615,7 @@
 
     // Get locked oop from the handle we passed to jni
     __ movptr(obj_reg, Address(oop_handle_reg, 0));
-    oopDesc::bs()->compile_resolve_oop(masm, obj_reg);
+    oopDesc::bs()->interpreter_read_barrier(masm, obj_reg);
 
     Label done;
 
--- a/src/cpu/x86/vm/shenandoahBarrierSet_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/shenandoahBarrierSet_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -146,18 +146,18 @@
 }
 
 // TODO: The following should really live in an X86 specific subclass.
-void ShenandoahBarrierSet::compile_resolve_oop(MacroAssembler* masm, Register dst) {
+void ShenandoahBarrierSet::interpreter_read_barrier(MacroAssembler* masm, Register dst) {
   if (ShenandoahReadBarrier) {
 
     Label is_null;
     __ testptr(dst, dst);
     __ jcc(Assembler::zero, is_null);
-    compile_resolve_oop_not_null(masm, dst);
+    interpreter_read_barrier_not_null(masm, dst);
     __ bind(is_null);
   }
 }
 
-void ShenandoahBarrierSet::compile_resolve_oop_not_null(MacroAssembler* masm, Register dst) {
+void ShenandoahBarrierSet::interpreter_read_barrier_not_null(MacroAssembler* masm, Register dst) {
   if (ShenandoahReadBarrier) {
     if (ShenandoahVerifyReadsToFromSpace) {
       compile_resolve_oop_runtime(masm, dst);
@@ -167,11 +167,11 @@
   }
 }
 
-void ShenandoahBarrierSet::compile_resolve_oop_for_write(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_state_save, ...) {
+void ShenandoahBarrierSet::interpreter_write_barrier(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_state_save, ...) {
 
   if (! ShenandoahWriteBarrier) {
     assert(! ShenandoahConcurrentEvacuation, "Can only do this without concurrent evacuation");
-    return compile_resolve_oop(masm, dst);
+    return interpreter_read_barrier(masm, dst);
   }
       
   assert(dst != rscratch1, "different regs");
@@ -193,7 +193,7 @@
   __ cmpb(evacuation_in_progress, 0);
 
   // Now check if evacuation is in progress.
-  compile_resolve_oop_not_null(masm, dst);
+  interpreter_read_barrier_not_null(masm, dst);
 
   __ jcc(Assembler::equal, done);
   __ push(rscratch1);
@@ -337,15 +337,4 @@
   __ bind(done);
 }
 
-/*
-void ShenandoahBarrierSet::compile_resolve_oop_for_write(MacroAssembler* masm, Register dst) {
-
-  Label is_null;
-  __ testptr(dst, dst);
-  __ jcc(Assembler::zero, is_null);
-  compile_resolve_oop_for_write_not_null(masm, dst);
-  __ bind(is_null);
-
-}
-*/
 #endif
--- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -545,7 +545,7 @@
 #endif // ASSERT
 
     __ bind(done);
-    oopDesc::bs()->compile_resolve_oop(_masm, rax);
+    oopDesc::bs()->interpreter_read_barrier(_masm, rax);
   }
 
   // add space for monitor & lock
@@ -649,7 +649,7 @@
     __ testptr(rax, rax);
     __ jcc(Assembler::zero, slow_path);
 
-    oopDesc::bs()->compile_resolve_oop_not_null(_masm, rax);
+    oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rax);
 
     // rax: local 0
     // rbx: method (but can be used as scratch now)
@@ -781,7 +781,7 @@
       __ movl(crc,   Address(rsp, 5*wordSize)); // Initial CRC
     } else {
       __ movptr(buf, Address(rsp, 3*wordSize)); // byte[] array
-      oopDesc::bs()->compile_resolve_oop_not_null(_masm, buf);
+      oopDesc::bs()->interpreter_read_barrier_not_null(_masm, buf);
       __ addptr(buf, arrayOopDesc::base_offset_in_bytes(T_BYTE)); // + header size
       __ movl2ptr(off, Address(rsp, 2*wordSize)); // offset
       __ addq(buf, off); // + offset
--- a/src/cpu/x86/vm/templateTable_x86.cpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/cpu/x86/vm/templateTable_x86.cpp	Thu Aug 20 17:52:12 2015 +0200
@@ -191,7 +191,7 @@
             __ movptr(new_val, val);
           }
           // For Shenandoah, make sure we only store refs into to-space.
-          oopDesc::bs()->compile_resolve_oop(_masm, val);
+          oopDesc::bs()->interpreter_read_barrier(_masm, val);
 
           __ store_heap_oop(Address(rdx, 0), val);
           __ g1_write_barrier_post(rdx /* store_adr */,
@@ -689,7 +689,7 @@
   // check array
 
   if (ShenandoahVerifyReadsToFromSpace) {
-    oopDesc::bs()->compile_resolve_oop(_masm, array);
+    oopDesc::bs()->interpreter_read_barrier(_masm, array);
   }
 
   __ null_check(array, arrayOopDesc::length_offset_in_bytes());
@@ -712,7 +712,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ movl(rax, Address(rdx, rax,
                        Address::times_4,
                        arrayOopDesc::base_offset_in_bytes(T_INT)));
@@ -725,7 +725,7 @@
   index_check(rdx, rax); // kills rbx
   NOT_LP64(__ mov(rbx, rax));
   // rbx,: index
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ movptr(rax, Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 0 * wordSize));
   NOT_LP64(__ movl(rdx, Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 1 * wordSize)));
 }
@@ -737,7 +737,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   LP64_ONLY(__ movflt(xmm0, Address(rdx, rax,
                          Address::times_4,
                          arrayOopDesc::base_offset_in_bytes(T_FLOAT))));
@@ -749,7 +749,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   LP64_ONLY(__ movdbl(xmm0, Address(rdx, rax,
                           Address::times_8,
                           arrayOopDesc::base_offset_in_bytes(T_DOUBLE))));
@@ -761,7 +761,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ load_heap_oop(rax, Address(rdx, rax,
                                 UseCompressedOops ? Address::times_4 : Address::times_ptr,
                                 arrayOopDesc::base_offset_in_bytes(T_OBJECT)));
@@ -772,7 +772,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ load_signed_byte(rax, Address(rdx, rax, Address::times_1, arrayOopDesc::base_offset_in_bytes(T_BYTE)));
 }
 
@@ -781,7 +781,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ load_unsigned_short(rax, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_CHAR)));
 }
 
@@ -795,7 +795,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ load_unsigned_short(rax,
                          Address(rdx, rax,
                                  Address::times_2,
@@ -808,7 +808,7 @@
   // rax: index
   // rdx: array
   index_check(rdx, rax); // kills rbx
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx);
   __ load_signed_short(rax, Address(rdx, rax, Address::times_2, arrayOopDesc::base_offset_in_bytes(T_SHORT)));
 }
 
@@ -1007,7 +1007,7 @@
   // rbx: index
   // rdx: array
   index_check(rdx, rbx); // prefer index in rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
   __ movl(Address(rdx, rbx,
                   Address::times_4,
                   arrayOopDesc::base_offset_in_bytes(T_INT)),
@@ -1022,7 +1022,7 @@
   // rdx: high(value)
   index_check(rcx, rbx);  // prefer index in rbx,
   // rbx,: index
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax, BarrierSet::ss_rdx);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax, BarrierSet::ss_rdx);
   __ movptr(Address(rcx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 0 * wordSize), rax);
   NOT_LP64(__ movl(Address(rcx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_LONG) + 1 * wordSize), rdx));
 }
@@ -1035,7 +1035,7 @@
   // rbx:  index
   // rdx:  array
   index_check(rdx, rbx); // prefer index in rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_ftos);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_ftos);
   LP64_ONLY(__ movflt(Address(rdx, rbx,
                    Address::times_4,
                    arrayOopDesc::base_offset_in_bytes(T_FLOAT)),
@@ -1050,7 +1050,7 @@
   // rbx:  index
   // rdx:  array
   index_check(rdx, rbx); // prefer index in rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_dtos);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_dtos);
   LP64_ONLY(__ movdbl(Address(rdx, rbx,
                    Address::times_8,
                    arrayOopDesc::base_offset_in_bytes(T_DOUBLE)),
@@ -1071,7 +1071,7 @@
                           arrayOopDesc::base_offset_in_bytes(T_OBJECT));
 
   index_check_without_pop(rdx, rcx);     // kills rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 3, 3, BarrierSet::noreg, BarrierSet::ss_rcx, BarrierSet::ss_rax);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 3, 3, BarrierSet::noreg, BarrierSet::ss_rcx, BarrierSet::ss_rax);
   __ testptr(rax, rax);
   __ jcc(Assembler::zero, is_null);
 
@@ -1120,7 +1120,7 @@
   // rbx: index
   // rdx: array
   index_check(rdx, rbx); // prefer index in rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
   __ movb(Address(rdx, rbx,
                   Address::times_1,
                   arrayOopDesc::base_offset_in_bytes(T_BYTE)),
@@ -1134,7 +1134,7 @@
   // rbx: index
   // rdx: array
   index_check(rdx, rbx);  // prefer index in rbx
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rdx, false, 0, 3, BarrierSet::noreg, BarrierSet::ss_rbx, BarrierSet::ss_rax);
   __ movw(Address(rdx, rbx,
                   Address::times_2,
                   arrayOopDesc::base_offset_in_bytes(T_CHAR)),
@@ -2238,9 +2238,9 @@
   // NOTE: We need to preemptively evacuate the oops here (for Shenandoah GC), because
   // we might get false negatives if both operands are the same, but another
   // thread evacuates between the load of the 1st and 2nd operand.
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rax, true, 0, 0);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rax, true, 0, 0);
   __ pop_ptr(rdx);
-  oopDesc::bs()->compile_resolve_oop(_masm, rdx);
+  oopDesc::bs()->interpreter_read_barrier(_masm, rdx);
   __ cmpptr(rdx, rax);
   __ jcc(j_not(cc), not_taken);
   branch(false, false);
@@ -2681,7 +2681,7 @@
   load_field_cp_cache_entry(obj, cache, index, off, flags, is_static);
 
   if (!is_static) pop_and_check_object(obj);
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, obj);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, obj);
 
   const Address field(obj, off, Address::times_1, 0*wordSize);
   NOT_LP64(const Address hi(obj, off, Address::times_1, 1*wordSize));
@@ -2954,9 +2954,9 @@
     __ pop(btos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     __ movb(field, rax);
     if (!is_static && rc == may_rewrite) {
@@ -2974,9 +2974,9 @@
     __ pop(atos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     // Store into the field
     do_oop_store(_masm, field, rax, _bs->kind(), false);
@@ -2995,9 +2995,9 @@
     __ pop(itos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     __ movl(field, rax);
     if (!is_static && rc == may_rewrite) {
@@ -3015,9 +3015,9 @@
     __ pop(ctos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     __ movw(field, rax);
     if (!is_static && rc == may_rewrite) {
@@ -3035,9 +3035,9 @@
     __ pop(stos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     __ movw(field, rax);
     if (!is_static && rc == may_rewrite) {
@@ -3056,9 +3056,9 @@
     __ pop(ltos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     __ movq(field, rax);
     if (!is_static && rc == may_rewrite) {
@@ -3107,9 +3107,9 @@
     __ pop(ftos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     NOT_LP64( __ fstp_s(field);)
     LP64_ONLY( __ movflt(field, xmm0);)
@@ -3130,9 +3130,9 @@
     __ pop(dtos);
     if (!is_static) {
       pop_and_check_object(obj);
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     } else {
-      oopDesc::bs()->compile_resolve_oop_for_write(_masm, obj, false, 0, 3, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+      oopDesc::bs()->interpreter_write_barrier(_masm, obj, false, 0, 3, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     }
     NOT_LP64( __ fstp_d(field);)
     LP64_ONLY( __ movdbl(field, xmm0);)
@@ -3261,11 +3261,11 @@
   // access field
   switch (bytecode()) {
   case Bytecodes::_fast_aputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     do_oop_store(_masm, field, rax, _bs->kind(), false);
     break;
   case Bytecodes::_fast_lputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
 #ifdef _LP64
   __ movq(field, rax);
 #else
@@ -3273,26 +3273,26 @@
 #endif
     break;
   case Bytecodes::_fast_iputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     __ movl(field, rax);
     break;
   case Bytecodes::_fast_bputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     __ movb(field, rax);
     break;
   case Bytecodes::_fast_sputfield:
     // fall through
   case Bytecodes::_fast_cputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_rax, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     __ movw(field, rax);
     break;
   case Bytecodes::_fast_fputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_ftos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     NOT_LP64( __ fstp_s(field); )
     LP64_ONLY( __ movflt(field, xmm0);)
     break;
   case Bytecodes::_fast_dputfield:
-    oopDesc::bs()->compile_resolve_oop_for_write(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
+    oopDesc::bs()->interpreter_write_barrier(_masm, rcx, false, 0, 4, BarrierSet::noreg, BarrierSet::ss_dtos, BarrierSet::ss_rbx, BarrierSet::ss_rdx);
     NOT_LP64( __ fstp_d(field); )
     LP64_ONLY( __ movdbl(field, xmm0);)
     break;
@@ -3351,7 +3351,7 @@
   // rax: object
   __ verify_oop(rax);
   __ null_check(rax);
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rax);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rax);
   Address field(rax, rbx, Address::times_1);
 
   // access field
@@ -3415,7 +3415,7 @@
   // next instruction)
   __ increment(rbcp);
   __ null_check(rax);
-  oopDesc::bs()->compile_resolve_oop_not_null(_masm, rax);
+  oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rax);
   const Address field = Address(rax, rbx, Address::times_1, 0*wordSize);
   switch (state) {
   case itos:
@@ -3971,7 +3971,7 @@
 void TemplateTable::arraylength() {
   transition(atos, itos);
   if (ShenandoahVerifyReadsToFromSpace) {
-    oopDesc::bs()->compile_resolve_oop(_masm, rax);
+    oopDesc::bs()->interpreter_read_barrier(_masm, rax);
   }
   __ null_check(rax, arrayOopDesc::length_offset_in_bytes());
   __ movl(rax, Address(rax, arrayOopDesc::length_offset_in_bytes()));
@@ -4176,7 +4176,7 @@
   // We need to preemptively evacuate the object, because we later compare
   // it to objects in the BasicObjectLock list, and we might get false negatives
   // if another thread evacuates the object in the meantime. See acmp.
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rax, false, 0, 0);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rax, false, 0, 0);
 
   const Address monitor_block_top(
         rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
@@ -4213,7 +4213,7 @@
     __ cmovptr(Assembler::equal, rmon, rtop);   // cmov => cmovptr
     // check if current entry is for same object
     __ movptr(rscratch1, Address(rtop, BasicObjectLock::obj_offset_in_bytes()));
-    oopDesc::bs()->compile_resolve_oop(_masm, rscratch1);
+    oopDesc::bs()->interpreter_read_barrier(_masm, rscratch1);
     __ cmpptr(rax, rscratch1);
     // if same object then stop searching
     __ jccb(Assembler::equal, exit);
@@ -4284,7 +4284,7 @@
   // We need to preemptively evacuate the object, because we later compare
   // it to objects in the BasicObjectLock list, and we might get false negatives
   // if another thread evacuates the object in the meantime. See acmp.
-  oopDesc::bs()->compile_resolve_oop_for_write(_masm, rax, false, 0, 0);
+  oopDesc::bs()->interpreter_write_barrier(_masm, rax, false, 0, 0);
 
   const Address monitor_block_top(
         rbp, frame::interpreter_frame_monitor_block_top_offset * wordSize);
@@ -4313,7 +4313,7 @@
     __ bind(loop);
     // check if current entry is for same object
     __ movptr(rscratch1, Address(rtop, BasicObjectLock::obj_offset_in_bytes()));
-    oopDesc::bs()->compile_resolve_oop(_masm, rscratch1);
+    oopDesc::bs()->interpreter_read_barrier(_masm, rscratch1);
     __ cmpptr(rax, rscratch1);
     // if same object then stop searching
     __ jcc(Assembler::equal, found);
--- a/src/share/vm/gc/shared/barrierSet.hpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/share/vm/gc/shared/barrierSet.hpp	Thu Aug 20 17:52:12 2015 +0200
@@ -243,17 +243,19 @@
     return src;
   }
 
-  virtual void compile_resolve_oop(MacroAssembler* masm, Register dst) {
+#ifndef CC_INTERP
+  virtual void interpreter_read_barrier(MacroAssembler* masm, Register dst) {
     // Default implementation does nothing.
   }
 
-  virtual void compile_resolve_oop_not_null(MacroAssembler* masm, Register dst) {
+  virtual void interpreter_read_barrier_not_null(MacroAssembler* masm, Register dst) {
     // Default implementation does nothing.
   }
 
-  virtual void compile_resolve_oop_for_write(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_save_state, ...) {
+  virtual void interpreter_write_barrier(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_save_state, ...) {
     // Default implementation does nothing.
   }
+#endif
 };
 
 template<typename T>
--- a/src/share/vm/gc/shenandoah/shenandoahBarrierSet.hpp	Thu Aug 20 12:10:37 2015 +0200
+++ b/src/share/vm/gc/shenandoah/shenandoahBarrierSet.hpp	Thu Aug 20 17:52:12 2015 +0200
@@ -164,10 +164,9 @@
 
 #ifndef CC_INTERP
 public:
-  // TODO: The following should really live in an X86 specific subclass.
-  virtual void compile_resolve_oop(MacroAssembler* masm, Register dst);
-  virtual void compile_resolve_oop_not_null(MacroAssembler* masm, Register dst);
-  void compile_resolve_oop_for_write(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_save_state, ...);
+  virtual void interpreter_read_barrier(MacroAssembler* masm, Register dst);
+  virtual void interpreter_read_barrier_not_null(MacroAssembler* masm, Register dst);
+  void interpreter_write_barrier(MacroAssembler* masm, Register dst, bool explicit_null_check, int stack_adjust, int num_save_state, ...);
 
 private:
   void compile_resolve_oop_runtime(MacroAssembler* masm, Register dst);