File revert-8174962-for-aarch64.patch of Package java-10-openjdk

Overview Repositories Revisions Requests Users Attributes Meta

File revert-8174962-for-aarch64.patch of Package java-10-openjdk (Revision 63ec3024741e0fd6a4f8a921cb0dc8d5)

Currently displaying revision 63ec3024741e0fd6a4f8a921cb0dc8d5 , Show latest

diff -r 6481320bb72c src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp
--- a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -774,7 +774,7 @@
     __ load_klass(rscratch1, receiver);
     __ ldr(tmp, Address(holder, CompiledICHolder::holder_klass_offset()));
     __ cmp(rscratch1, tmp);
-    __ ldr(rmethod, Address(holder, CompiledICHolder::holder_metadata_offset()));
+    __ ldr(rmethod, Address(holder, CompiledICHolder::holder_method_offset()));
     __ br(Assembler::EQ, ok);
     __ far_jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
 
diff -r 6481320bb72c src/hotspot/cpu/arm/macroAssembler_arm.cpp
--- a/src/hotspot/cpu/arm/macroAssembler_arm.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/arm/macroAssembler_arm.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -2475,65 +2475,49 @@
 // On success, the result will be in method_result, and execution falls through.
 // On failure, execution transfers to the given label.
 void MacroAssembler::lookup_interface_method(Register Rklass,
-                                             Register Rintf,
-                                             RegisterOrConstant itable_index,
+                                             Register Rinterf,
+                                             Register Rindex,
                                              Register method_result,
-                                             Register Rscan,
-                                             Register Rtmp,
+                                             Register temp_reg1,
+                                             Register temp_reg2,
                                              Label& L_no_such_interface) {
 
-  assert_different_registers(Rklass, Rintf, Rscan, Rtmp);
-
-  const int entry_size = itableOffsetEntry::size() * HeapWordSize;
-  assert(itableOffsetEntry::interface_offset_in_bytes() == 0, "not added for convenience");
+  assert_different_registers(Rklass, Rinterf, temp_reg1, temp_reg2, Rindex);
+
+  Register Ritable = temp_reg1;
 
   // Compute start of first itableOffsetEntry (which is at the end of the vtable)
   const int base = in_bytes(Klass::vtable_start_offset());
   const int scale = exact_log2(vtableEntry::size_in_bytes());
-  ldr_s32(Rtmp, Address(Rklass, Klass::vtable_length_offset())); // Get length of vtable
-  add(Rscan, Rklass, base);
-  add(Rscan, Rscan, AsmOperand(Rtmp, lsl, scale));
-
-  // Search through the itable for an interface equal to incoming Rintf
-  // itable looks like [intface][offset][intface][offset][intface][offset]
-
-  Label loop;
-  bind(loop);
-  ldr(Rtmp, Address(Rscan, entry_size, post_indexed));
-#ifdef AARCH64
-  Label found;
-  cmp(Rtmp, Rintf);
-  b(found, eq);
-  cbnz(Rtmp, loop);
-#else
-  cmp(Rtmp, Rintf);  // set ZF and CF if interface is found
-  cmn(Rtmp, 0, ne);  // check if tmp == 0 and clear CF if it is
-  b(loop, ne);
-#endif // AARCH64
-
-#ifdef AARCH64
-  b(L_no_such_interface);
-  bind(found);
-#else
-  // CF == 0 means we reached the end of itable without finding icklass
-  b(L_no_such_interface, cc);
-#endif // !AARCH64
-
-  if (method_result != noreg) {
-    // Interface found at previous position of Rscan, now load the method
-    ldr_s32(Rtmp, Address(Rscan, itableOffsetEntry::offset_offset_in_bytes() - entry_size));
-    if (itable_index.is_register()) {
-      add(Rtmp, Rtmp, Rklass); // Add offset to Klass*
-      assert(itableMethodEntry::size() * HeapWordSize == wordSize, "adjust the scaling in the code below");
-      assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust the offset in the code below");
-      ldr(method_result, Address::indexed_ptr(Rtmp, itable_index.as_register()));
-    } else {
-      int method_offset = itableMethodEntry::size() * HeapWordSize * itable_index.as_constant() +
-                          itableMethodEntry::method_offset_in_bytes();
-      add_slow(method_result, Rklass, method_offset);
-      ldr(method_result, Address(method_result, Rtmp));
-    }
-  }
+  ldr_s32(temp_reg2, Address(Rklass, Klass::vtable_length_offset())); // Get length of vtable
+  add(Ritable, Rklass, base);
+  add(Ritable, Ritable, AsmOperand(temp_reg2, lsl, scale));
+
+  Label entry, search;
+
+  b(entry);
+
+  bind(search);
+  add(Ritable, Ritable, itableOffsetEntry::size() * HeapWordSize);
+
+  bind(entry);
+
+  // Check that the entry is non-null.  A null entry means that the receiver
+  // class doesn't implement the interface, and wasn't the same as the
+  // receiver class checked when the interface was resolved.
+
+  ldr(temp_reg2, Address(Ritable, itableOffsetEntry::interface_offset_in_bytes()));
+  cbz(temp_reg2, L_no_such_interface);
+
+  cmp(Rinterf, temp_reg2);
+  b(search, ne);
+
+  ldr_s32(temp_reg2, Address(Ritable, itableOffsetEntry::offset_offset_in_bytes()));
+  add(temp_reg2, temp_reg2, Rklass); // Add offset to Klass*
+  assert(itableMethodEntry::size() * HeapWordSize == wordSize, "adjust the scaling in the code below");
+  assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust the offset in the code below");
+
+  ldr(method_result, Address::indexed_ptr(temp_reg2, Rindex));
 }
 
 #ifdef COMPILER2
diff -r 6481320bb72c src/hotspot/cpu/arm/macroAssembler_arm.hpp
--- a/src/hotspot/cpu/arm/macroAssembler_arm.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/arm/macroAssembler_arm.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -1316,7 +1316,7 @@
 
   void lookup_interface_method(Register recv_klass,
                                Register intf_klass,
-                               RegisterOrConstant itable_index,
+                               Register itable_index,
                                Register method_result,
                                Register temp_reg1,
                                Register temp_reg2,
diff -r 6481320bb72c src/hotspot/cpu/arm/sharedRuntime_arm.cpp
--- a/src/hotspot/cpu/arm/sharedRuntime_arm.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/arm/sharedRuntime_arm.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -984,7 +984,7 @@
 
   __ load_klass(receiver_klass, receiver);
   __ ldr(holder_klass, Address(Ricklass, CompiledICHolder::holder_klass_offset()));
-  __ ldr(Rmethod, Address(Ricklass, CompiledICHolder::holder_metadata_offset()));
+  __ ldr(Rmethod, Address(Ricklass, CompiledICHolder::holder_method_offset()));
   __ cmp(receiver_klass, holder_klass);
 
 #ifdef AARCH64
diff -r 6481320bb72c src/hotspot/cpu/arm/templateTable_arm.cpp
--- a/src/hotspot/cpu/arm/templateTable_arm.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/arm/templateTable_arm.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -4198,7 +4198,7 @@
   const Register Rflags  = R3_tmp;
   const Register Rklass  = R3_tmp;
 
-  prepare_invoke(byte_no, Rinterf, Rmethod, Rrecv, Rflags);
+  prepare_invoke(byte_no, Rinterf, Rindex, Rrecv, Rflags);
 
   // Special case of invokeinterface called for virtual method of
   // java.lang.Object.  See cpCacheOop.cpp for details.
@@ -4207,39 +4207,56 @@
   Label notMethod;
   __ tbz(Rflags, ConstantPoolCacheEntry::is_forced_virtual_shift, notMethod);
 
+  __ mov(Rmethod, Rindex);
   invokevirtual_helper(Rmethod, Rrecv, Rflags);
   __ bind(notMethod);
 
   // Get receiver klass into Rklass - also a null check
   __ load_klass(Rklass, Rrecv);
 
-  Label no_such_interface;
-
-  // Receiver subtype check against REFC.
-  __ lookup_interface_method(// inputs: rec. class, interface
-                             Rklass, Rinterf, noreg,
-                             // outputs:  scan temp. reg1, scan temp. reg2
-                             noreg, Ritable, Rtemp,
-                             no_such_interface);
-
   // profile this call
   __ profile_virtual_call(R0_tmp, Rklass);
 
-  // Get declaring interface class from method
-  __ ldr(Rtemp, Address(Rmethod, Method::const_offset()));
-  __ ldr(Rtemp, Address(Rtemp, ConstMethod::constants_offset()));
-  __ ldr(Rinterf, Address(Rtemp, ConstantPool::pool_holder_offset_in_bytes()));
-
-  // Get itable index from method
-  __ ldr_s32(Rtemp, Address(Rmethod, Method::itable_index_offset()));
-  __ add(Rtemp, Rtemp, (-Method::itable_index_max)); // small negative constant is too large for an immediate on arm32
-  __ neg(Rindex, Rtemp);
-
-  __ lookup_interface_method(// inputs: rec. class, interface
-                             Rklass, Rinterf, Rindex,
-                             // outputs:  scan temp. reg1, scan temp. reg2
-                             Rmethod, Ritable, Rtemp,
-                             no_such_interface);
+  // Compute start of first itableOffsetEntry (which is at the end of the vtable)
+  const int base = in_bytes(Klass::vtable_start_offset());
+  assert(vtableEntry::size() == 1, "adjust the scaling in the code below");
+  __ ldr_s32(Rtemp, Address(Rklass, Klass::vtable_length_offset())); // Get length of vtable
+  __ add(Ritable, Rklass, base);
+  __ add(Ritable, Ritable, AsmOperand(Rtemp, lsl, LogBytesPerWord));
+
+  Label entry, search, interface_ok;
+
+  __ b(entry);
+
+  __ bind(search);
+  __ add(Ritable, Ritable, itableOffsetEntry::size() * HeapWordSize);
+
+  __ bind(entry);
+
+  // Check that the entry is non-null.  A null entry means that the receiver
+  // class doesn't implement the interface, and wasn't the same as the
+  // receiver class checked when the interface was resolved.
+
+  __ ldr(Rtemp, Address(Ritable, itableOffsetEntry::interface_offset_in_bytes()));
+  __ cbnz(Rtemp, interface_ok);
+
+  // throw exception
+  __ call_VM(noreg, CAST_FROM_FN_PTR(address,
+                   InterpreterRuntime::throw_IncompatibleClassChangeError));
+
+  // the call_VM checks for exception, so we should never return here.
+  __ should_not_reach_here();
+
+  __ bind(interface_ok);
+
+  __ cmp(Rinterf, Rtemp);
+  __ b(search, ne);
+
+  __ ldr_s32(Rtemp, Address(Ritable, itableOffsetEntry::offset_offset_in_bytes()));
+  __ add(Rtemp, Rtemp, Rklass); // Add offset to Klass*
+  assert(itableMethodEntry::size() == 1, "adjust the scaling in the code below");
+
+  __ ldr(Rmethod, Address::indexed_ptr(Rtemp, Rindex));
 
   // Rmethod: Method* to call
 
@@ -4261,13 +4278,6 @@
 
   // do the call
   __ jump_from_interpreted(Rmethod);
-
-  // throw exception
-  __ bind(no_such_interface);
-  __ restore_method();
-  __ call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError));
-  // the call_VM checks for exception, so we should never return here.
-  __ should_not_reach_here();
 }
 
 void TemplateTable::invokehandle(int byte_no) {
diff -r 6481320bb72c src/hotspot/cpu/arm/vtableStubs_arm.cpp
--- a/src/hotspot/cpu/arm/vtableStubs_arm.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/arm/vtableStubs_arm.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -28,7 +28,6 @@
 #include "code/vtableStubs.hpp"
 #include "interp_masm_arm.hpp"
 #include "memory/resourceArea.hpp"
-#include "oops/compiledICHolder.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klassVtable.hpp"
 #include "runtime/sharedRuntime.hpp"
@@ -119,48 +118,67 @@
 
   // R0-R3 / R0-R7 registers hold the arguments and cannot be spoiled
   const Register Rclass  = AARCH64_ONLY(R9)  NOT_AARCH64(R4);
-  const Register Rintf   = AARCH64_ONLY(R10) NOT_AARCH64(R5);
+  const Register Rlength = AARCH64_ONLY(R10)  NOT_AARCH64(R5);
   const Register Rscan   = AARCH64_ONLY(R11) NOT_AARCH64(R6);
+  const Register tmp     = Rtemp;
 
-  assert_different_registers(Ricklass, Rclass, Rintf, Rscan, Rtemp);
+  assert_different_registers(Ricklass, Rclass, Rlength, Rscan, tmp);
 
   // Calculate the start of itable (itable goes after vtable)
   const int scale = exact_log2(vtableEntry::size_in_bytes());
   address npe_addr = __ pc();
   __ load_klass(Rclass, R0);
+  __ ldr_s32(Rlength, Address(Rclass, Klass::vtable_length_offset()));
 
-  Label L_no_such_interface;
+  __ add(Rscan, Rclass, in_bytes(Klass::vtable_start_offset()));
+  __ add(Rscan, Rscan, AsmOperand(Rlength, lsl, scale));
+
+  // Search through the itable for an interface equal to incoming Ricklass
+  // itable looks like [intface][offset][intface][offset][intface][offset]
+  const int entry_size = itableOffsetEntry::size() * HeapWordSize;
+  assert(itableOffsetEntry::interface_offset_in_bytes() == 0, "not added for convenience");
 
-  // Receiver subtype check against REFC.
-  __ ldr(Rintf, Address(Ricklass, CompiledICHolder::holder_klass_offset()));
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             Rclass, Rintf, noreg,
-                             // outputs: temp reg1, temp reg2
-                             noreg, Rscan, Rtemp,
-                             L_no_such_interface);
+  Label loop;
+  __ bind(loop);
+  __ ldr(tmp, Address(Rscan, entry_size, post_indexed));
+#ifdef AARCH64
+  Label found;
+  __ cmp(tmp, Ricklass);
+  __ b(found, eq);
+  __ cbnz(tmp, loop);
+#else
+  __ cmp(tmp, Ricklass);  // set ZF and CF if interface is found
+  __ cmn(tmp, 0, ne);     // check if tmp == 0 and clear CF if it is
+  __ b(loop, ne);
+#endif // AARCH64
 
-  // Get Method* and entry point for compiler
-  __ ldr(Rintf, Address(Ricklass, CompiledICHolder::holder_metadata_offset()));
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             Rclass, Rintf, itable_index,
-                             // outputs: temp reg1, temp reg2, temp reg3
-                             Rmethod, Rscan, Rtemp,
-                             L_no_such_interface);
+  assert(StubRoutines::throw_IncompatibleClassChangeError_entry() != NULL, "Check initialization order");
+#ifdef AARCH64
+  __ jump(StubRoutines::throw_IncompatibleClassChangeError_entry(), relocInfo::runtime_call_type, tmp);
+  __ bind(found);
+#else
+  // CF == 0 means we reached the end of itable without finding icklass
+  __ jump(StubRoutines::throw_IncompatibleClassChangeError_entry(), relocInfo::runtime_call_type, noreg, cc);
+#endif // !AARCH64
+
+  // Interface found at previous position of Rscan, now load the method oop
+  __ ldr_s32(tmp, Address(Rscan, itableOffsetEntry::offset_offset_in_bytes() - entry_size));
+  {
+    const int method_offset = itableMethodEntry::size() * HeapWordSize * itable_index +
+      itableMethodEntry::method_offset_in_bytes();
+    __ add_slow(Rmethod, Rclass, method_offset);
+  }
+  __ ldr(Rmethod, Address(Rmethod, tmp));
 
   address ame_addr = __ pc();
 
 #ifdef AARCH64
-  __ ldr(Rtemp, Address(Rmethod, Method::from_compiled_offset()));
-  __ br(Rtemp);
+  __ ldr(tmp, Address(Rmethod, Method::from_compiled_offset()));
+  __ br(tmp);
 #else
   __ ldr(PC, Address(Rmethod, Method::from_compiled_offset()));
 #endif // AARCH64
 
-  __ bind(L_no_such_interface);
-
-  assert(StubRoutines::throw_IncompatibleClassChangeError_entry() != NULL, "check initialization order");
-  __ jump(StubRoutines::throw_IncompatibleClassChangeError_entry(), relocInfo::runtime_call_type, Rtemp);
-
   masm->flush();
 
   if (PrintMiscellaneous && (WizardMode || Verbose)) {
@@ -187,7 +205,7 @@
     instr_count = NOT_AARCH64(4) AARCH64_ONLY(5);
   } else {
     // itable stub size
-    instr_count = NOT_AARCH64(31) AARCH64_ONLY(31);
+    instr_count = NOT_AARCH64(20) AARCH64_ONLY(20);
   }
 
 #ifdef AARCH64
diff -r 6481320bb72c src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp
--- a/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -1188,7 +1188,7 @@
   // Argument is valid and klass is as expected, continue.
 
   // Extract method from inline cache, verified entry point needs it.
-  __ ld(R19_method, CompiledICHolder::holder_metadata_offset(), ic);
+  __ ld(R19_method, CompiledICHolder::holder_method_offset(), ic);
   assert(R19_method == ic, "the inline cache register is dead here");
 
   __ ld(code, method_(code));
diff -r 6481320bb72c src/hotspot/cpu/s390/sharedRuntime_s390.cpp
--- a/src/hotspot/cpu/s390/sharedRuntime_s390.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/s390/sharedRuntime_s390.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -2660,9 +2660,9 @@
   Label skip_fixup;
   {
     Label ic_miss;
-    const int klass_offset           = oopDesc::klass_offset_in_bytes();
-    const int holder_klass_offset    = CompiledICHolder::holder_klass_offset();
-    const int holder_metadata_offset = CompiledICHolder::holder_metadata_offset();
+    const int klass_offset         = oopDesc::klass_offset_in_bytes();
+    const int holder_klass_offset  = CompiledICHolder::holder_klass_offset();
+    const int holder_method_offset = CompiledICHolder::holder_method_offset();
 
     // Out-of-line call to ic_miss handler.
     __ call_ic_miss_handler(ic_miss, 0x11, 0, Z_R1_scratch);
@@ -2691,7 +2691,7 @@
     // This def MUST MATCH code in gen_c2i_adapter!
     const Register code = Z_R11;
 
-    __ z_lg(Z_method, holder_metadata_offset, Z_method);
+    __ z_lg(Z_method, holder_method_offset, Z_method);
     __ load_and_test_long(Z_R0, method_(code));
     __ z_brne(ic_miss);  // Cache miss: call runtime to handle this.
 
diff -r 6481320bb72c src/hotspot/cpu/sparc/macroAssembler_sparc.cpp
--- a/src/hotspot/cpu/sparc/macroAssembler_sparc.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/sparc/macroAssembler_sparc.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -2058,10 +2058,9 @@
                                              Register method_result,
                                              Register scan_temp,
                                              Register sethi_temp,
-                                             Label& L_no_such_interface,
-                                             bool return_method) {
+                                             Label& L_no_such_interface) {
   assert_different_registers(recv_klass, intf_klass, method_result, scan_temp);
-  assert(!return_method || itable_index.is_constant() || itable_index.as_register() == method_result,
+  assert(itable_index.is_constant() || itable_index.as_register() == method_result,
          "caller must use same register for non-constant itable index as for method");
 
   Label L_no_such_interface_restore;
@@ -2093,13 +2092,11 @@
   add(scan_temp, itb_offset, scan_temp);
   add(recv_klass, scan_temp, scan_temp);
 
-  if (return_method) {
-    // Adjust recv_klass by scaled itable_index, so we can free itable_index.
-    RegisterOrConstant itable_offset = itable_index;
-    itable_offset = regcon_sll_ptr(itable_index, exact_log2(itableMethodEntry::size() * wordSize), itable_offset);
-    itable_offset = regcon_inc_ptr(itable_offset, itableMethodEntry::method_offset_in_bytes(), itable_offset);
-    add(recv_klass, ensure_simm13_or_reg(itable_offset, sethi_temp), recv_klass);
-  }
+  // Adjust recv_klass by scaled itable_index, so we can free itable_index.
+  RegisterOrConstant itable_offset = itable_index;
+  itable_offset = regcon_sll_ptr(itable_index, exact_log2(itableMethodEntry::size() * wordSize), itable_offset);
+  itable_offset = regcon_inc_ptr(itable_offset, itableMethodEntry::method_offset_in_bytes(), itable_offset);
+  add(recv_klass, ensure_simm13_or_reg(itable_offset, sethi_temp), recv_klass);
 
   // for (scan = klass->itable(); scan->interface() != NULL; scan += scan_step) {
   //   if (scan->interface() == intf) {
@@ -2134,14 +2131,12 @@
 
   bind(L_found_method);
 
-  if (return_method) {
-    // Got a hit.
-    int ito_offset = itableOffsetEntry::offset_offset_in_bytes();
-    // scan_temp[-scan_step] points to the vtable offset we need
-    ito_offset -= scan_step;
-    lduw(scan_temp, ito_offset, scan_temp);
-    ld_ptr(recv_klass, scan_temp, method_result);
-  }
+  // Got a hit.
+  int ito_offset = itableOffsetEntry::offset_offset_in_bytes();
+  // scan_temp[-scan_step] points to the vtable offset we need
+  ito_offset -= scan_step;
+  lduw(scan_temp, ito_offset, scan_temp);
+  ld_ptr(recv_klass, scan_temp, method_result);
 
   if (did_save) {
     Label L_done;
diff -r 6481320bb72c src/hotspot/cpu/sparc/macroAssembler_sparc.hpp
--- a/src/hotspot/cpu/sparc/macroAssembler_sparc.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/sparc/macroAssembler_sparc.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -1277,8 +1277,7 @@
                                RegisterOrConstant itable_index,
                                Register method_result,
                                Register temp_reg, Register temp2_reg,
-                               Label& no_such_interface,
-                               bool return_method = true);
+                               Label& no_such_interface);
 
   // virtual method calling
   void lookup_virtual_method(Register recv_klass,
diff -r 6481320bb72c src/hotspot/cpu/sparc/sharedRuntime_sparc.cpp
--- a/src/hotspot/cpu/sparc/sharedRuntime_sparc.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/sparc/sharedRuntime_sparc.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -904,7 +904,7 @@
 
     Label ok, ok2;
     __ brx(Assembler::equal, false, Assembler::pt, ok);
-    __ delayed()->ld_ptr(G5_method, CompiledICHolder::holder_metadata_offset(), G5_method);
+    __ delayed()->ld_ptr(G5_method, CompiledICHolder::holder_method_offset(), G5_method);
     __ jump_to(ic_miss, G3_scratch);
     __ delayed()->nop();
 
diff -r 6481320bb72c src/hotspot/cpu/sparc/templateTable_sparc.cpp
--- a/src/hotspot/cpu/sparc/templateTable_sparc.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/sparc/templateTable_sparc.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -3081,15 +3081,15 @@
   assert(byte_no == f1_byte, "use this argument");
 
   const Register Rinterface  = G1_scratch;
-  const Register Rmethod     = Lscratch;
   const Register Rret        = G3_scratch;
+  const Register Rindex      = Lscratch;
   const Register O0_recv     = O0;
   const Register O1_flags    = O1;
   const Register O2_Klass    = O2;
   const Register Rscratch    = G4_scratch;
   assert_different_registers(Rscratch, G5_method);
 
-  prepare_invoke(byte_no, Rinterface, Rret, Rmethod, O0_recv, O1_flags);
+  prepare_invoke(byte_no, Rinterface, Rret, Rindex, O0_recv, O1_flags);
 
   // get receiver klass
   __ null_check(O0_recv, oopDesc::klass_offset_in_bytes());
@@ -3109,40 +3109,55 @@
 
   __ bind(notMethod);
 
-  Register Rtemp = O1_flags;
-
-  Label L_no_such_interface;
-
-  // Receiver subtype check against REFC.
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             O2_Klass, Rinterface, noreg,
-                             // outputs: temp reg1, temp reg2, temp reg3
-                             G5_method, Rscratch, Rtemp,
-                             L_no_such_interface,
-                             /*return_method=*/false);
-
   __ profile_virtual_call(O2_Klass, O4);
 
   //
   // find entry point to call
   //
 
-  // Get declaring interface class from method
-  __ ld_ptr(Rmethod, Method::const_offset(), Rinterface);
-  __ ld_ptr(Rinterface, ConstMethod::constants_offset(), Rinterface);
-  __ ld_ptr(Rinterface, ConstantPool::pool_holder_offset_in_bytes(), Rinterface);
-
-  // Get itable index from method
-  const Register Rindex = G5_method;
-  __ ld(Rmethod, Method::itable_index_offset(), Rindex);
-  __ sub(Rindex, Method::itable_index_max, Rindex);
-  __ neg(Rindex);
-
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             O2_Klass, Rinterface, Rindex,
-                             // outputs: method, scan temp reg, temp reg
-                             G5_method, Rscratch, Rtemp,
-                             L_no_such_interface);
+  // compute start of first itableOffsetEntry (which is at end of vtable)
+  const int base = in_bytes(Klass::vtable_start_offset());
+  Label search;
+  Register Rtemp = O1_flags;
+
+  __ ld(O2_Klass, in_bytes(Klass::vtable_length_offset()), Rtemp);
+  __ sll(Rtemp, LogBytesPerWord, Rtemp);   // Rscratch *= 4;
+  if (Assembler::is_simm13(base)) {
+    __ add(Rtemp, base, Rtemp);
+  } else {
+    __ set(base, Rscratch);
+    __ add(Rscratch, Rtemp, Rtemp);
+  }
+  __ add(O2_Klass, Rtemp, Rscratch);
+
+  __ bind(search);
+
+  __ ld_ptr(Rscratch, itableOffsetEntry::interface_offset_in_bytes(), Rtemp);
+  {
+    Label ok;
+
+    // Check that entry is non-null.  Null entries are probably a bytecode
+    // problem.  If the interface isn't implemented by the receiver class,
+    // the VM should throw IncompatibleClassChangeError.  linkResolver checks
+    // this too but that's only if the entry isn't already resolved, so we
+    // need to check again.
+    __ br_notnull_short( Rtemp, Assembler::pt, ok);
+    call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError));
+    __ should_not_reach_here();
+    __ bind(ok);
+  }
+
+  __ cmp(Rinterface, Rtemp);
+  __ brx(Assembler::notEqual, true, Assembler::pn, search);
+  __ delayed()->add(Rscratch, itableOffsetEntry::size() * wordSize, Rscratch);
+
+  // entry found and Rscratch points to it
+  __ ld(Rscratch, itableOffsetEntry::offset_offset_in_bytes(), Rscratch);
+
+  assert(itableMethodEntry::method_offset_in_bytes() == 0, "adjust instruction below");
+  __ sll(Rindex, exact_log2(itableMethodEntry::size() * wordSize), Rindex);       // Rindex *= 8;
+  __ add(Rscratch, Rindex, Rscratch);
+  __ ld_ptr(O2_Klass, Rscratch, G5_method);
 
   // Check for abstract method error.
   {
@@ -3159,10 +3174,6 @@
   __ profile_arguments_type(G5_method, Rcall, Gargs, true);
   __ profile_called_method(G5_method, Rscratch);
   __ call_from_interpreter(Rcall, Gargs, Rret);
-
-  __ bind(L_no_such_interface);
-  call_VM(noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::throw_IncompatibleClassChangeError));
-  __ should_not_reach_here();
 }
 
 void TemplateTable::invokehandle(int byte_no) {
diff -r 6481320bb72c src/hotspot/cpu/sparc/vtableStubs_sparc.cpp
--- a/src/hotspot/cpu/sparc/vtableStubs_sparc.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/sparc/vtableStubs_sparc.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -27,7 +27,6 @@
 #include "code/vtableStubs.hpp"
 #include "interp_masm_sparc.hpp"
 #include "memory/resourceArea.hpp"
-#include "oops/compiledICHolder.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klassVtable.hpp"
 #include "runtime/sharedRuntime.hpp"
@@ -141,8 +140,7 @@
   MacroAssembler* masm = new MacroAssembler(&cb);
 
   Register G3_Klass = G3_scratch;
-  Register G5_icholder = G5;  // Passed in as an argument
-  Register G4_interface = G4_scratch;
+  Register G5_interface = G5;  // Passed in as an argument
   Label search;
 
   // Entry arguments:
@@ -166,26 +164,14 @@
   }
 #endif /* PRODUCT */
 
-  Label L_no_such_interface;
+  Label throw_icce;
 
   Register L5_method = L5;
-
-  // Receiver subtype check against REFC.
-  __ ld_ptr(G5_icholder, CompiledICHolder::holder_klass_offset(), G4_interface);
   __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             G3_Klass, G4_interface, itable_index,
-                             // outputs: scan temp. reg1, scan temp. reg2
-                             L5_method, L2, L3,
-                             L_no_such_interface,
-                             /*return_method=*/ false);
-
-  // Get Method* and entrypoint for compiler
-  __ ld_ptr(G5_icholder, CompiledICHolder::holder_metadata_offset(), G4_interface);
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             G3_Klass, G4_interface, itable_index,
+                             G3_Klass, G5_interface, itable_index,
                              // outputs: method, scan temp. reg
                              L5_method, L2, L3,
-                             L_no_such_interface);
+                             throw_icce);
 
 #ifndef PRODUCT
   if (DebugVtables) {
@@ -211,7 +197,7 @@
   __ JMP(G3_scratch, 0);
   __ delayed()->nop();
 
-  __ bind(L_no_such_interface);
+  __ bind(throw_icce);
   AddressLiteral icce(StubRoutines::throw_IncompatibleClassChangeError_entry());
   __ jump_to(icce, G3_scratch);
   __ delayed()->restore();
@@ -246,7 +232,7 @@
                           MacroAssembler::instr_size_for_decode_klass_not_null() : 0);
       return basic + slop;
     } else {
-      const int basic = 54 * BytesPerInstWord +
+      const int basic = 34 * BytesPerInstWord +
                         // shift;add for load_klass (only shift with zero heap based)
                         (UseCompressedClassPointers ?
                           MacroAssembler::instr_size_for_decode_klass_not_null() : 0);
diff -r 6481320bb72c src/hotspot/cpu/x86/macroAssembler_x86.cpp
--- a/src/hotspot/cpu/x86/macroAssembler_x86.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/macroAssembler_x86.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -5809,13 +5809,8 @@
                                              RegisterOrConstant itable_index,
                                              Register method_result,
                                              Register scan_temp,
-                                             Label& L_no_such_interface,
-                                             bool return_method) {
-  assert_different_registers(recv_klass, intf_klass, scan_temp);
-  assert_different_registers(method_result, intf_klass, scan_temp);
-  assert(recv_klass != method_result || !return_method,
-         "recv_klass can be destroyed when method isn't needed");
-
+                                             Label& L_no_such_interface) {
+  assert_different_registers(recv_klass, intf_klass, method_result, scan_temp);
   assert(itable_index.is_constant() || itable_index.as_register() == method_result,
          "caller must use same register for non-constant itable index as for method");
 
@@ -5832,11 +5827,9 @@
   // %%% Could store the aligned, prescaled offset in the klassoop.
   lea(scan_temp, Address(recv_klass, scan_temp, times_vte_scale, vtable_base));
 
-  if (return_method) {
-    // Adjust recv_klass by scaled itable_index, so we can free itable_index.
-    assert(itableMethodEntry::size() * wordSize == wordSize, "adjust the scaling in the code below");
-    lea(recv_klass, Address(recv_klass, itable_index, Address::times_ptr, itentry_off));
-  }
+  // Adjust recv_klass by scaled itable_index, so we can free itable_index.
+  assert(itableMethodEntry::size() * wordSize == wordSize, "adjust the scaling in the code below");
+  lea(recv_klass, Address(recv_klass, itable_index, Address::times_ptr, itentry_off));
 
   // for (scan = klass->itable(); scan->interface() != NULL; scan += scan_step) {
   //   if (scan->interface() == intf) {
@@ -5870,11 +5863,9 @@
 
   bind(found_method);
 
-  if (return_method) {
-    // Got a hit.
-    movl(scan_temp, Address(scan_temp, itableOffsetEntry::offset_offset_in_bytes()));
-    movptr(method_result, Address(recv_klass, scan_temp, Address::times_1));
-  }
+  // Got a hit.
+  movl(scan_temp, Address(scan_temp, itableOffsetEntry::offset_offset_in_bytes()));
+  movptr(method_result, Address(recv_klass, scan_temp, Address::times_1));
 }
 
 
diff -r 6481320bb72c src/hotspot/cpu/x86/macroAssembler_x86.hpp
--- a/src/hotspot/cpu/x86/macroAssembler_x86.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/macroAssembler_x86.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -544,8 +544,7 @@
                                RegisterOrConstant itable_index,
                                Register method_result,
                                Register scan_temp,
-                               Label& no_such_interface,
-                               bool return_method = true);
+                               Label& no_such_interface);
 
   // virtual method calling
   void lookup_virtual_method(Register recv_klass,
diff -r 6481320bb72c src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp
--- a/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -957,7 +957,7 @@
     Label missed;
     __ movptr(temp, Address(receiver, oopDesc::klass_offset_in_bytes()));
     __ cmpptr(temp, Address(holder, CompiledICHolder::holder_klass_offset()));
-    __ movptr(rbx, Address(holder, CompiledICHolder::holder_metadata_offset()));
+    __ movptr(rbx, Address(holder, CompiledICHolder::holder_method_offset()));
     __ jcc(Assembler::notEqual, missed);
     // Method might have been compiled since the call site was patched to
     // interpreted if that is the case treat it as a miss so we can get
diff -r 6481320bb72c src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp
--- a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -949,7 +949,7 @@
   {
     __ load_klass(temp, receiver);
     __ cmpptr(temp, Address(holder, CompiledICHolder::holder_klass_offset()));
-    __ movptr(rbx, Address(holder, CompiledICHolder::holder_metadata_offset()));
+    __ movptr(rbx, Address(holder, CompiledICHolder::holder_method_offset()));
     __ jcc(Assembler::equal, ok);
     __ jump(RuntimeAddress(SharedRuntime::get_ic_miss_stub()));
 
diff -r 6481320bb72c src/hotspot/cpu/x86/templateTable_x86.cpp
--- a/src/hotspot/cpu/x86/templateTable_x86.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/templateTable_x86.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -3712,11 +3712,11 @@
 void TemplateTable::invokeinterface(int byte_no) {
   transition(vtos, vtos);
   assert(byte_no == f1_byte, "use this argument");
-  prepare_invoke(byte_no, rax, rbx,  // get f1 Klass*, f2 Method*
+  prepare_invoke(byte_no, rax, rbx,  // get f1 Klass*, f2 itable index
                  rcx, rdx); // recv, flags
 
-  // rax: reference klass (from f1)
-  // rbx: method (from f2)
+  // rax: interface klass (from f1)
+  // rbx: itable index (from f2)
   // rcx: receiver
   // rdx: flags
 
@@ -3738,29 +3738,11 @@
   __ null_check(rcx, oopDesc::klass_offset_in_bytes());
   __ load_klass(rdx, rcx);
 
+  // profile this call
+  __ profile_virtual_call(rdx, rbcp, rlocals);
+
   Label no_such_interface, no_such_method;
 
-  // Receiver subtype check against REFC.
-  // Superklass in rax. Subklass in rdx. Blows rcx, rdi.
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             rdx, rax, noreg,
-                             // outputs: scan temp. reg, scan temp. reg
-                             rbcp, rlocals,
-                             no_such_interface,
-                             /*return_method=*/false);
-
-  // profile this call
-  __ restore_bcp(); // rbcp was destroyed by receiver type check
-  __ profile_virtual_call(rdx, rbcp, rlocals);
-
-  // Get declaring interface class from method, and itable index
-  __ movptr(rax, Address(rbx, Method::const_offset()));
-  __ movptr(rax, Address(rax, ConstMethod::constants_offset()));
-  __ movptr(rax, Address(rax, ConstantPool::pool_holder_offset_in_bytes()));
-  __ movl(rbx, Address(rbx, Method::itable_index_offset()));
-  __ subl(rbx, Method::itable_index_max);
-  __ negl(rbx);
-
   __ lookup_interface_method(// inputs: rec. class, interface, itable index
                              rdx, rax, rbx,
                              // outputs: method, scan temp. reg
diff -r 6481320bb72c src/hotspot/cpu/x86/vtableStubs_x86_32.cpp
--- a/src/hotspot/cpu/x86/vtableStubs_x86_32.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/vtableStubs_x86_32.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -27,7 +27,6 @@
 #include "code/vtableStubs.hpp"
 #include "interp_masm_x86.hpp"
 #include "memory/resourceArea.hpp"
-#include "oops/compiledICHolder.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klassVtable.hpp"
 #include "runtime/sharedRuntime.hpp"
@@ -148,7 +147,7 @@
   MacroAssembler* masm = new MacroAssembler(&cb);
 
   // Entry arguments:
-  //  rax: CompiledICHolder
+  //  rax,: Interface
   //  rcx: Receiver
 
 #ifndef PRODUCT
@@ -156,42 +155,25 @@
     __ incrementl(ExternalAddress((address) SharedRuntime::nof_megamorphic_calls_addr()));
   }
 #endif /* PRODUCT */
+  // get receiver (need to skip return address on top of stack)
 
-  // Most registers are in use; we'll use rax, rbx, rsi, rdi
-  // (If we need to make rsi, rdi callee-save, do a push/pop here.)
-  const Register recv_klass_reg     = rsi;
-  const Register holder_klass_reg   = rax; // declaring interface klass (DECC)
-  const Register resolved_klass_reg = rbx; // resolved interface klass (REFC)
-  const Register temp_reg           = rdi;
-
-  const Register icholder_reg = rax;
-  __ movptr(resolved_klass_reg, Address(icholder_reg, CompiledICHolder::holder_klass_offset()));
-  __ movptr(holder_klass_reg,   Address(icholder_reg, CompiledICHolder::holder_metadata_offset()));
-
-  Label L_no_such_interface;
+  assert(VtableStub::receiver_location() == rcx->as_VMReg(), "receiver expected in rcx");
 
   // get receiver klass (also an implicit null-check)
   address npe_addr = __ pc();
-  assert(VtableStub::receiver_location() ==  rcx->as_VMReg(), "receiver expected in  rcx");
-  __ load_klass(recv_klass_reg, rcx);
+  __ movptr(rsi, Address(rcx, oopDesc::klass_offset_in_bytes()));
+
+  // Most registers are in use; we'll use rax, rbx, rsi, rdi
+  // (If we need to make rsi, rdi callee-save, do a push/pop here.)
+  const Register method = rbx;
+  Label throw_icce;
 
-  // Receiver subtype check against REFC.
-  // Destroys recv_klass_reg value.
-  __ lookup_interface_method(// inputs: rec. class, interface
-                             recv_klass_reg, resolved_klass_reg, noreg,
-                             // outputs:  scan temp. reg1, scan temp. reg2
-                             recv_klass_reg, temp_reg,
-                             L_no_such_interface,
-                             /*return_method=*/false);
-
-  // Get selected method from declaring class and itable index
-  const Register method = rbx;
-  __ load_klass(recv_klass_reg, rcx); // restore recv_klass_reg
+  // Get Method* and entrypoint for compiler
   __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                             recv_klass_reg, holder_klass_reg, itable_index,
+                             rsi, rax, itable_index,
                              // outputs: method, scan temp. reg
-                             method, temp_reg,
-                             L_no_such_interface);
+                             method, rdi,
+                             throw_icce);
 
   // method (rbx): Method*
   // rcx: receiver
@@ -211,10 +193,9 @@
   address ame_addr = __ pc();
   __ jmp(Address(method, Method::from_compiled_offset()));
 
-  __ bind(L_no_such_interface);
+  __ bind(throw_icce);
   __ jump(RuntimeAddress(StubRoutines::throw_IncompatibleClassChangeError_entry()));
-
-  __ flush();
+  masm->flush();
 
   if (PrintMiscellaneous && (WizardMode || Verbose)) {
     tty->print_cr("itable #%d at " PTR_FORMAT "[%d] left over: %d",
@@ -239,7 +220,7 @@
     return (DebugVtables ? 210 : 16) + (CountCompiledCalls ? 6 : 0);
   } else {
     // Itable stub size
-    return (DebugVtables ? 256 : 110) + (CountCompiledCalls ? 6 : 0);
+    return (DebugVtables ? 256 : 66) + (CountCompiledCalls ? 6 : 0);
   }
   // In order to tune these parameters, run the JVM with VM options
   // +PrintMiscellaneous and +WizardMode to see information about
diff -r 6481320bb72c src/hotspot/cpu/x86/vtableStubs_x86_64.cpp
--- a/src/hotspot/cpu/x86/vtableStubs_x86_64.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/cpu/x86/vtableStubs_x86_64.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -27,7 +27,6 @@
 #include "code/vtableStubs.hpp"
 #include "interp_masm_x86.hpp"
 #include "memory/resourceArea.hpp"
-#include "oops/compiledICHolder.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/klassVtable.hpp"
 #include "runtime/sharedRuntime.hpp"
@@ -148,50 +147,36 @@
 #endif
 
   // Entry arguments:
-  //  rax: CompiledICHolder
+  //  rax: Interface
   //  j_rarg0: Receiver
 
+  // Free registers (non-args) are rax (interface), rbx
+
+  // get receiver (need to skip return address on top of stack)
+
+  assert(VtableStub::receiver_location() == j_rarg0->as_VMReg(), "receiver expected in j_rarg0");
+  // get receiver klass (also an implicit null-check)
+  address npe_addr = __ pc();
+
   // Most registers are in use; we'll use rax, rbx, r10, r11
   // (various calling sequences use r[cd]x, r[sd]i, r[89]; stay away from them)
-  const Register recv_klass_reg     = r10;
-  const Register holder_klass_reg   = rax; // declaring interface klass (DECC)
-  const Register resolved_klass_reg = rbx; // resolved interface klass (REFC)
-  const Register temp_reg           = r11;
-
-  Label L_no_such_interface;
-
-  const Register icholder_reg = rax;
-  __ movptr(resolved_klass_reg, Address(icholder_reg, CompiledICHolder::holder_klass_offset()));
-  __ movptr(holder_klass_reg,   Address(icholder_reg, CompiledICHolder::holder_metadata_offset()));
-
-  // get receiver klass (also an implicit null-check)
-  assert(VtableStub::receiver_location() == j_rarg0->as_VMReg(), "receiver expected in j_rarg0");
-  address npe_addr = __ pc();
-  __ load_klass(recv_klass_reg, j_rarg0);
-
-  // Receiver subtype check against REFC.
-  // Destroys recv_klass_reg value.
-  __ lookup_interface_method(// inputs: rec. class, interface
-                             recv_klass_reg, resolved_klass_reg, noreg,
-                             // outputs:  scan temp. reg1, scan temp. reg2
-                             recv_klass_reg, temp_reg,
-                             L_no_such_interface,
-                             /*return_method=*/false);
-
-  // Get selected method from declaring class and itable index
-  const Register method = rbx;
-  __ load_klass(recv_klass_reg, j_rarg0);   // restore recv_klass_reg
-  __ lookup_interface_method(// inputs: rec. class, interface, itable index
-                       recv_klass_reg, holder_klass_reg, itable_index,
-                       // outputs: method, scan temp. reg
-                       method, temp_reg,
-                       L_no_such_interface);
+  __ load_klass(r10, j_rarg0);
 
   // If we take a trap while this arg is on the stack we will not
   // be able to walk the stack properly. This is not an issue except
   // when there are mistakes in this assembly code that could generate
   // a spurious fault. Ask me how I know...
 
+  const Register method = rbx;
+  Label throw_icce;
+
+  // Get Method* and entrypoint for compiler
+  __ lookup_interface_method(// inputs: rec. class, interface, itable index
+                             r10, rax, itable_index,
+                             // outputs: method, scan temp. reg
+                             method, r11,
+                             throw_icce);
+
   // method (rbx): Method*
   // j_rarg0: receiver
 
@@ -212,7 +197,7 @@
   address ame_addr = __ pc();
   __ jmp(Address(method, Method::from_compiled_offset()));
 
-  __ bind(L_no_such_interface);
+  __ bind(throw_icce);
   __ jump(RuntimeAddress(StubRoutines::throw_IncompatibleClassChangeError_entry()));
 
   __ flush();
@@ -239,8 +224,8 @@
            (UseCompressedClassPointers ?  MacroAssembler::instr_size_for_decode_klass_not_null() : 0);
   } else {
     // Itable stub size
-    return (DebugVtables ? 512 : 140) + (CountCompiledCalls ? 13 : 0) +
-           (UseCompressedClassPointers ? 2 * MacroAssembler::instr_size_for_decode_klass_not_null() : 0);
+    return (DebugVtables ? 512 : 74) + (CountCompiledCalls ? 13 : 0) +
+           (UseCompressedClassPointers ?  MacroAssembler::instr_size_for_decode_klass_not_null() : 0);
   }
   // In order to tune these parameters, run the JVM with VM options
   // +PrintMiscellaneous and +WizardMode to see information about
diff -r 6481320bb72c src/hotspot/share/aot/aotCompiledMethod.cpp
--- a/src/hotspot/share/aot/aotCompiledMethod.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/aot/aotCompiledMethod.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -270,7 +270,7 @@
         CompiledIC *ic = CompiledIC_at(&iter);
         if (ic->is_icholder_call()) {
           CompiledICHolder* cichk = ic->cached_icholder();
-          f(cichk->holder_metadata());
+          f(cichk->holder_method());
           f(cichk->holder_klass());
         } else {
           // Get Klass* or NULL (if value is -1) from GOT cell of virtual call PLT stub.
diff -r 6481320bb72c src/hotspot/share/code/compiledIC.cpp
--- a/src/hotspot/share/code/compiledIC.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/code/compiledIC.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -230,13 +230,10 @@
 #ifdef ASSERT
     int index = call_info->resolved_method()->itable_index();
     assert(index == itable_index, "CallInfo pre-computes this");
+#endif //ASSERT
     InstanceKlass* k = call_info->resolved_method()->method_holder();
     assert(k->verify_itable_index(itable_index), "sanity check");
-#endif //ASSERT
-    CompiledICHolder* holder = new CompiledICHolder(call_info->resolved_method()->method_holder(),
-                                                    call_info->resolved_klass());
-    holder->claim();
-    InlineCacheBuffer::create_transition_stub(this, holder, entry);
+    InlineCacheBuffer::create_transition_stub(this, k, entry);
   } else {
     assert(call_info->call_kind() == CallInfo::vtable_call, "either itable or vtable");
     // Can be different than selected_method->vtable_index(), due to package-private etc.
@@ -520,14 +517,7 @@
 
 bool CompiledIC::is_icholder_entry(address entry) {
   CodeBlob* cb = CodeCache::find_blob_unsafe(entry);
-  if (cb != NULL && cb->is_adapter_blob()) {
-    return true;
-  }
-  // itable stubs also use CompiledICHolder
-  if (VtableStubs::is_entry_point(entry) && VtableStubs::stub_containing(entry)->is_itable_stub()) {
-    return true;
-  }
-  return false;
+  return (cb != NULL && cb->is_adapter_blob());
 }
 
 bool CompiledIC::is_icholder_call_site(virtual_call_Relocation* call_site, const CompiledMethod* cm) {
diff -r 6481320bb72c src/hotspot/share/code/compiledIC.hpp
--- a/src/hotspot/share/code/compiledIC.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/code/compiledIC.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -45,11 +45,11 @@
 //          \                        /   \     /
 //       [4] \                      / [4] \->-/
 //            \->-  Megamorphic -<-/
-//              (CompiledICHolder*)
+//                  (Method*)
 //
-// The text in parentheses () refers to the value of the inline cache receiver (mov instruction)
+// The text in paranteses () refere to the value of the inline cache receiver (mov instruction)
 //
-// The numbers in square brackets refer to the kind of transition:
+// The numbers in square brackets refere to the kind of transition:
 // [1]: Initial fixup. Receiver it found from debug information
 // [2]: Compilation of a method
 // [3]: Recompilation of a method (note: only entry is changed. The Klass* must stay the same)
diff -r 6481320bb72c src/hotspot/share/code/compiledMethod.cpp
--- a/src/hotspot/share/code/compiledMethod.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/code/compiledMethod.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -404,7 +404,8 @@
     // yet be marked below. (We check this further below).
     CompiledICHolder* cichk_oop = ic->cached_icholder();
 
-    if (cichk_oop->is_loader_alive(is_alive)) {
+    if (cichk_oop->holder_method()->method_holder()->is_loader_alive(is_alive) &&
+        cichk_oop->holder_klass()->is_loader_alive(is_alive)) {
       return;
     }
   } else {
diff -r 6481320bb72c src/hotspot/share/code/nmethod.cpp
--- a/src/hotspot/share/code/nmethod.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/code/nmethod.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -1545,7 +1545,7 @@
         CompiledIC *ic = CompiledIC_at(&iter);
         if (ic->is_icholder_call()) {
           CompiledICHolder* cichk = ic->cached_icholder();
-          f(cichk->holder_metadata());
+          f(cichk->holder_method());
           f(cichk->holder_klass());
         } else {
           Metadata* ic_oop = ic->cached_metadata();
diff -r 6481320bb72c src/hotspot/share/interpreter/interpreterRuntime.cpp
--- a/src/hotspot/share/interpreter/interpreterRuntime.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/interpreter/interpreterRuntime.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -822,7 +822,6 @@
   case CallInfo::itable_call:
     cp_cache_entry->set_itable_call(
       bytecode,
-      info.resolved_klass(),
       info.resolved_method(),
       info.itable_index());
     break;
diff -r 6481320bb72c src/hotspot/share/oops/compiledICHolder.cpp
--- a/src/hotspot/share/oops/compiledICHolder.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/compiledICHolder.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -32,8 +32,8 @@
 volatile int CompiledICHolder::_live_not_claimed_count;
 
 
-CompiledICHolder::CompiledICHolder(Metadata* metadata, Klass* klass)
-  : _holder_metadata(metadata), _holder_klass(klass) {
+CompiledICHolder::CompiledICHolder(Method* method, Klass* klass)
+  : _holder_method(method), _holder_klass(klass) {
 #ifdef ASSERT
   Atomic::inc(&_live_count);
   Atomic::inc(&_live_not_claimed_count);
@@ -47,28 +47,12 @@
 }
 #endif // ASSERT
 
-bool CompiledICHolder::is_loader_alive(BoolObjectClosure* is_alive) {
-  if (_holder_metadata->is_method()) {
-    if (!((Method*)_holder_metadata)->method_holder()->is_loader_alive(is_alive)) {
-      return false;
-    }
-  } else if (_holder_metadata->is_klass()) {
-    if (!((Klass*)_holder_metadata)->is_loader_alive(is_alive)) {
-      return false;
-    }
-  }
-  if (!_holder_klass->is_loader_alive(is_alive)) {
-    return false;
-  }
-  return true;
-}
-
 // Printing
 
 void CompiledICHolder::print_on(outputStream* st) const {
   st->print("%s", internal_name());
-  st->print(" - metadata: "); holder_metadata()->print_value_on(st); st->cr();
-  st->print(" - klass:    "); holder_klass()->print_value_on(st); st->cr();
+  st->print(" - method: "); holder_method()->print_value_on(st); st->cr();
+  st->print(" - klass:  "); holder_klass()->print_value_on(st); st->cr();
 }
 
 void CompiledICHolder::print_value_on(outputStream* st) const {
@@ -79,7 +63,7 @@
 // Verification
 
 void CompiledICHolder::verify_on(outputStream* st) {
-  guarantee(holder_metadata()->is_method() || holder_metadata()->is_klass(), "should be method or klass");
+  guarantee(holder_method()->is_method(), "should be method");
   guarantee(holder_klass()->is_klass(),   "should be klass");
 }
 
diff -r 6481320bb72c src/hotspot/share/oops/compiledICHolder.hpp
--- a/src/hotspot/share/oops/compiledICHolder.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/compiledICHolder.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -29,9 +29,8 @@
 #include "utilities/macros.hpp"
 
 // A CompiledICHolder* is a helper object for the inline cache implementation.
-// It holds:
-//   (1) (method+klass pair) when converting from compiled to an interpreted call
-//   (2) (klass+klass pair) when calling itable stub from megamorphic compiled call
+// It holds an intermediate value (method+klass pair) used when converting from
+// compiled to an interpreted call.
 //
 // These are always allocated in the C heap and are freed during a
 // safepoint by the ICBuffer logic.  It's unsafe to free them earlier
@@ -46,33 +45,32 @@
   static volatile int _live_not_claimed_count; // allocated but not yet in use so not
                                                // reachable by iterating over nmethods
 
-  Metadata* _holder_metadata;
+  Method* _holder_method;
   Klass*    _holder_klass;    // to avoid name conflict with oopDesc::_klass
   CompiledICHolder* _next;
 
  public:
   // Constructor
-  CompiledICHolder(Metadata* metadata, Klass* klass);
+  CompiledICHolder(Method* method, Klass* klass);
   ~CompiledICHolder() NOT_DEBUG_RETURN;
 
   static int live_count() { return _live_count; }
   static int live_not_claimed_count() { return _live_not_claimed_count; }
 
   // accessors
+  Method* holder_method() const     { return _holder_method; }
   Klass*    holder_klass()  const     { return _holder_klass; }
-  Metadata* holder_metadata() const   { return _holder_metadata; }
 
-  void set_holder_metadata(Metadata* m) { _holder_metadata = m; }
-  void set_holder_klass(Klass* k)     { _holder_klass = k; }
+  void set_holder_method(Method* m) { _holder_method = m; }
+  void set_holder_klass(Klass* k)   { _holder_klass = k; }
 
-  static int holder_metadata_offset() { return offset_of(CompiledICHolder, _holder_metadata); }
+  // interpreter support (offsets in bytes)
+  static int holder_method_offset()   { return offset_of(CompiledICHolder, _holder_method); }
   static int holder_klass_offset()    { return offset_of(CompiledICHolder, _holder_klass); }
 
   CompiledICHolder* next()     { return _next; }
   void set_next(CompiledICHolder* n) { _next = n; }
 
-  bool is_loader_alive(BoolObjectClosure* is_alive);
-
   // Verify
   void verify_on(outputStream* st);
 
diff -r 6481320bb72c src/hotspot/share/oops/cpCache.cpp
--- a/src/hotspot/share/oops/cpCache.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/cpCache.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -277,16 +277,14 @@
   set_direct_or_vtable_call(invoke_code, method, index, false);
 }
 
-void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code,
-                                             Klass* referenced_klass,
-                                             const methodHandle& method, int index) {
+void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, const methodHandle& method, int index) {
   assert(method->method_holder()->verify_itable_index(index), "");
   assert(invoke_code == Bytecodes::_invokeinterface, "");
   InstanceKlass* interf = method->method_holder();
   assert(interf->is_interface(), "must be an interface");
   assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
-  set_f1(referenced_klass);
-  set_f2((intx)method());
+  set_f1(interf);
+  set_f2(index);
   set_method_flags(as_TosState(method->result_type()),
                    0,  // no option bits
                    method()->size_of_parameters());
@@ -515,23 +513,10 @@
 
 
 #if INCLUDE_JVMTI
-
-void log_adjust(const char* entry_type, Method* old_method, Method* new_method, bool* trace_name_printed) {
-  if (log_is_enabled(Info, redefine, class, update)) {
-    ResourceMark rm;
-    if (!(*trace_name_printed)) {
-      log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
-      *trace_name_printed = true;
-    }
-    log_debug(redefine, class, update, constantpool)
-          ("cpc %s entry update: %s(%s)", entry_type, new_method->name()->as_C_string(), new_method->signature()->as_C_string());
-  }
-}
-
 // RedefineClasses() API support:
 // If this ConstantPoolCacheEntry refers to old_method then update it
 // to refer to new_method.
-void ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
+bool ConstantPoolCacheEntry::adjust_method_entry(Method* old_method,
        Method* new_method, bool * trace_name_printed) {
 
   if (is_vfinal()) {
@@ -540,35 +525,63 @@
       // match old_method so need an update
       // NOTE: can't use set_f2_as_vfinal_method as it asserts on different values
       _f2 = (intptr_t)new_method;
-      log_adjust("vfinal", old_method, new_method, trace_name_printed);
+      if (log_is_enabled(Info, redefine, class, update)) {
+        ResourceMark rm;
+        if (!(*trace_name_printed)) {
+          log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
+          *trace_name_printed = true;
+        }
+        log_debug(redefine, class, update, constantpool)
+          ("cpc vf-entry update: %s(%s)", new_method->name()->as_C_string(), new_method->signature()->as_C_string());
+      }
+      return true;
     }
-    return;
+
+    // f1() is not used with virtual entries so bail out
+    return false;
   }
 
-  assert (_f1 != NULL, "should not call with uninteresting entry");
+  if (_f1 == NULL) {
+    // NULL f1() means this is a virtual entry so bail out
+    // We are assuming that the vtable index does not need change.
+    return false;
+  }
 
-  if (!(_f1->is_method())) {
-    // _f1 is a Klass* for an interface, _f2 is the method
-    if (f2_as_interface_method() == old_method) {
-      _f2 = (intptr_t)new_method;
-      log_adjust("interface", old_method, new_method, trace_name_printed);
+  if (_f1 == old_method) {
+    _f1 = new_method;
+    if (log_is_enabled(Info, redefine, class, update)) {
+      ResourceMark rm;
+      if (!(*trace_name_printed)) {
+        log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());
+        *trace_name_printed = true;
+      }
+      log_debug(redefine, class, update, constantpool)
+        ("cpc entry update: %s(%s)", new_method->name()->as_C_string(), new_method->signature()->as_C_string());
     }
-  } else if (_f1 == old_method) {
-    _f1 = new_method;
-    log_adjust("special, static or dynamic", old_method, new_method, trace_name_printed);
+    return true;
   }
+
+  return false;
 }
 
 // a constant pool cache entry should never contain old or obsolete methods
 bool ConstantPoolCacheEntry::check_no_old_or_obsolete_entries() {
-  Method* m = get_interesting_method_entry(NULL);
-  // return false if m refers to a non-deleted old or obsolete method
-  if (m != NULL) {
-    assert(m->is_valid() && m->is_method(), "m is a valid method");
-    return !m->is_old() && !m->is_obsolete(); // old is always set for old and obsolete
-  } else {
+  if (is_vfinal()) {
+    // virtual and final so _f2 contains method ptr instead of vtable index
+    Metadata* f2 = (Metadata*)_f2;
+    // Return false if _f2 refers to an old or an obsolete method.
+    // _f2 == NULL || !_f2->is_method() are just as unexpected here.
+    return (f2 != NULL NOT_PRODUCT(&& f2->is_valid()) && f2->is_method() &&
+            !((Method*)f2)->is_old() && !((Method*)f2)->is_obsolete());
+  } else if (_f1 == NULL ||
+             (NOT_PRODUCT(_f1->is_valid() &&) !_f1->is_method())) {
+    // _f1 == NULL || !_f1->is_method() are OK here
     return true;
   }
+  // return false if _f1 refers to a non-deleted old or obsolete method
+  return (NOT_PRODUCT(_f1->is_valid() &&) _f1->is_method() &&
+          (f1_as_method()->is_deleted() ||
+          (!f1_as_method()->is_old() && !f1_as_method()->is_obsolete())));
 }
 
 Method* ConstantPoolCacheEntry::get_interesting_method_entry(Klass* k) {
@@ -585,11 +598,10 @@
     return NULL;
   } else {
     if (!(_f1->is_method())) {
-      // _f1 is a Klass* for an interface
-      m = f2_as_interface_method();
-    } else {
-      m = f1_as_method();
+      // _f1 can also contain a Klass* for an interface
+      return NULL;
     }
+    m = f1_as_method();
   }
   assert(m != NULL && m->is_method(), "sanity check");
   if (m == NULL || !m->is_method() || (k != NULL && m->method_holder() != k)) {
diff -r 6481320bb72c src/hotspot/share/oops/cpCache.hpp
--- a/src/hotspot/share/oops/cpCache.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/cpCache.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -249,7 +249,6 @@
 
   void set_itable_call(
     Bytecodes::Code invoke_code,                 // the bytecode used; must be invokeinterface
-    Klass* referenced_klass,                     // the referenced klass in the InterfaceMethodref
     const methodHandle& method,                  // the resolved interface method
     int itable_index                             // index into itable for the method
   );
@@ -353,7 +352,6 @@
   bool      is_f1_null() const                   { Metadata* f1 = f1_ord(); return f1 == NULL; }  // classifies a CPC entry as unbound
   int       f2_as_index() const                  { assert(!is_vfinal(), ""); return (int) _f2; }
   Method*   f2_as_vfinal_method() const          { assert(is_vfinal(), ""); return (Method*)_f2; }
-  Method*   f2_as_interface_method() const       { assert(bytecode_1() == Bytecodes::_invokeinterface, ""); return (Method*)_f2; }
   intx flags_ord() const                         { return (intx)OrderAccess::load_acquire(&_flags); }
   int  field_index() const                       { assert(is_field_entry(),  ""); return (_flags & field_index_mask); }
   int  parameter_size() const                    { assert(is_method_entry(), ""); return (_flags & parameter_size_mask); }
@@ -389,7 +387,7 @@
   // trace_name_printed is set to true if the current call has
   // printed the klass name so that other routines in the adjust_*
   // group don't print the klass name.
-  void adjust_method_entry(Method* old_method, Method* new_method,
+  bool adjust_method_entry(Method* old_method, Method* new_method,
          bool* trace_name_printed);
   bool check_no_old_or_obsolete_entries();
   Method* get_interesting_method_entry(Klass* k);
diff -r 6481320bb72c src/hotspot/share/oops/klassVtable.cpp
--- a/src/hotspot/share/oops/klassVtable.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/klassVtable.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -1185,6 +1185,7 @@
   Array<Method*>* methods = InstanceKlass::cast(interf)->methods();
   int nof_methods = methods->length();
   HandleMark hm;
+  assert(nof_methods > 0, "at least one method must exist for interface to be in vtable");
   Handle interface_loader (THREAD, InstanceKlass::cast(interf)->class_loader());
 
   int ime_count = method_count_for_interface(interf);
@@ -1353,10 +1354,8 @@
       }
     }
 
-    // Visit all interfaces which either have any methods or can participate in receiver type check.
-    // We do not bother to count methods in transitive interfaces, although that would allow us to skip
-    // this step in the rare case of a zero-method interface extending another zero-method interface.
-    if (method_count > 0 || InstanceKlass::cast(intf)->transitive_interfaces()->length() > 0) {
+    // Only count interfaces with at least one method
+    if (method_count > 0) {
       blk->doit(intf, method_count);
     }
   }
diff -r 6481320bb72c src/hotspot/share/oops/method.hpp
--- a/src/hotspot/share/oops/method.hpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/oops/method.hpp	Thu Jan 18 17:37:01 2018 +0100
@@ -698,7 +698,6 @@
   static ByteSize from_interpreted_offset()      { return byte_offset_of(Method, _from_interpreted_entry ); }
   static ByteSize interpreter_entry_offset()     { return byte_offset_of(Method, _i2i_entry ); }
   static ByteSize signature_handler_offset()     { return in_ByteSize(sizeof(Method) + wordSize);      }
-  static ByteSize itable_index_offset()          { return byte_offset_of(Method, _vtable_index ); }
 
   // for code generation
   static int method_data_offset_in_bytes()       { return offset_of(Method, _method_data); }
diff -r 6481320bb72c src/hotspot/share/runtime/vmStructs.cpp
--- a/src/hotspot/share/runtime/vmStructs.cpp	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/hotspot/share/runtime/vmStructs.cpp	Thu Jan 18 17:37:01 2018 +0100
@@ -233,7 +233,7 @@
   nonstatic_field(ArrayKlass,                  _dimension,                                    int)                                   \
   volatile_nonstatic_field(ArrayKlass,         _higher_dimension,                             Klass*)                                \
   volatile_nonstatic_field(ArrayKlass,         _lower_dimension,                              Klass*)                                \
-  nonstatic_field(CompiledICHolder,            _holder_metadata,                              Metadata*)                               \
+  nonstatic_field(CompiledICHolder,            _holder_method,                                Method*)                               \
   nonstatic_field(CompiledICHolder,            _holder_klass,                                 Klass*)                                \
   nonstatic_field(ConstantPool,                _tags,                                         Array<u1>*)                            \
   nonstatic_field(ConstantPool,                _cache,                                        ConstantPoolCache*)                    \
diff -r 6481320bb72c src/java.base/share/classes/java/lang/invoke/DirectMethodHandle.java
--- a/src/java.base/share/classes/java/lang/invoke/DirectMethodHandle.java	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/java.base/share/classes/java/lang/invoke/DirectMethodHandle.java	Thu Jan 18 17:37:01 2018 +0100
@@ -80,20 +80,13 @@
             mtype = mtype.insertParameterTypes(0, receiver);
         }
         if (!member.isField()) {
-            switch (refKind) {
-                case REF_invokeSpecial: {
-                    member = member.asSpecial();
-                    LambdaForm lform = preparedLambdaForm(member);
-                    return new Special(mtype, lform, member);
-                }
-                case REF_invokeInterface: {
-                    LambdaForm lform = preparedLambdaForm(member);
-                    return new Interface(mtype, lform, member, receiver);
-                }
-                default: {
-                    LambdaForm lform = preparedLambdaForm(member);
-                    return new DirectMethodHandle(mtype, lform, member);
-                }
+            if (refKind == REF_invokeSpecial) {
+                member = member.asSpecial();
+                LambdaForm lform = preparedLambdaForm(member);
+                return new Special(mtype, lform, member);
+            } else {
+                LambdaForm lform = preparedLambdaForm(member);
+                return new DirectMethodHandle(mtype, lform, member);
             }
         } else {
             LambdaForm lform = preparedFieldLambdaForm(member);
@@ -197,7 +190,6 @@
     static LambdaForm makePreparedLambdaForm(MethodType mtype, int which) {
         boolean needsInit = (which == LF_INVSTATIC_INIT);
         boolean doesAlloc = (which == LF_NEWINVSPECIAL);
-        boolean needsReceiverCheck = (which == LF_INVINTERFACE);
         String linkerName;
         LambdaForm.Kind kind;
         switch (which) {
@@ -227,7 +219,6 @@
         int nameCursor = ARG_LIMIT;
         final int NEW_OBJ     = (doesAlloc ? nameCursor++ : -1);
         final int GET_MEMBER  = nameCursor++;
-        final int CHECK_RECEIVER = (needsReceiverCheck ? nameCursor++ : -1);
         final int LINKER_CALL = nameCursor++;
         Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
         assert(names.length == nameCursor);
@@ -242,10 +233,6 @@
         }
         assert(findDirectMethodHandle(names[GET_MEMBER]) == names[DMH_THIS]);
         Object[] outArgs = Arrays.copyOfRange(names, ARG_BASE, GET_MEMBER+1, Object[].class);
-        if (needsReceiverCheck) {
-            names[CHECK_RECEIVER] = new Name(getFunction(NF_checkReceiver), names[DMH_THIS], names[ARG_BASE]);
-            outArgs[0] = names[CHECK_RECEIVER];
-        }
         assert(outArgs[outArgs.length-1] == names[GET_MEMBER]);  // look, shifted args!
         int result = LAST_RESULT;
         if (doesAlloc) {
@@ -389,29 +376,6 @@
         }
     }
 
-    /** This subclass represents invokeinterface instructions. */
-    static class Interface extends DirectMethodHandle {
-        private final Class<?> refc;
-        private Interface(MethodType mtype, LambdaForm form, MemberName member, Class<?> refc) {
-            super(mtype, form, member);
-            assert refc.isInterface() : refc;
-            this.refc = refc;
-        }
-        @Override
-        MethodHandle copyWith(MethodType mt, LambdaForm lf) {
-            return new Interface(mt, lf, member, refc);
-        }
-
-        Object checkReceiver(Object recv) {
-            if (!refc.isInstance(recv)) {
-                String msg = String.format("Class %s does not implement the requested interface %s",
-                        recv.getClass().getName(), refc.getName());
-                throw new IncompatibleClassChangeError(msg);
-            }
-            return recv;
-        }
-    }
-
     /** This subclass handles constructor references. */
     static class Constructor extends DirectMethodHandle {
         final MemberName initMethod;
@@ -774,8 +738,7 @@
             NF_allocateInstance = 8,
             NF_constructorMethod = 9,
             NF_UNSAFE = 10,
-            NF_checkReceiver = 11,
-            NF_LIMIT = 12;
+            NF_LIMIT = 11;
 
     private static final @Stable NamedFunction[] NFS = new NamedFunction[NF_LIMIT];
 
@@ -822,11 +785,6 @@
                     return new NamedFunction(
                             MemberName.getFactory()
                                     .resolveOrFail(REF_getField, member, DirectMethodHandle.class, NoSuchMethodException.class));
-                case NF_checkReceiver:
-                    member = new MemberName(Interface.class, "checkReceiver", OBJ_OBJ_TYPE, REF_invokeVirtual);
-                    return new NamedFunction(
-                        MemberName.getFactory()
-                            .resolveOrFail(REF_invokeVirtual, member, Interface.class, NoSuchMethodException.class));
                 default:
                     throw newInternalError("Unknown function: " + func);
             }
diff -r 6481320bb72c src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CompiledICHolder.java
--- a/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CompiledICHolder.java	Thu Jan 18 16:20:16 2018 +0000
+++ b/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/oops/CompiledICHolder.java	Thu Jan 18 17:37:01 2018 +0100
@@ -40,10 +40,10 @@
   }
 
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
-    Type type      = db.lookupType("CompiledICHolder");
-    holderMetadata = new MetadataField(type.getAddressField("_holder_metadata"), 0);
-    holderKlass    = new MetadataField(type.getAddressField("_holder_klass"), 0);
-    headerSize     = type.getSize();
+    Type type    = db.lookupType("CompiledICHolder");
+    holderMethod = new MetadataField(type.getAddressField("_holder_method"), 0);
+    holderKlass  = new MetadataField(type.getAddressField("_holder_klass"), 0);
+    headerSize   = type.getSize();
   }
 
   public CompiledICHolder(Address addr) {
@@ -55,12 +55,12 @@
   private static long headerSize;
 
   // Fields
-  private static MetadataField holderMetadata;
+  private static MetadataField holderMethod;
   private static MetadataField holderKlass;
 
   // Accessors for declared fields
-  public Metadata getHolderMetadata() { return (Metadata) holderMetadata.getValue(this); }
-  public Klass    getHolderKlass()    { return (Klass)    holderKlass.getValue(this); }
+  public Method getHolderMethod() { return (Method) holderMethod.getValue(this); }
+  public Klass  getHolderKlass()  { return (Klass)  holderKlass.getValue(this); }
 
   public void printValueOn(PrintStream tty) {
     tty.print("CompiledICHolder");
diff -r 6481320bb72c test/hotspot/jtreg/runtime/SharedArchiveFile/serviceability/transformRelatedClasses/TransformTestCommon.java
--- a/test/hotspot/jtreg/runtime/SharedArchiveFile/serviceability/transformRelatedClasses/TransformTestCommon.java	Thu Jan 18 16:20:16 2018 +0000
+++ b/test/hotspot/jtreg/runtime/SharedArchiveFile/serviceability/transformRelatedClasses/TransformTestCommon.java	Thu Jan 18 17:37:01 2018 +0100
@@ -63,8 +63,8 @@
                                             String parent, String child)
         throws Exception {
 
-        String parentSharedMatch = " " + parent + " source: shared objects file";
-        String childSharedMatch =  " " + child +  " source: shared objects file";
+        String parentSharedMatch = parent + " source: shared objects file";
+        String childSharedMatch =  child +  " source: shared objects file";
 
         if (entry.isParentExpectedShared)
             out.shouldContain(parentSharedMatch);

Places

File revert-8174962-for-aarch64.patch of Package java-10-openjdk (Revision 63ec3024741e0fd6a4f8a921cb0dc8d5)

Places