changeset 464:851ca5831589

meth: fix to intrinsic compilation; assembler tweaks for debugging; backtrace filtering
author jrose
date Tue, 10 Jul 2012 01:42:34 -0700
parents a1bae6849a0b
children 93e8421c14a6
files meth-lazy-7023639.patch
diffstat 1 files changed, 594 insertions(+), 50 deletions(-) [+]
line wrap: on
line diff
--- a/meth-lazy-7023639.patch	Sun Jul 08 02:23:40 2012 -0700
+++ b/meth-lazy-7023639.patch	Tue Jul 10 01:42:34 2012 -0700
@@ -7,7 +7,54 @@
 diff --git a/src/cpu/sparc/vm/assembler_sparc.cpp b/src/cpu/sparc/vm/assembler_sparc.cpp
 --- a/src/cpu/sparc/vm/assembler_sparc.cpp
 +++ b/src/cpu/sparc/vm/assembler_sparc.cpp
-@@ -2998,26 +2998,60 @@
+@@ -44,8 +44,10 @@
+ 
+ #ifdef PRODUCT
+ #define BLOCK_COMMENT(str) /* nothing */
++#define STOP(error) stop(error)
+ #else
+ #define BLOCK_COMMENT(str) block_comment(str)
++#define STOP(error) block_comment(error); stop(error)
+ #endif
+ 
+ // Convert the raw encoding form into the form expected by the
+@@ -992,7 +994,7 @@
+   save_frame(0);                // to avoid clobbering O0
+   ld_ptr(pc_addr, L0);
+   br_null_short(L0, Assembler::pt, PcOk);
+-  stop("last_Java_pc not zeroed before leaving Java");
++  STOP("last_Java_pc not zeroed before leaving Java");
+   bind(PcOk);
+ 
+   // Verify that flags was zeroed on return to Java
+@@ -1001,7 +1003,7 @@
+   tst(L0);
+   br(Assembler::zero, false, Assembler::pt, FlagsOk);
+   delayed() -> restore();
+-  stop("flags not zeroed before leaving Java");
++  STOP("flags not zeroed before leaving Java");
+   bind(FlagsOk);
+ #endif /* ASSERT */
+   //
+@@ -1021,7 +1023,7 @@
+   andcc(last_java_sp, 0x01, G0);
+   br(Assembler::notZero, false, Assembler::pt, StackOk);
+   delayed()->nop();
+-  stop("Stack Not Biased in set_last_Java_frame");
++  STOP("Stack Not Biased in set_last_Java_frame");
+   bind(StackOk);
+ #endif // ASSERT
+   assert( last_java_sp != G4_scratch, "bad register usage in set_last_Java_frame");
+@@ -2020,7 +2022,7 @@
+   char* b = new char[1024];
+   sprintf(b, "untested: %s", what);
+ 
+-  if ( ShowMessageBoxOnError )   stop(b);
++  if ( ShowMessageBoxOnError )   STOP(b);
+   else                           warn(b);
+ }
+ 
+@@ -2998,26 +3000,60 @@
  }
  
  
@@ -74,7 +121,7 @@
    restore();
    ba_short(L_success);
  
-@@ -3234,54 +3268,6 @@
+@@ -3234,54 +3270,6 @@
  }
  
  
@@ -129,6 +176,67 @@
  RegisterOrConstant MacroAssembler::argument_offset(RegisterOrConstant arg_slot,
                                                     Register temp_reg,
                                                     int extra_slot_offset) {
+@@ -3914,7 +3902,7 @@
+     ld_ptr(G2_thread, in_bytes(JavaThread::tlab_start_offset()), t2);
+     or3(t1, t2, t3);
+     cmp_and_br_short(t1, t2, Assembler::greaterEqual, Assembler::pn, next);
+-    stop("assert(top >= start)");
++    STOP("assert(top >= start)");
+     should_not_reach_here();
+ 
+     bind(next);
+@@ -3922,13 +3910,13 @@
+     ld_ptr(G2_thread, in_bytes(JavaThread::tlab_end_offset()), t2);
+     or3(t3, t2, t3);
+     cmp_and_br_short(t1, t2, Assembler::lessEqual, Assembler::pn, next2);
+-    stop("assert(top <= end)");
++    STOP("assert(top <= end)");
+     should_not_reach_here();
+ 
+     bind(next2);
+     and3(t3, MinObjAlignmentInBytesMask, t3);
+     cmp_and_br_short(t3, 0, Assembler::lessEqual, Assembler::pn, ok);
+-    stop("assert(aligned)");
++    STOP("assert(aligned)");
+     should_not_reach_here();
+ 
+     bind(ok);
+@@ -3976,7 +3964,7 @@
+       btst(MinObjAlignmentInBytesMask, obj);
+       br(Assembler::zero, false, Assembler::pt, L);
+       delayed()->nop();
+-      stop("eden top is not properly aligned");
++      STOP("eden top is not properly aligned");
+       bind(L);
+     }
+ #endif // ASSERT
+@@ -4013,7 +4001,7 @@
+       btst(MinObjAlignmentInBytesMask, top_addr);
+       br(Assembler::zero, false, Assembler::pt, L);
+       delayed()->nop();
+-      stop("eden top is not properly aligned");
++      STOP("eden top is not properly aligned");
+       bind(L);
+     }
+ #endif // ASSERT
+@@ -4066,7 +4054,7 @@
+     btst(MinObjAlignmentInBytesMask, free);
+     br(Assembler::zero, false, Assembler::pt, L);
+     delayed()->nop();
+-    stop("updated TLAB free is not properly aligned");
++    STOP("updated TLAB free is not properly aligned");
+     bind(L);
+   }
+ #endif // ASSERT
+@@ -4164,7 +4152,7 @@
+     ld_ptr(G2_thread, in_bytes(JavaThread::tlab_size_offset()), t2);
+     sll_ptr(t2, LogHeapWordSize, t2);
+     cmp_and_br_short(t1, t2, Assembler::equal, Assembler::pt, ok);
+-    stop("assert(t1 == tlab_size)");
++    STOP("assert(t1 == tlab_size)");
+     should_not_reach_here();
+ 
+     bind(ok);
 diff --git a/src/cpu/sparc/vm/assembler_sparc.hpp b/src/cpu/sparc/vm/assembler_sparc.hpp
 --- a/src/cpu/sparc/vm/assembler_sparc.hpp
 +++ b/src/cpu/sparc/vm/assembler_sparc.hpp
@@ -752,7 +860,7 @@
    Label L_ok, L_bad;
    BLOCK_COMMENT("verify_klass {");
    __ verify_oop(obj_reg);
-@@ -498,538 +91,405 @@
+@@ -498,538 +91,413 @@
    __ set(ExternalAddress(klass_addr), temp2_reg);
    __ ld_ptr(Address(temp2_reg, 0), temp2_reg);
    __ cmp_and_brx_short(temp_reg, temp2_reg, Assembler::equal, Assembler::pt, L_ok);
@@ -767,6 +875,7 @@
 +
 +void MethodHandles::verify_ref_kind(MacroAssembler* _masm, int ref_kind, Register member_reg, Register temp) {
 +  Label L;
++  BLOCK_COMMENT("verify_ref_kind {");
 +  __ lduw(Address(member_reg, NONZERO(java_lang_invoke_MemberName::flags_offset_in_bytes())), temp);
 +  __ srl( temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT, temp);
 +  __ and3(temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK,  temp);
@@ -779,6 +888,7 @@
 +      trace_method_handle(_masm, buf);
 +    __ STOP(buf);
 +  }
++  BLOCK_COMMENT("} verify_ref_kind");
 +  __ bind(L);
 +}
 +
@@ -837,6 +947,7 @@
 +  //NOT_PRODUCT({ FlagSetting fs(TraceMethodHandles, true); trace_method_handle(_masm, "LZMH"); });
 +
 +  // Load the invoker, as MH -> MH.form -> LF.vmentry
++  __ verify_oop(recv);
 +  __ load_heap_oop(Address(recv,        NONZERO(java_lang_invoke_MethodHandle::form_offset_in_bytes())),       method_temp);
 +  __ verify_oop(method_temp);
 +  __ load_heap_oop(Address(method_temp, NONZERO(java_lang_invoke_LambdaForm::vmentry_offset_in_bytes())), method_temp);
@@ -1064,7 +1175,7 @@
 +  Register temp3 = G3_scratch;
 +  Register temp4 = (for_compiler_entry ? noreg      : O2);
 +  if (for_compiler_entry) {
-+    assert(receiver_reg == O0, "only valid assignment");
++    assert(receiver_reg == (iid == vmIntrinsics::_linkToStatic ? noreg : O0), "only valid assignment");
 +    assert_different_registers(member_reg, O0, O1, O2, O3, O4, O5);
 +    assert_different_registers(temp1,      O0, O1, O2, O3, O4, O5);
 +    assert_different_registers(temp2,      O0, O1, O2, O3, O4, O5);
@@ -1107,10 +1218,8 @@
 +
 +    Register temp1_recv_klass = temp1;
 +    if (iid != vmIntrinsics::_linkToStatic) {
-+      BLOCK_COMMENT("check_receiver {");
-+      // The receiver for the MemberName must be in receiver_reg.
 +      __ verify_oop(receiver_reg);
-+      if (iid == vmIntrinsics::_linkToSpecial && !VerifyMethodHandles) {
++      if (iid == vmIntrinsics::_linkToSpecial) {
 +        // Don't actually load the klass; just null-check the receiver.
 +        __ null_check(receiver_reg);
 +      } else {
@@ -1119,7 +1228,14 @@
 +        __ load_klass(receiver_reg, temp1_recv_klass);
 +        __ verify_oop(temp1_recv_klass);
 +      }
++      BLOCK_COMMENT("check_receiver {");
++      // The receiver for the MemberName must be in receiver_reg.
 +      // Check the receiver against the MemberName.clazz
++      if (VerifyMethodHandles && iid == vmIntrinsics::_linkToSpecial) {
++        // Did not load it above...
++        __ load_klass(receiver_reg, temp1_recv_klass);
++        __ verify_oop(temp1_recv_klass);
++      }
 +      if (VerifyMethodHandles && iid != vmIntrinsics::_linkToInterface) {
 +        Label L_ok;
 +        Register temp2_defc = temp2;
@@ -1633,7 +1749,7 @@
  
    if (Verbose) {
      // dumping last frame with frame::describe
-@@ -1090,6 +550,7 @@
+@@ -1090,6 +558,7 @@
  
      // mark saved_sp, if seems valid (may not be valid for some adapters)
      intptr_t *unbiased_sp = (intptr_t *)(STACK_BIAS+(uintptr_t)saved_sp);
@@ -1641,7 +1757,7 @@
      if ((unbiased_sp >= dump_sp - UNREASONABLE_STACK_MOVE) && (unbiased_sp < dump_fp)) {
        values.describe(-1, unbiased_sp, "*saved_sp+STACK_BIAS");
      }
-@@ -1097,10 +558,13 @@
+@@ -1097,10 +566,13 @@
      // Note: the unextended_sp may not be correct
      tty->print_cr("  stack layout:");
      values.print(p);
@@ -1659,7 +1775,7 @@
    }
  }
  
-@@ -1143,1260 +607,3 @@
+@@ -1143,1260 +615,3 @@
    BLOCK_COMMENT("} trace_method_handle");
  }
  #endif // PRODUCT
@@ -3132,16 +3248,41 @@
 diff --git a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
 --- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
 +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
-@@ -1937,20 +1937,131 @@
+@@ -1937,20 +1937,156 @@
    __ bind(done);
  }
  
++static void verify_oop_args(MacroAssembler* masm,
++                            int total_args_passed,
++                            const BasicType* sig_bt,
++                            const VMRegPair* regs) {
++  Register temp_reg = G5_method;  // not part of any compiled calling seq
++  if (VerifyOops) {
++    for (int i = 0; i < total_args_passed; i++) {
++      if (sig_bt[i] == T_OBJECT ||
++          sig_bt[i] == T_ARRAY) {
++        VMReg r = regs[i].first();
++        assert(r->is_valid(), "bad oop arg");
++        if (r->is_stack()) {
++          RegisterOrConstant ld_off = reg2offset(r) + STACK_BIAS;
++          ld_off = __ ensure_simm13_or_reg(ld_off, temp_reg);
++          __ ld_ptr(SP, ld_off, temp_reg);
++          __ verify_oop(temp_reg);
++        } else {
++          __ verify_oop(r->as_Register());
++        }
++      }
++    }
++  }
++}
++
 +static void gen_special_dispatch(MacroAssembler* masm,
 +                                 int total_args_passed,
 +                                 int comp_args_on_stack,
 +                                 vmIntrinsics::ID special_dispatch,
 +                                 const BasicType* sig_bt,
 +                                 const VMRegPair* regs) {
++  verify_oop_args(masm, total_args_passed, sig_bt, regs);
 +
 +  // Now write the args into the outgoing interpreter space
 +  bool     has_receiver   = false;
@@ -3942,7 +4083,31 @@
 diff --git a/src/cpu/x86/vm/assembler_x86.cpp b/src/cpu/x86/vm/assembler_x86.cpp
 --- a/src/cpu/x86/vm/assembler_x86.cpp
 +++ b/src/cpu/x86/vm/assembler_x86.cpp
-@@ -5492,14 +5492,34 @@
+@@ -41,6 +41,15 @@
+ #include "gc_implementation/g1/heapRegion.hpp"
+ #endif
+ 
++#ifdef PRODUCT
++#define BLOCK_COMMENT(str) /* nothing */
++#define STOP(error) stop(error)
++#else
++#define BLOCK_COMMENT(str) block_comment(str)
++#define STOP(error) block_comment(error); stop(error)
++#endif
++
++#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
+ // Implementation of AddressLiteral
+ 
+ AddressLiteral::AddressLiteral(address target, relocInfo::relocType rtype) {
+@@ -5484,6 +5493,7 @@
+     // This is the value of eip which points to where verify_oop will return.
+     if (os::message_box(msg, "Execution stopped, print registers?")) {
+       ttyLocker ttyl;
++      FlagSetting fs(Debugging, true);
+       tty->print_cr("eip = 0x%08x", eip);
+ #ifndef PRODUCT
+       if ((WizardMode || Verbose) && PrintMiscellaneous) {
+@@ -5492,14 +5502,35 @@
          tty->cr();
        }
  #endif
@@ -3982,10 +4147,27 @@
 +      Disassembler::decode((address)eip-64, (address)eip);
 +      tty->print_cr("--------");
 +      Disassembler::decode((address)eip, (address)eip+32);
++      Debugging = false;
        BREAKPOINT;
        assert(false, "start up GDB");
      }
-@@ -6035,23 +6055,45 @@
+@@ -6014,7 +6045,7 @@
+ 
+ void MacroAssembler::debug64(char* msg, int64_t pc, int64_t regs[]) {
+   // In order to get locks to work, we need to fake a in_VM state
+-  if (ShowMessageBoxOnError ) {
++  if (ShowMessageBoxOnError) {
+     JavaThread* thread = JavaThread::current();
+     JavaThreadState saved_state = thread->thread_state();
+     thread->set_thread_state(_thread_in_vm);
+@@ -6029,29 +6060,53 @@
+     // This is the value of eip which points to where verify_oop will return.
+     if (os::message_box(msg, "Execution stopped, print registers?")) {
+       ttyLocker ttyl;
++      FlagSetting fs(Debugging, true);
+       tty->print_cr("rip = 0x%016lx", pc);
+ #ifndef PRODUCT
+       tty->cr();
        findpc(pc);
        tty->cr();
  #endif
@@ -4042,12 +4224,49 @@
 +      Disassembler::decode((address)pc-64, (address)pc);
 +      tty->print_cr("--------");
 +      Disassembler::decode((address)pc, (address)pc+32);
++      Debugging = false;
        BREAKPOINT;
 +      assert(false, "start up GDB");
      }
      ThreadStateTransition::transition(thread, _thread_in_vm, saved_state);
    } else {
-@@ -8684,6 +8726,19 @@
+@@ -6431,7 +6486,7 @@
+       get_thread(rax);
+       cmpptr(java_thread, rax);
+       jcc(Assembler::equal, L);
+-      stop("MacroAssembler::call_VM_base: rdi not callee saved?");
++      STOP("MacroAssembler::call_VM_base: rdi not callee saved?");
+       bind(L);
+     }
+     pop(rax);
+@@ -7171,7 +7226,7 @@
+       jcc(Assembler::notZero, integer);
+       cmpl(tmp3, 0x80000000);
+       jcc(Assembler::notZero, integer);
+-      stop("integer indefinite value shouldn't be seen here");
++      STOP("integer indefinite value shouldn't be seen here");
+       bind(integer);
+     }
+ #else
+@@ -7181,7 +7236,7 @@
+       shlq(tmp3, 1);
+       jcc(Assembler::carryClear, integer);
+       jcc(Assembler::notZero, integer);
+-      stop("integer indefinite value shouldn't be seen here");
++      STOP("integer indefinite value shouldn't be seen here");
+       bind(integer);
+     }
+ #endif
+@@ -8345,7 +8400,7 @@
+     shlptr(tsize, LogHeapWordSize);
+     cmpptr(t1, tsize);
+     jcc(Assembler::equal, ok);
+-    stop("assert(t1 != tlab size)");
++    STOP("assert(t1 != tlab size)");
+     should_not_reach_here();
+ 
+     bind(ok);
+@@ -8684,6 +8739,19 @@
  }
  
  
@@ -4067,7 +4286,32 @@
  void MacroAssembler::check_klass_subtype(Register sub_klass,
                             Register super_klass,
                             Register temp_reg,
-@@ -8983,60 +9038,6 @@
+@@ -8933,6 +9001,7 @@
+   // Pass register number to verify_oop_subroutine
+   char* b = new char[strlen(s) + 50];
+   sprintf(b, "verify_oop: %s: %s", reg->name(), s);
++  BLOCK_COMMENT("verify_oop {");
+ #ifdef _LP64
+   push(rscratch1);                    // save r10, trashed by movptr()
+ #endif
+@@ -8947,6 +9016,7 @@
+   movptr(rax, ExternalAddress(StubRoutines::verify_oop_subroutine_entry_address()));
+   call(rax);
+   // Caller pops the arguments (oop, message) and restores rax, r10
++  BLOCK_COMMENT("} verify_oop");
+ }
+ 
+ 
+@@ -8967,7 +9037,7 @@
+       jcc(Assembler::notZero, L);
+       char* buf = new char[40];
+       sprintf(buf, "DelayedValue="INTPTR_FORMAT, delayed_value_addr[1]);
+-      stop(buf);
++      STOP(buf);
+     } else {
+       jccb(Assembler::notZero, L);
+       hlt();
+@@ -8983,60 +9053,6 @@
  }
  
  
@@ -4128,7 +4372,24 @@
  Address MacroAssembler::argument_address(RegisterOrConstant arg_slot,
                                           int extra_slot_offset) {
    // cf. TemplateTable::prepare_invoke(), if (load_receiver).
-@@ -9549,6 +9550,25 @@
+@@ -9109,14 +9125,14 @@
+     movptr(t1, Address(thread_reg, in_bytes(JavaThread::tlab_top_offset())));
+     cmpptr(t1, Address(thread_reg, in_bytes(JavaThread::tlab_start_offset())));
+     jcc(Assembler::aboveEqual, next);
+-    stop("assert(top >= start)");
++    STOP("assert(top >= start)");
+     should_not_reach_here();
+ 
+     bind(next);
+     movptr(t1, Address(thread_reg, in_bytes(JavaThread::tlab_end_offset())));
+     cmpptr(t1, Address(thread_reg, in_bytes(JavaThread::tlab_top_offset())));
+     jcc(Assembler::aboveEqual, ok);
+-    stop("assert(top <= end)");
++    STOP("assert(top <= end)");
+     should_not_reach_here();
+ 
+     bind(ok);
+@@ -9549,6 +9565,25 @@
      movptr(dst, src);
  }
  
@@ -4154,6 +4415,56 @@
  // Used for storing NULLs.
  void MacroAssembler::store_heap_oop_null(Address dst) {
  #ifdef _LP64
+@@ -9579,7 +9614,7 @@
+     push(rscratch1); // cmpptr trashes rscratch1
+     cmpptr(r12_heapbase, ExternalAddress((address)Universe::narrow_oop_base_addr()));
+     jcc(Assembler::equal, ok);
+-    stop(msg);
++    STOP(msg);
+     bind(ok);
+     pop(rscratch1);
+   }
+@@ -9612,7 +9647,7 @@
+     Label ok;
+     testq(r, r);
+     jcc(Assembler::notEqual, ok);
+-    stop("null oop passed to encode_heap_oop_not_null");
++    STOP("null oop passed to encode_heap_oop_not_null");
+     bind(ok);
+   }
+ #endif
+@@ -9633,7 +9668,7 @@
+     Label ok;
+     testq(src, src);
+     jcc(Assembler::notEqual, ok);
+-    stop("null oop passed to encode_heap_oop_not_null2");
++    STOP("null oop passed to encode_heap_oop_not_null2");
+     bind(ok);
+   }
+ #endif
+@@ -9824,7 +9859,7 @@
+     cmpptr(rax, StackAlignmentInBytes-wordSize);
+     pop(rax);
+     jcc(Assembler::equal, L);
+-    stop("Stack is not properly aligned!");
++    STOP("Stack is not properly aligned!");
+     bind(L);
+   }
+ #endif
+@@ -10498,13 +10533,6 @@
+   bind(DONE);
+ }
+ 
+-#ifdef PRODUCT
+-#define BLOCK_COMMENT(str) /* nothing */
+-#else
+-#define BLOCK_COMMENT(str) block_comment(str)
+-#endif
+-
+-#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
+ void MacroAssembler::generate_fill(BasicType t, bool aligned,
+                                    Register to, Register value, Register count,
+                                    Register rtmp, XMMRegister xtmp) {
 diff --git a/src/cpu/x86/vm/assembler_x86.hpp b/src/cpu/x86/vm/assembler_x86.hpp
 --- a/src/cpu/x86/vm/assembler_x86.hpp
 +++ b/src/cpu/x86/vm/assembler_x86.hpp
@@ -4851,7 +5162,7 @@
    __ load_klass(temp, obj);
    __ cmpptr(temp, ExternalAddress((address) klass_addr));
    __ jcc(Assembler::equal, L_ok);
-@@ -541,17 +87,40 @@
+@@ -541,17 +87,42 @@
    __ movptr(temp, Address(temp, super_check_offset));
    __ cmpptr(temp, ExternalAddress((address) klass_addr));
    __ jcc(Assembler::equal, L_ok);
@@ -4868,6 +5179,7 @@
 +
 +void MethodHandles::verify_ref_kind(MacroAssembler* _masm, int ref_kind, Register member_reg, Register temp) {
 +  Label L;
++  BLOCK_COMMENT("verify_ref_kind {");
 +  __ movl(temp, Address(member_reg, NONZERO(java_lang_invoke_MemberName::flags_offset_in_bytes())));
 +  __ shrl(temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_SHIFT);
 +  __ andl(temp, java_lang_invoke_MemberName::MN_REFERENCE_KIND_MASK);
@@ -4881,6 +5193,7 @@
 +      trace_method_handle(_masm, buf);
 +    __ STOP(buf);
 +  }
++  BLOCK_COMMENT("} verify_ref_kind");
 +  __ bind(L);
 +}
 +
@@ -4897,7 +5210,7 @@
      Label run_compiled_code;
      // JVMTI events, such as single-stepping, are implemented partly by avoiding running
      // compiled code in threads for which the event is enabled.  Check here for
-@@ -567,462 +136,364 @@
+@@ -567,462 +138,370 @@
      __ cmpb(Address(rthread, JavaThread::interp_only_mode_offset()), 0);
      __ jccb(Assembler::zero, run_compiled_code);
      __ jmp(Address(method, methodOopDesc::interpreter_entry_offset()));
@@ -4924,6 +5237,7 @@
 +  //NOT_PRODUCT({ FlagSetting fs(TraceMethodHandles, true); trace_method_handle(_masm, "LZMH"); });
 +
 +  // Load the invoker, as MH -> MH.form -> LF.vmentry
++  __ verify_oop(recv);
 +  __ load_heap_oop(method_temp, Address(recv, NONZERO(java_lang_invoke_MethodHandle::form_offset_in_bytes())));
 +  __ verify_oop(method_temp);
 +  __ load_heap_oop(method_temp, Address(method_temp, NONZERO(java_lang_invoke_LambdaForm::vmentry_offset_in_bytes())));
@@ -5187,7 +5501,7 @@
 +  Register temp2 = rscratch2;
 +  Register temp3 = rax;
 +  if (for_compiler_entry) {
-+    assert(receiver_reg == j_rarg0, "only valid assignment");
++    assert(receiver_reg == (iid == vmIntrinsics::_linkToStatic ? noreg : j_rarg0), "only valid assignment");
 +    assert_different_registers(temp1,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
 +    assert_different_registers(temp2,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
 +    assert_different_registers(temp3,        j_rarg0, j_rarg1, j_rarg2, j_rarg3, j_rarg4, j_rarg5);
@@ -5342,7 +5656,7 @@
 +  Register temp2 = rdi;
 +  Register temp3 = rax;
 +  if (for_compiler_entry) {
-+    assert(receiver_reg == rcx, "only valid assignment");
++    assert(receiver_reg == (iid == vmIntrinsics::_linkToStatic ? noreg : rcx), "only valid assignment");
 +    assert_different_registers(temp1,        rcx, rdx);
 +    assert_different_registers(temp2,        rcx, rdx);
 +    assert_different_registers(temp3,        rcx, rdx);
@@ -5414,10 +5728,8 @@
 +
 +    Register temp1_recv_klass = temp1;
 +    if (iid != vmIntrinsics::_linkToStatic) {
-+      BLOCK_COMMENT("check_receiver {");
-+      // The receiver for the MemberName must be in receiver_reg.
 +      __ verify_oop(receiver_reg);
-+      if (iid == vmIntrinsics::_linkToSpecial && !VerifyMethodHandles) {
++      if (iid == vmIntrinsics::_linkToSpecial) {
 +        // Don't actually load the klass; just null-check the receiver.
 +        __ null_check(receiver_reg);
 +      } else {
@@ -5426,7 +5738,14 @@
 +        __ load_klass(temp1_recv_klass, receiver_reg);
 +        __ verify_oop(temp1_recv_klass);
 +      }
++      BLOCK_COMMENT("check_receiver {");
++      // The receiver for the MemberName must be in receiver_reg.
 +      // Check the receiver against the MemberName.clazz
++      if (VerifyMethodHandles && iid == vmIntrinsics::_linkToSpecial) {
++        // Did not load it above...
++        __ load_klass(temp1_recv_klass, receiver_reg);
++        __ verify_oop(temp1_recv_klass);
++      }
 +      if (VerifyMethodHandles && iid != vmIntrinsics::_linkToInterface) {
 +        Label L_ok;
 +        Register temp2_defc = temp2;
@@ -5678,7 +5997,7 @@
  
    if (Verbose) {
      tty->print_cr("Registers:");
-@@ -1086,12 +557,18 @@
+@@ -1086,12 +565,18 @@
          values.describe(-1, dump_fp, "fp for #1 <not parsed, cannot trust pc>");
          values.describe(-1, dump_sp, "sp for #1");
        }
@@ -5699,7 +6018,7 @@
    }
  }
  
-@@ -1159,1363 +636,3 @@
+@@ -1159,1363 +644,3 @@
  }
  #endif //PRODUCT
  
@@ -7356,16 +7675,39 @@
 diff --git a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp
 --- a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp
 +++ b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp
-@@ -1293,6 +1293,66 @@
+@@ -1293,6 +1293,89 @@
    __ bind(done);
  }
  
++static void verify_oop_args(MacroAssembler* masm,
++                            int total_args_passed,
++                            const BasicType* sig_bt,
++                            const VMRegPair* regs) {
++  Register temp_reg = rbx;  // not part of any compiled calling seq
++  if (VerifyOops) {
++    for (int i = 0; i < total_args_passed; i++) {
++      if (sig_bt[i] == T_OBJECT ||
++          sig_bt[i] == T_ARRAY) {
++        VMReg r = regs[i].first();
++        assert(r->is_valid(), "bad oop arg");
++        if (r->is_stack()) {
++          __ movptr(temp_reg, Address(rsp, r->reg2stack() * VMRegImpl::stack_slot_size + wordSize));
++          __ verify_oop(temp_reg);
++        } else {
++          __ verify_oop(r->as_Register());
++        }
++      }
++    }
++  }
++}
++
 +static void gen_special_dispatch(MacroAssembler* masm,
 +                                 int total_args_passed,
 +                                 int comp_args_on_stack,
 +                                 vmIntrinsics::ID special_dispatch,
 +                                 const BasicType* sig_bt,
 +                                 const VMRegPair* regs) {
++  verify_oop_args(masm, total_args_passed, sig_bt, regs);
 +
 +  // Now write the args into the outgoing interpreter space
 +  bool     has_receiver   = false;
@@ -7423,7 +7765,7 @@
  
  // ---------------------------------------------------------------------------
  // Generate a native wrapper for a given method.  The method takes arguments
-@@ -1323,14 +1383,37 @@
+@@ -1323,14 +1406,37 @@
  //    transition back to thread_in_Java
  //    return to caller
  //
@@ -7464,7 +7806,7 @@
    bool is_critical_native = true;
    address native_func = method->critical_native_function();
    if (native_func == NULL) {
-@@ -1436,7 +1519,7 @@
+@@ -1436,7 +1542,7 @@
        if (in_regs[i].first()->is_Register()) {
          const Register reg = in_regs[i].first()->as_Register();
          switch (in_sig_bt[i]) {
@@ -7491,16 +7833,39 @@
  class ComputeMoveOrder: public StackObj {
    class MoveOperation: public ResourceObj {
      friend class ComputeMoveOrder;
-@@ -1532,6 +1540,66 @@
+@@ -1532,6 +1540,89 @@
    }
  };
  
++static void verify_oop_args(MacroAssembler* masm,
++                            int total_args_passed,
++                            const BasicType* sig_bt,
++                            const VMRegPair* regs) {
++  Register temp_reg = rbx;  // not part of any compiled calling seq
++  if (VerifyOops) {
++    for (int i = 0; i < total_args_passed; i++) {
++      if (sig_bt[i] == T_OBJECT ||
++          sig_bt[i] == T_ARRAY) {
++        VMReg r = regs[i].first();
++        assert(r->is_valid(), "bad oop arg");
++        if (r->is_stack()) {
++          __ movptr(temp_reg, Address(rsp, r->reg2stack() * VMRegImpl::stack_slot_size + wordSize));
++          __ verify_oop(temp_reg);
++        } else {
++          __ verify_oop(r->as_Register());
++        }
++      }
++    }
++  }
++}
++
 +static void gen_special_dispatch(MacroAssembler* masm,
 +                                 int total_args_passed,
 +                                 int comp_args_on_stack,
 +                                 vmIntrinsics::ID special_dispatch,
 +                                 const BasicType* sig_bt,
 +                                 const VMRegPair* regs) {
++  verify_oop_args(masm, total_args_passed, sig_bt, regs);
 +
 +  // Now write the args into the outgoing interpreter space
 +  bool     has_receiver   = false;
@@ -7543,7 +7908,7 @@
 +      // pass the receiver oop in a register.  If this is not true on some
 +      // platform, pick a temp and load the receiver from stack.
 +      assert(false, "receiver always in a register");
-+      receiver_reg = rcx;  // known to be free at this point
++      receiver_reg = j_rarg0;  // known to be free at this point
 +      __ movptr(receiver_reg, Address(rsp, r->reg2stack() * VMRegImpl::stack_slot_size + wordSize));
 +    } else {
 +      // no data motion is needed
@@ -7558,7 +7923,7 @@
  
  // ---------------------------------------------------------------------------
  // Generate a native wrapper for a given method.  The method takes arguments
-@@ -1539,14 +1607,60 @@
+@@ -1539,14 +1630,60 @@
  // convention (handlizes oops, etc), transitions to native, makes the call,
  // returns to java state (possibly blocking), unhandlizes any result and
  // returns.
@@ -7622,7 +7987,7 @@
    bool is_critical_native = true;
    address native_func = method->critical_native_function();
    if (native_func == NULL) {
-@@ -1658,7 +1772,7 @@
+@@ -1658,7 +1795,7 @@
            case T_SHORT:
            case T_CHAR:
            case T_INT:  single_slots++; break;
@@ -9666,7 +10031,26 @@
      fatal("Invalid layout of preloaded class");
    }
    dest_offset = fd.offset();
-@@ -2377,8 +2384,7 @@
+@@ -1455,6 +1462,7 @@
+   nmethod* nm = NULL;
+   bool skip_fillInStackTrace_check = false;
+   bool skip_throwableInit_check = false;
++  KlassHandle skip_lambda_form_klass(THREAD, SystemDictionary::well_known_klass(SystemDictionary::WK_KLASS_ENUM_NAME(LambdaForm_klass)));
+ 
+   for (frame fr = thread->last_frame(); max_depth != total_count;) {
+     methodOop method = NULL;
+@@ -1534,6 +1542,10 @@
+         skip_throwableInit_check = true;
+       }
+     }
++    if (!ShowMethodHandleFrames &&
++        (method->is_compiled_lambda_form() ||   // FIXME: allocate a methodOop flag bit for this
++         method->method_holder() == skip_lambda_form_klass()))
++      continue;
+     bt.push(method, bci, CHECK);
+     total_count++;
+   }
+@@ -2377,8 +2389,7 @@
  // Support for java_lang_invoke_MethodHandle
  
  int java_lang_invoke_MethodHandle::_type_offset;
@@ -9676,7 +10060,7 @@
  
  int java_lang_invoke_MemberName::_clazz_offset;
  int java_lang_invoke_MemberName::_name_offset;
-@@ -2387,21 +2393,18 @@
+@@ -2387,21 +2398,18 @@
  int java_lang_invoke_MemberName::_vmtarget_offset;
  int java_lang_invoke_MemberName::_vmindex_offset;
  
@@ -9704,7 +10088,7 @@
    }
  }
  
-@@ -2412,30 +2415,14 @@
+@@ -2412,30 +2420,14 @@
      compute_offset(_name_offset,      klass_oop, vmSymbols::name_name(),      vmSymbols::string_signature());
      compute_offset(_type_offset,      klass_oop, vmSymbols::type_name(),      vmSymbols::object_signature());
      compute_offset(_flags_offset,     klass_oop, vmSymbols::flags_name(),     vmSymbols::int_signature());
@@ -9739,7 +10123,7 @@
    }
  }
  
-@@ -2464,31 +2451,14 @@
+@@ -2464,31 +2456,14 @@
    mh->obj_field_put(_type_offset, mtype);
  }
  
@@ -9777,7 +10161,7 @@
  }
  
  /// MemberName accessors
-@@ -2540,57 +2510,40 @@
+@@ -2540,57 +2515,40 @@
  
  void java_lang_invoke_MemberName::set_vmtarget(oop mname, oop ref) {
    assert(is_instance(mname), "wrong type");
@@ -9860,7 +10244,7 @@
  }
  
  
-@@ -2635,6 +2588,8 @@
+@@ -2635,6 +2593,8 @@
  }
  
  bool java_lang_invoke_MethodType::equals(oop mt1, oop mt2) {
@@ -9869,7 +10253,7 @@
    if (rtype(mt1) != rtype(mt2))
      return false;
    if (ptype_count(mt1) != ptype_count(mt2))
-@@ -2669,62 +2624,25 @@
+@@ -2669,62 +2629,25 @@
    return ptypes(mt)->length();
  }
  
@@ -9940,7 +10324,7 @@
  }
  
  
-@@ -2809,10 +2727,26 @@
+@@ -2809,10 +2732,26 @@
  }
  
  oop java_lang_ClassLoader::parent(oop loader) {
@@ -9968,7 +10352,7 @@
  
  // For class loader classes, parallelCapable defined
  // based on non-null field
-@@ -3072,9 +3006,7 @@
+@@ -3072,9 +3011,7 @@
    if (EnableInvokeDynamic) {
      java_lang_invoke_MethodHandle::compute_offsets();
      java_lang_invoke_MemberName::compute_offsets();
@@ -9979,7 +10363,7 @@
      java_lang_invoke_MethodType::compute_offsets();
      java_lang_invoke_MethodTypeForm::compute_offsets();
      java_lang_invoke_CallSite::compute_offsets();
-@@ -3306,7 +3238,14 @@
+@@ -3306,7 +3243,14 @@
      }
    }
    ResourceMark rm;
@@ -11142,6 +11526,44 @@
    tty->print_cr("deoptimization_stubs: %d",deoptimizationStubCount);
    tty->print_cr("uncommon_traps: %d",uncommonTrapStubCount);
    tty->print_cr("\nnmethod size distribution (non-zombie java)");
+diff --git a/src/share/vm/code/nmethod.cpp b/src/share/vm/code/nmethod.cpp
+--- a/src/share/vm/code/nmethod.cpp
++++ b/src/share/vm/code/nmethod.cpp
+@@ -945,8 +945,12 @@
+ void nmethod::print_on(outputStream* st, const char* msg) const {
+   if (st != NULL) {
+     ttyLocker ttyl;
+-    CompileTask::print_compilation(st, this, msg);
+-    if (WizardMode) st->print(" (" INTPTR_FORMAT ")", this);
++    if (WizardMode) {
++      CompileTask::print_compilation(st, this, msg, /*short_form:*/ true);
++      st->print_cr(" (" INTPTR_FORMAT ")", this);
++    } else {
++      CompileTask::print_compilation(st, this, msg, /*short_form:*/ false);
++    }
+   }
+ }
+ 
+diff --git a/src/share/vm/code/vtableStubs.hpp b/src/share/vm/code/vtableStubs.hpp
+--- a/src/share/vm/code/vtableStubs.hpp
++++ b/src/share/vm/code/vtableStubs.hpp
+@@ -55,6 +55,8 @@
+   int index() const                              { return _index; }
+   static VMReg receiver_location()               { return _receiver_location; }
+   void set_next(VtableStub* n)                   { _next = n; }
++
++ public:
+   address code_begin() const                     { return (address)(this + 1); }
+   address code_end() const                       { return code_begin() + pd_code_size_limit(_is_vtable_stub); }
+   address entry_point() const                    { return code_begin(); }
+@@ -65,6 +67,7 @@
+   }
+   bool contains(address pc) const                { return code_begin() <= pc && pc < code_end(); }
+ 
++ private:
+   void set_exception_points(address npe_addr, address ame_addr) {
+     _npe_offset = npe_addr - code_begin();
+     _ame_offset = ame_addr - code_begin();
 diff --git a/src/share/vm/compiler/compileBroker.cpp b/src/share/vm/compiler/compileBroker.cpp
 --- a/src/share/vm/compiler/compileBroker.cpp
 +++ b/src/share/vm/compiler/compileBroker.cpp
@@ -11154,6 +11576,22 @@
      bool in_base_library;
      address adr = NativeLookup::lookup(method, in_base_library, THREAD);
      if (HAS_PENDING_EXCEPTION) {
+diff --git a/src/share/vm/compiler/compileBroker.hpp b/src/share/vm/compiler/compileBroker.hpp
+--- a/src/share/vm/compiler/compileBroker.hpp
++++ b/src/share/vm/compiler/compileBroker.hpp
+@@ -104,10 +104,10 @@
+ 
+ public:
+   void         print_compilation(outputStream* st = tty, bool short_form = false);
+-  static void  print_compilation(outputStream* st, const nmethod* nm, const char* msg = NULL) {
++  static void  print_compilation(outputStream* st, const nmethod* nm, const char* msg = NULL, bool short_form = false) {
+     print_compilation_impl(st, nm->method(), nm->compile_id(), nm->comp_level(),
+                            nm->is_osr_method(), nm->is_osr_method() ? nm->osr_entry_bci() : -1, /*is_blocking*/ false,
+-                           msg);
++                           msg, short_form);
+   }
+ 
+   static void  print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg = NULL);
 diff --git a/src/share/vm/interpreter/abstractInterpreter.hpp b/src/share/vm/interpreter/abstractInterpreter.hpp
 --- a/src/share/vm/interpreter/abstractInterpreter.hpp
 +++ b/src/share/vm/interpreter/abstractInterpreter.hpp
@@ -13385,9 +13823,24 @@
 diff --git a/src/share/vm/oops/methodKlass.cpp b/src/share/vm/oops/methodKlass.cpp
 --- a/src/share/vm/oops/methodKlass.cpp
 +++ b/src/share/vm/oops/methodKlass.cpp
-@@ -288,11 +288,7 @@
+@@ -238,7 +238,11 @@
+     st->print_cr(" - highest level:     %d", m->highest_comp_level());
+   st->print_cr(" - vtable index:      %d",   m->_vtable_index);
+   st->print_cr(" - i2i entry:         " INTPTR_FORMAT, m->interpreter_entry());
+-  st->print_cr(" - adapter:           " INTPTR_FORMAT, m->adapter());
++  st->print(   " - adapters:          ");
++  if (m->adapter() == NULL)
++    st->print_cr(INTPTR_FORMAT, m->adapter());
++  else
++    m->adapter()->print_adapter_on(st);
+   st->print_cr(" - compiled entry     " INTPTR_FORMAT, m->from_compiled_entry());
+   st->print_cr(" - code size:         %d",   m->code_size());
+   if (m->code_size() != 0) {
+@@ -286,13 +290,8 @@
+   if (m->code() != NULL) {
+     st->print   (" - compiled code: ");
      m->code()->print_value_on(st);
-     st->cr();
+-    st->cr();
    }
 -  if (m->is_method_handle_invoke()) {
 -    st->print_cr(" - invoke method type: " INTPTR_FORMAT, (address) m->method_handle_type());
@@ -13452,6 +13905,24 @@
      set_native_function(
        SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
        !native_bind_event_is_interesting);
+@@ -801,13 +799,13 @@
+   OrderAccess::storestore();
+ #ifdef SHARK
+   mh->_from_interpreted_entry = code->insts_begin();
+-#else
++#else //!SHARK
+   mh->_from_compiled_entry = code->verified_entry_point();
+   OrderAccess::storestore();
+   // Instantly compiled code can execute.
+-  mh->_from_interpreted_entry = mh->get_i2c_entry();
+-#endif // SHARK
+-
++  if (!mh->is_method_handle_intrinsic())
++    mh->_from_interpreted_entry = mh->get_i2c_entry();
++#endif //!SHARK
+ }
+ 
+ 
 @@ -859,106 +857,51 @@
    return false;
  }
@@ -21224,7 +21695,7 @@
    diagnostic(bool, PrintMethodHandleStubs, false,                           \
            "Print generated stub code for method handles")                   \
                                                                              \
-@@ -3845,19 +3839,12 @@
+@@ -3845,19 +3839,15 @@
    diagnostic(bool, VerifyMethodHandles, trueInDebug,                        \
            "perform extra checks when constructing method handles")          \
                                                                              \
@@ -21235,6 +21706,9 @@
 -          "Process all method handles with MethodHandleWalk")               \
 +  diagnostic(bool, PreferInterpreterMethodHandles, false,                   \
 +          "suppress compiled fast-paths for out-of-line MH calls")          \
++                                                                            \
++  diagnostic(bool, ShowMethodHandleFrames, false,                           \
++          "show intermediate compile lambda form frames (usually hidden)")  \
                                                                              \
    experimental(bool, TrustFinalNonStaticFields, false,                      \
            "trust final non-static declarations for constant folding")       \
@@ -21246,6 +21720,75 @@
    develop(bool, TraceInvokeDynamic, false,                                  \
            "trace internal invoke dynamic operations")                       \
                                                                              \
+diff --git a/src/share/vm/runtime/os.cpp b/src/share/vm/runtime/os.cpp
+--- a/src/share/vm/runtime/os.cpp
++++ b/src/share/vm/runtime/os.cpp
+@@ -807,7 +807,7 @@
+       // the interpreter is generated into a buffer blob
+       InterpreterCodelet* i = Interpreter::codelet_containing(addr);
+       if (i != NULL) {
+-        st->print_cr(INTPTR_FORMAT " is an Interpreter codelet", addr);
++        st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", addr, (int)(addr - i->code_begin()));
+         i->print_on(st);
+         return;
+       }
+@@ -818,14 +818,15 @@
+       }
+       //
+       if (AdapterHandlerLibrary::contains(b)) {
+-        st->print_cr(INTPTR_FORMAT " is an AdapterHandler", addr);
++        st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", addr, (int)(addr - b->code_begin()));
+         AdapterHandlerLibrary::print_handler_on(st, b);
+       }
+       // the stubroutines are generated into a buffer blob
+       StubCodeDesc* d = StubCodeDesc::desc_for(addr);
+       if (d != NULL) {
++        st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", addr, (int)(addr - d->begin()));
+         d->print_on(st);
+-        if (verbose) st->cr();
++        st->cr();
+         return;
+       }
+       if (StubRoutines::contains(addr)) {
+@@ -840,26 +841,25 @@
+       }
+       VtableStub* v = VtableStubs::stub_containing(addr);
+       if (v != NULL) {
++        st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", addr, (int)(addr - v->entry_point()));
+         v->print_on(st);
++        st->cr();
+         return;
+       }
+     }
+-    if (verbose && b->is_nmethod()) {
++    nmethod* nm = b->as_nmethod_or_null();
++    if (nm != NULL) {
+       ResourceMark rm;
+-      st->print("%#p: Compiled ", addr);
+-      ((nmethod*)b)->method()->print_value_on(st);
+-      st->print("  = (CodeBlob*)" INTPTR_FORMAT, b);
+-      st->cr();
++      st->print(INTPTR_FORMAT " is at entry_point+%d in (nmethod*)" INTPTR_FORMAT,
++                addr, (int)(addr - nm->entry_point()), nm);
++      if (verbose) {
++        st->print(" for ");
++        nm->method()->print_value_on(st);
++      }
++      nm->print_nmethod(verbose);
+       return;
+     }
+-    st->print(INTPTR_FORMAT " ", b);
+-    if ( b->is_nmethod()) {
+-      if (b->is_zombie()) {
+-        st->print_cr("is zombie nmethod");
+-      } else if (b->is_not_entrant()) {
+-        st->print_cr("is non-entrant nmethod");
+-      }
+-    }
++    st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", addr, (int)(addr - b->code_begin()));
+     b->print_on(st);
+     return;
+   }
 diff --git a/src/share/vm/runtime/reflection.cpp b/src/share/vm/runtime/reflection.cpp
 --- a/src/share/vm/runtime/reflection.cpp
 +++ b/src/share/vm/runtime/reflection.cpp
@@ -21585,7 +22128,7 @@
 -      tty->cr();
 -      tty->print_cr("i2c argument handler #%d for: %s %s (fingerprint = %s, %d bytes generated)",
 +    if (PrintAdapterHandlers || PrintStubCode) {
-+      entry->print_on(tty);
++      entry->print_adapter_on(tty);
 +      tty->print_cr("i2c argument handler #%d for: %s %s (%d bytes generated)",
                      _adapters->number_of_entries(), (method->is_static() ? "static" : "receiver"),
 -                    method->signature()->as_C_string(), fingerprint->as_string(), insts_size );
@@ -21649,14 +22192,14 @@
 -                   a->fingerprint()->as_string(),
 -                   a->get_i2c_entry(), a->get_c2i_entry(), a->get_c2i_unverified_entry());
 -
-+      a->print_on(tty);
++      a->print_adapter_on(tty);
        return;
      }
    }
    assert(false, "Should have found handler");
  }
  
-+void AdapterHandlerEntry::print_on(outputStream* st) const {
++void AdapterHandlerEntry::print_adapter_on(outputStream* st) const {
 +  st->print_cr("AHE@" INTPTR_FORMAT ": %s i2c: " INTPTR_FORMAT " c2i: " INTPTR_FORMAT " c2iUV: " INTPTR_FORMAT,
 +               (intptr_t) this, fingerprint()->as_string(),
 +               get_i2c_entry(), get_c2i_entry(), get_c2i_unverified_entry());
@@ -21760,12 +22303,13 @@
  
    AdapterHandlerEntry* next() {
      return (AdapterHandlerEntry*)BasicHashtableEntry::next();
-@@ -665,7 +637,7 @@
+@@ -665,7 +637,8 @@
    bool compare_code(unsigned char* code, int length, int total_args_passed, BasicType* sig_bt);
  #endif
  
 -  void print();
-+  virtual void print_on(outputStream* st) const;
++  //virtual void print_on(outputStream* st) const;  DO NOT USE
++  void print_adapter_on(outputStream* st) const;
  };
  
  class AdapterHandlerLibrary: public AllStatic {