--- a/hotspot/src/share/vm/prims/methodHandles.cpp	Wed Mar 15 11:44:46 2017 +0100
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp	Wed Mar 15 10:25:37 2017 -0400
@@ -124,7 +124,7 @@
 
 Handle MethodHandles::new_MemberName(TRAPS) {
   Handle empty;
-  instanceKlassHandle k(THREAD, SystemDictionary::MemberName_klass());
+  InstanceKlass* k = SystemDictionary::MemberName_klass();
   if (!k->is_initialized())  k->initialize(CHECK_(empty));
   return Handle(THREAD, k->allocate_instance(THREAD));
 }
@@ -138,9 +138,9 @@
   if (target_klass == SystemDictionary::reflect_Field_klass()) {
     oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
     int slot  = java_lang_reflect_Field::slot(target_oop);  // fd.index()
-    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
-    if (!k.is_null() && k->is_instance_klass()) {
-      fieldDescriptor fd(InstanceKlass::cast(k()), slot);
+    Klass* k = java_lang_Class::as_Klass(clazz);
+    if (k != NULL && k->is_instance_klass()) {
+      fieldDescriptor fd(InstanceKlass::cast(k), slot);
       oop mname2 = init_field_MemberName(mname, fd);
       if (mname2 != NULL) {
         // Since we have the reified name and type handy, add them to the result.
@@ -154,22 +154,22 @@
   } else if (target_klass == SystemDictionary::reflect_Method_klass()) {
     oop clazz  = java_lang_reflect_Method::clazz(target_oop);
     int slot   = java_lang_reflect_Method::slot(target_oop);
-    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
-    if (!k.is_null() && k->is_instance_klass()) {
-      Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
+    Klass* k = java_lang_Class::as_Klass(clazz);
+    if (k != NULL && k->is_instance_klass()) {
+      Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
       if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))
         return NULL;            // do not resolve unless there is a concrete signature
-      CallInfo info(m, k());
+      CallInfo info(m, k);
       return init_method_MemberName(mname, info);
     }
   } else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
     oop clazz  = java_lang_reflect_Constructor::clazz(target_oop);
     int slot   = java_lang_reflect_Constructor::slot(target_oop);
-    KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
-    if (!k.is_null() && k->is_instance_klass()) {
-      Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
+    Klass* k = java_lang_Class::as_Klass(clazz);
+    if (k != NULL && k->is_instance_klass()) {
+      Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
       if (m == NULL)  return NULL;
-      CallInfo info(m, k());
+      CallInfo info(m, k);
       return init_method_MemberName(mname, info);
     }
   }
@@ -180,8 +180,8 @@
   assert(info.resolved_appendix().is_null(), "only normal methods here");
   methodHandle m = info.resolved_method();
   assert(m.not_null(), "null method handle");
-  KlassHandle m_klass = m->method_holder();
-  assert(m.not_null(), "null holder for method handle");
+  Klass* m_klass = m->method_holder();
+  assert(m_klass != NULL, "null holder for method handle");
   int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
   int vmindex = Method::invalid_vtable_index;
 
@@ -208,12 +208,12 @@
   case CallInfo::vtable_call:
     vmindex = info.vtable_index();
     flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
-    assert(info.resolved_klass()->is_subtype_of(m_klass()), "virtual call must be type-safe");
+    assert(info.resolved_klass()->is_subtype_of(m_klass), "virtual call must be type-safe");
     if (m_klass->is_interface()) {
       // This is a vtable call to an interface method (abstract "miranda method" or default method).
       // The vtable index is meaningless without a class (not interface) receiver type, so get one.
       // (LinkResolver should help us figure this out.)
-      KlassHandle m_klass_non_interface = info.resolved_klass();
+      Klass* m_klass_non_interface = info.resolved_klass();
       if (m_klass_non_interface->is_interface()) {
         m_klass_non_interface = SystemDictionary::Object_klass();
 #ifdef ASSERT
@@ -229,7 +229,7 @@
         assert(m->is_public(), "virtual call must be to public interface method");
         return NULL;  // elicit an error later in product build
       }
-      assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface()), "virtual call must be type-safe");
+      assert(info.resolved_klass()->is_subtype_of(m_klass_non_interface), "virtual call must be type-safe");
       m_klass = m_klass_non_interface;
     }
     if (TraceInvokeDynamic) {
@@ -637,7 +637,7 @@
 // An unresolved member name is a mere symbolic reference.
 // Resolving it plants a vmtarget/vmindex in it,
 // which refers directly to JVM internals.
-Handle MethodHandles::resolve_MemberName(Handle mname, KlassHandle caller, TRAPS) {
+Handle MethodHandles::resolve_MemberName(Handle mname, Klass* caller, TRAPS) {
   Handle empty;
   assert(java_lang_invoke_MemberName::is_instance(mname()), "");
 
@@ -664,7 +664,7 @@
     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve", empty);
   }
 
-  instanceKlassHandle defc;
+  InstanceKlass* defc = NULL;
   {
     Klass* defc_klass = java_lang_Class::as_Klass(defc_oop());
     if (defc_klass == NULL)  return empty;  // a primitive; no resolution possible
@@ -672,9 +672,9 @@
       if (!defc_klass->is_array_klass())  return empty;
       defc_klass = SystemDictionary::Object_klass();
     }
-    defc = instanceKlassHandle(THREAD, defc_klass);
+    defc = InstanceKlass::cast(defc_klass);
   }
-  if (defc.is_null()) {
+  if (defc == NULL) {
     THROW_MSG_(vmSymbols::java_lang_InternalError(), "primitive class", empty);
   }
   defc->link_class(CHECK_(empty));  // possible safepoint
@@ -687,7 +687,7 @@
 
   vmIntrinsics::ID mh_invoke_id = vmIntrinsics::_none;
   if ((flags & ALL_KINDS) == IS_METHOD &&
-      (defc() == SystemDictionary::MethodHandle_klass()) &&
+      (defc == SystemDictionary::MethodHandle_klass()) &&
       (ref_kind == JVM_REF_invokeVirtual ||
        ref_kind == JVM_REF_invokeSpecial ||
        // static invocation mode is required for _linkToVirtual, etc.:
@@ -705,7 +705,7 @@
   TempNewSymbol type = lookup_signature(type_str(), (mh_invoke_id != vmIntrinsics::_none), CHECK_(empty));
   if (type == NULL)  return empty;  // no such signature exists in the VM
 
-  LinkInfo::AccessCheck access_check = caller.not_null() ?
+  LinkInfo::AccessCheck access_check = caller != NULL ?
                                               LinkInfo::needs_access_check :
                                               LinkInfo::skip_access_check;
 
@@ -840,7 +840,7 @@
     {
       assert(vmtarget->is_klass(), "field vmtarget is Klass*");
       if (!((Klass*) vmtarget)->is_instance_klass())  break;
-      instanceKlassHandle defc(THREAD, (Klass*) vmtarget);
+      InstanceKlass* defc = InstanceKlass::cast((Klass*) vmtarget);
       DEBUG_ONLY(vmtarget = NULL);  // safety
       bool is_static = ((flags & JVM_ACC_STATIC) != 0);
       fieldDescriptor fd; // find_field initializes fd if found
@@ -868,15 +868,15 @@
   THROW_MSG(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format");
 }
 
-int MethodHandles::find_MemberNames(KlassHandle k,
+int MethodHandles::find_MemberNames(Klass* k,
                                     Symbol* name, Symbol* sig,
-                                    int mflags, KlassHandle caller,
+                                    int mflags, Klass* caller,
                                     int skip, objArrayHandle results) {
   // %%% take caller into account!
 
   Thread* thread = Thread::current();
 
-  if (k.is_null() || !k->is_instance_klass())  return -1;
+  if (k == NULL || !k->is_instance_klass())  return -1;
 
   int rfill = 0, rlimit = results->length(), rskip = skip;
   // overflow measurement:
@@ -904,7 +904,8 @@
   }
 
   if ((match_flags & IS_FIELD) != 0) {
-    for (FieldStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {
+    InstanceKlass* ik = InstanceKlass::cast(k);
+    for (FieldStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
       if (name != NULL && st.name() != name)
           continue;
       if (sig != NULL && st.signature() != sig)
@@ -950,7 +951,8 @@
     } else {
       // caller will accept either sort; no need to adjust name
     }
-    for (MethodStream st(k(), local_only, !search_intfc); !st.eos(); st.next()) {
+    InstanceKlass* ik = InstanceKlass::cast(k);
+    for (MethodStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
       Method* m = st.method();
       Symbol* m_name = m->name();
       if (m_name == clinit_name)
@@ -1238,9 +1240,8 @@
     }
   }
 
-  KlassHandle caller(THREAD,
-                     caller_jh == NULL ? (Klass*) NULL :
-                     java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh)));
+  Klass* caller = caller_jh == NULL ? NULL :
+                     java_lang_Class::as_Klass(JNIHandles::resolve_non_null(caller_jh));
   Handle resolved = MethodHandles::resolve_MemberName(mname, caller, CHECK_NULL);
 
   if (resolved.is_null()) {
@@ -1330,7 +1331,7 @@
                                jclass clazz_jh, jstring name_jh, jstring sig_jh,
                                int mflags, jclass caller_jh, jint skip, jobjectArray results_jh)) {
   if (clazz_jh == NULL || results_jh == NULL)  return -1;
-  KlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh)));
+  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz_jh));
 
   objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh));
   if (results.is_null() || !results->is_objArray())  return -1;
@@ -1346,11 +1347,11 @@
     if (sig == NULL)  return 0; // a match is not possible
   }
 
-  KlassHandle caller;
+  Klass* caller = NULL;
   if (caller_jh != NULL) {
     oop caller_oop = JNIHandles::resolve_non_null(caller_jh);
     if (!java_lang_Class::is_instance(caller_oop))  return -1;
-    caller = KlassHandle(THREAD, java_lang_Class::as_Klass(caller_oop));
+    caller = java_lang_Class::as_Klass(caller_oop);
   }
 
   if (name != NULL && sig != NULL && results.not_null()) {