jdk-sandbox: comparison hotspot/src/share/vm/prims/methodHandles.cpp

equal deleted inserted replaced

-:b9b83b001cac
+:20cc2230dc8a
 // Note: A method which does not have a TRAPS argument cannot block in the GC
 // or throw exceptions.  Such methods are used in this file to do something quick
 // and local, like parse a data structure.  For speed, such methods work on plain
 // oops, not handles.  Trapping methods uniformly operate on handles.
-methodOop MethodHandles::decode_vmtarget(oop vmtarget, int vmindex, oop mtype,
+methodHandle MethodHandles::decode_vmtarget(oop vmtarget, int vmindex, oop mtype,
-klassOop& receiver_limit_result, int& decode_flags_result) {
+KlassHandle& receiver_limit_result, int& decode_flags_result) {
-if (vmtarget == NULL)  return NULL;
+if (vmtarget == NULL)  return methodHandle();
 assert(methodOopDesc::nonvirtual_vtable_index < 0, "encoding");
 if (vmindex < 0) {
 // this DMH performs no dispatch; it is directly bound to a methodOop
 // A MemberName may either be directly bound to a methodOop,
 // or it may use the klass/index form; both forms mean the same thing.
 }
 // MemberName and DirectMethodHandle have the same linkage to the JVM internals.
 // (MemberName is the non-operational name used for queries and setup.)
-methodOop MethodHandles::decode_DirectMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_DirectMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {
 oop vmtarget = java_lang_invoke_DirectMethodHandle::vmtarget(mh);
 int vmindex  = java_lang_invoke_DirectMethodHandle::vmindex(mh);
 oop mtype    = java_lang_invoke_DirectMethodHandle::type(mh);
 return decode_vmtarget(vmtarget, vmindex, mtype, receiver_limit_result, decode_flags_result);
 }
-methodOop MethodHandles::decode_BoundMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_BoundMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {
 assert(java_lang_invoke_BoundMethodHandle::is_instance(mh), "");
 assert(mh->klass() != SystemDictionary::AdapterMethodHandle_klass(), "");
 for (oop bmh = mh;;) {
 // Bound MHs can be stacked to bind several arguments.
 oop target = java_lang_invoke_MethodHandle::vmtarget(bmh);
-if (target == NULL)  return NULL;
+if (target == NULL)  return methodHandle();
 decode_flags_result |= MethodHandles::_dmf_binds_argument;
 klassOop tk = target->klass();
 if (tk == SystemDictionary::BoundMethodHandle_klass()) {
 bmh = target;
 continue;
 }
 }
 }
 }
-methodOop MethodHandles::decode_AdapterMethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_AdapterMethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {
 assert(mh->klass() == SystemDictionary::AdapterMethodHandle_klass(), "");
 for (oop amh = mh;;) {
 // Adapter MHs can be stacked to convert several arguments.
 int conv_op = adapter_conversion_op(java_lang_invoke_AdapterMethodHandle::conversion(amh));
 decode_flags_result |= (_dmf_adapter_lsb << conv_op) & _DMF_ADAPTER_MASK;
 oop target = java_lang_invoke_MethodHandle::vmtarget(amh);
-if (target == NULL)  return NULL;
+if (target == NULL)  return methodHandle();
 klassOop tk = target->klass();
 if (tk == SystemDictionary::AdapterMethodHandle_klass()) {
 amh = target;
 continue;
 } else {
 return MethodHandles::decode_MethodHandle(target, receiver_limit_result, decode_flags_result);
 }
 }
 }
-methodOop MethodHandles::decode_MethodHandle(oop mh, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_MethodHandle(oop mh, KlassHandle& receiver_limit_result, int& decode_flags_result) {
-if (mh == NULL)  return NULL;
+if (mh == NULL)  return methodHandle();
 klassOop mhk = mh->klass();
 assert(java_lang_invoke_MethodHandle::is_subclass(mhk), "must be a MethodHandle");
 if (mhk == SystemDictionary::DirectMethodHandle_klass()) {
 return decode_DirectMethodHandle(mh, receiver_limit_result, decode_flags_result);
 } else if (mhk == SystemDictionary::BoundMethodHandle_klass()) {
 } else if (java_lang_invoke_BoundMethodHandle::is_subclass(mhk)) {
 // could be a JavaMethodHandle (but not an adapter MH)
 return decode_BoundMethodHandle(mh, receiver_limit_result, decode_flags_result);
 } else {
 assert(false, "cannot parse this MH");
-return NULL;              // random MH?
+return methodHandle();  // random MH?
 }
 }
 methodOop MethodHandles::decode_methodOop(methodOop m, int& decode_flags_result) {
 assert(m->is_method(), "");
 }
 // A trusted party is handing us a cookie to determine a method.
 // Let's boil it down to the method oop they really want.
-methodOop MethodHandles::decode_method(oop x, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_method(oop x, KlassHandle& receiver_limit_result, int& decode_flags_result) {
 decode_flags_result = 0;
-receiver_limit_result = NULL;
+receiver_limit_result = KlassHandle();
 klassOop xk = x->klass();
 if (xk == Universe::methodKlassObj()) {
 return decode_methodOop((methodOop) x, decode_flags_result);
 } else if (xk == SystemDictionary::MemberName_klass()) {
 // Note: This only works if the MemberName has already been resolved.
 } else {
 // unrecognized object
 assert(!x->is_method(), "already checked");
 assert(!java_lang_invoke_MemberName::is_instance(x), "already checked");
 }
-return NULL;
+return methodHandle();
 }
 int MethodHandles::decode_MethodHandle_stack_pushes(oop mh) {
 if (mh->klass() == SystemDictionary::DirectMethodHandle_klass())
 int mods  = java_lang_reflect_Field::modifiers(target_oop);
 klassOop k = java_lang_Class::as_klassOop(clazz);
 int offset = instanceKlass::cast(k)->offset_from_fields(slot);
 init_MemberName(mname_oop, k, accessFlags_from(mods), offset);
 } else {
-int decode_flags = 0; klassOop receiver_limit = NULL;
+KlassHandle receiver_limit; int decode_flags = 0;
-methodOop m = MethodHandles::decode_method(target_oop,
+methodHandle m = MethodHandles::decode_method(target_oop, receiver_limit, decode_flags);
-receiver_limit, decode_flags);
 bool do_dispatch = ((decode_flags & MethodHandles::_dmf_does_dispatch) != 0);
-init_MemberName(mname_oop, m, do_dispatch);
+init_MemberName(mname_oop, m(), do_dispatch);
 }
 }
 void MethodHandles::init_MemberName(oop mname_oop, methodOop m, bool do_dispatch) {
 int flags = ((m->is_initializer() ? IS_CONSTRUCTOR : IS_METHOD)
 java_lang_invoke_MemberName::set_flags(mname_oop,    flags);
 java_lang_invoke_MemberName::set_clazz(mname_oop,    Klass::cast(field_holder)->java_mirror());
 }
-methodOop MethodHandles::decode_MemberName(oop mname, klassOop& receiver_limit_result, int& decode_flags_result) {
+methodHandle MethodHandles::decode_MemberName(oop mname, KlassHandle& receiver_limit_result, int& decode_flags_result) {
+methodHandle empty;
 int flags  = java_lang_invoke_MemberName::flags(mname);
-if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) == 0)  return NULL;  // not invocable
+if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) == 0)  return empty;  // not invocable
 oop vmtarget = java_lang_invoke_MemberName::vmtarget(mname);
 int vmindex  = java_lang_invoke_MemberName::vmindex(mname);
-if (vmindex == VM_INDEX_UNINITIALIZED)  return NULL; // not resolved
+if (vmindex == VM_INDEX_UNINITIALIZED)  return empty;  // not resolved
-methodOop m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);
+methodHandle m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit_result, decode_flags_result);
 oop clazz = java_lang_invoke_MemberName::clazz(mname);
 if (clazz != NULL && java_lang_Class::is_instance(clazz)) {
 klassOop klass = java_lang_Class::as_klassOop(clazz);
 if (klass != NULL)  receiver_limit_result = klass;
 }
 return m;
 }
 // convert the external string or reflective type to an internal signature
-Symbol* MethodHandles::convert_to_signature(oop type_str,
+Symbol* MethodHandles::convert_to_signature(oop type_str, bool polymorphic, TRAPS) {
-bool polymorphic,
-TRAPS) {
 if (java_lang_invoke_MethodType::is_instance(type_str)) {
 return java_lang_invoke_MethodType::as_signature(type_str, polymorphic, CHECK_NULL);
 } else if (java_lang_Class::is_instance(type_str)) {
 return java_lang_Class::as_signature(type_str, false, CHECK_NULL);
 } else if (java_lang_String::is_instance(type_str)) {
 const int sentinel_limit = methodOopDesc::highest_unused_vtable_index_value - sentinel_slop;
 assert(VM_INDEX_UNINITIALIZED < sentinel_limit, "Java sentinel != JVM sentinels");
 #endif
 if (java_lang_invoke_MemberName::vmindex(mname()) != VM_INDEX_UNINITIALIZED)
 return;  // already resolved
-oop defc_oop = java_lang_invoke_MemberName::clazz(mname());
+Handle defc_oop(THREAD, java_lang_invoke_MemberName::clazz(mname()));
-oop name_str = java_lang_invoke_MemberName::name(mname());
+Handle name_str(THREAD, java_lang_invoke_MemberName::name( mname()));
-oop type_str = java_lang_invoke_MemberName::type(mname());
+Handle type_str(THREAD, java_lang_invoke_MemberName::type( mname()));
-int flags    = java_lang_invoke_MemberName::flags(mname());
+int    flags    =       java_lang_invoke_MemberName::flags(mname());
-if (defc_oop == NULL || name_str == NULL || type_str == NULL) {
+if (defc_oop.is_null() || name_str.is_null() || type_str.is_null()) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "nothing to resolve");
 }
-klassOop defc_klassOop = java_lang_Class::as_klassOop(defc_oop);
-defc_oop = NULL;  // safety
+instanceKlassHandle defc;
-if (defc_klassOop == NULL)  return;  // a primitive; no resolution possible
+{
-if (!Klass::cast(defc_klassOop)->oop_is_instance()) {
+klassOop defc_klassOop = java_lang_Class::as_klassOop(defc_oop());
-if (!Klass::cast(defc_klassOop)->oop_is_array())  return;
+if (defc_klassOop == NULL)  return;  // a primitive; no resolution possible
-defc_klassOop = SystemDictionary::Object_klass();
+if (!Klass::cast(defc_klassOop)->oop_is_instance()) {
-}
+if (!Klass::cast(defc_klassOop)->oop_is_array())  return;
-instanceKlassHandle defc(THREAD, defc_klassOop);
+defc_klassOop = SystemDictionary::Object_klass();
-defc_klassOop = NULL;  // safety
+}
+defc = instanceKlassHandle(THREAD, defc_klassOop);
+}
 if (defc.is_null()) {
 THROW_MSG(vmSymbols::java_lang_InternalError(), "primitive class");
 }
-defc->link_class(CHECK);
+defc->link_class(CHECK);  // possible safepoint
 // convert the external string name to an internal symbol
-TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str);
+TempNewSymbol name = java_lang_String::as_symbol_or_null(name_str());
 if (name == NULL)  return;  // no such name
-name_str = NULL;  // safety
 Handle polymorphic_method_type;
 bool polymorphic_signature = false;
 if ((flags & ALL_KINDS) == IS_METHOD &&
 (defc() == SystemDictionary::MethodHandle_klass() &&
-methodOopDesc::is_method_handle_invoke_name(name)))
+methodOopDesc::is_method_handle_invoke_name(name))) {
 polymorphic_signature = true;
+}
 // convert the external string or reflective type to an internal signature
-TempNewSymbol type = convert_to_signature(type_str, polymorphic_signature, CHECK);
+TempNewSymbol type = convert_to_signature(type_str(), polymorphic_signature, CHECK);
-if (java_lang_invoke_MethodType::is_instance(type_str) && polymorphic_signature) {
+if (java_lang_invoke_MethodType::is_instance(type_str()) && polymorphic_signature) {
-polymorphic_method_type = Handle(THREAD, type_str);  //preserve exactly
+polymorphic_method_type = type_str;  // preserve exactly
 }
 if (type == NULL)  return;  // no such signature exists in the VM
-type_str = NULL; // safety
 // Time to do the lookup.
 switch (flags & ALL_KINDS) {
 case IS_METHOD:
 {
 }
 int mods = (m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS);
 java_lang_invoke_MemberName::set_vmtarget(mname(), vmtarget);
 java_lang_invoke_MemberName::set_vmindex(mname(),  vmindex);
 java_lang_invoke_MemberName::set_modifiers(mname(), mods);
-DEBUG_ONLY(int junk; klassOop junk2);
+DEBUG_ONLY(KlassHandle junk1; int junk2);
-assert(decode_MemberName(mname(), junk2, junk) == result.resolved_method()(),
+assert(decode_MemberName(mname(), junk1, junk2) == result.resolved_method(),
 "properly stored for later decoding");
 return;
 }
 case IS_CONSTRUCTOR:
 {
 int vmindex  = methodOopDesc::nonvirtual_vtable_index;
 int mods     = (m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS);
 java_lang_invoke_MemberName::set_vmtarget(mname(), vmtarget);
 java_lang_invoke_MemberName::set_vmindex(mname(),  vmindex);
 java_lang_invoke_MemberName::set_modifiers(mname(), mods);
-DEBUG_ONLY(int junk; klassOop junk2);
+DEBUG_ONLY(KlassHandle junk1; int junk2);
-assert(decode_MemberName(mname(), junk2, junk) == result.resolved_method()(),
+assert(decode_MemberName(mname(), junk1, junk2) == result.resolved_method(),
 "properly stored for later decoding");
 return;
 }
 case IS_FIELD:
 {
 switch (flags & ALL_KINDS) {
 case IS_METHOD:
 case IS_CONSTRUCTOR:
 {
-klassOop receiver_limit = NULL;
+KlassHandle receiver_limit; int decode_flags = 0;
-int      decode_flags   = 0;
+methodHandle m = decode_vmtarget(vmtarget, vmindex, NULL, receiver_limit, decode_flags);
-methodHandle m(THREAD, decode_vmtarget(vmtarget, vmindex, NULL,
-receiver_limit, decode_flags));
 if (m.is_null())  break;
 if (!have_defc) {
 klassOop defc = m->method_holder();
-if (receiver_limit != NULL && receiver_limit != defc
+if (receiver_limit.not_null() && receiver_limit() != defc
-&& Klass::cast(receiver_limit)->is_subtype_of(defc))
+&& Klass::cast(receiver_limit())->is_subtype_of(defc))
-defc = receiver_limit;
+defc = receiver_limit();
 java_lang_invoke_MemberName::set_clazz(mname(), Klass::cast(defc)->java_mirror());
 }
 if (!have_name) {
 //not java_lang_String::create_from_symbol; let's intern member names
 Handle name = StringTable::intern(m->name(), CHECK);
 }
 // cases of metadata in MH.vmtarget:
 // - AMH can have methodOop for static invoke with bound receiver
 // - DMH can have methodOop for static invoke (on variable receiver)
 // - DMH can have klassOop for dispatched (non-static) invoke
-klassOop receiver_limit = NULL;
+KlassHandle receiver_limit; int decode_flags = 0;
-int decode_flags = 0;
+methodHandle m = decode_MethodHandle(mh(), receiver_limit, decode_flags);
-methodOop m = decode_MethodHandle(mh(), receiver_limit, decode_flags);
+if (m.is_null())  return NULL;
-if (m == NULL)  return NULL;
 switch (format) {
 case ETF_REFLECT_METHOD:
 // same as jni_ToReflectedMethod:
 if (m->is_initializer()) {
 return Reflection::new_constructor(m, THREAD);
 case ETF_METHOD_NAME:
 {
 if (SystemDictionary::MemberName_klass() == NULL)  break;
 instanceKlassHandle mname_klass(THREAD, SystemDictionary::MemberName_klass());
 mname_klass->initialize(CHECK_NULL);
-Handle mname = mname_klass->allocate_instance_handle(CHECK_NULL);
+Handle mname = mname_klass->allocate_instance_handle(CHECK_NULL);  // possible safepoint
 java_lang_invoke_MemberName::set_vmindex(mname(), VM_INDEX_UNINITIALIZED);
 bool do_dispatch = ((decode_flags & MethodHandles::_dmf_does_dispatch) != 0);
-init_MemberName(mname(), m, do_dispatch);
+init_MemberName(mname(), m(), do_dispatch);
 expand_MemberName(mname, 0, CHECK_NULL);
 return mname();
 }
 }
 // InterpreterRuntime::resolve_invoke(), which first finds the method
 // and then decides how to populate the constant pool cache entry
 // that links the interpreter calls to the method.  We need the same
 // bits, and will use the same calling sequence code.
-int vmindex = methodOopDesc::garbage_vtable_index;
+int    vmindex = methodOopDesc::garbage_vtable_index;
-oop vmtarget = NULL;
+Handle vmtarget;
 instanceKlass::cast(m->method_holder())->link_class(CHECK);
 MethodHandleEntry* me = NULL;
 if (do_dispatch && Klass::cast(m->method_holder())->is_interface()) {
 vmtarget = m->method_holder(); // the interface
 me = MethodHandles::entry(MethodHandles::_invokeinterface_mh);
 } else if (!do_dispatch || m->can_be_statically_bound()) {
 // We are simulating an invokestatic or invokespecial instruction.
 // Set up the method pointer, just like ConstantPoolCacheEntry::set_method().
-vmtarget = m();
+vmtarget = m;
 // this does not help dispatch, but it will make it possible to parse this MH:
 vmindex  = methodOopDesc::nonvirtual_vtable_index;
 assert(vmindex < 0, "(>=0) == do_dispatch");
 if (!m->is_static()) {
 me = MethodHandles::entry(MethodHandles::_invokespecial_mh);
 me = MethodHandles::entry(MethodHandles::_invokestatic_mh);
 // Part of the semantics of a static call is an initialization barrier.
 // For a DMH, it is done now, when the handle is created.
 Klass* k = Klass::cast(m->method_holder());
 if (k->should_be_initialized()) {
-k->initialize(CHECK);
+k->initialize(CHECK);  // possible safepoint
 }
 }
 } else {
 // We are simulating an invokevirtual instruction.
 // Set up the vtable index, just like ConstantPoolCacheEntry::set_method().
 me = MethodHandles::entry(MethodHandles::_invokevirtual_mh);
 }
 if (me == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
-java_lang_invoke_DirectMethodHandle::set_vmtarget(mh(), vmtarget);
+java_lang_invoke_DirectMethodHandle::set_vmtarget(mh(), vmtarget());
-java_lang_invoke_DirectMethodHandle::set_vmindex(mh(),  vmindex);
+java_lang_invoke_DirectMethodHandle::set_vmindex( mh(), vmindex);
-DEBUG_ONLY(int flags; klassOop rlimit);
+DEBUG_ONLY(KlassHandle rlimit; int flags);
-assert(MethodHandles::decode_method(mh(), rlimit, flags) == m(),
+assert(MethodHandles::decode_method(mh(), rlimit, flags) == m,
 "properly stored for later decoding");
 DEBUG_ONLY(bool actual_do_dispatch = ((flags & _dmf_does_dispatch) != 0));
 assert(!(actual_do_dispatch && !do_dispatch),
 "do not perform dispatch if !do_dispatch specified");
 assert(actual_do_dispatch == (vmindex >= 0), "proper later decoding of do_dispatch");
 void MethodHandles::verify_BoundMethodHandle_with_receiver(Handle mh,
 methodHandle m,
 TRAPS) {
 // Verify type.
-oop receiver = java_lang_invoke_BoundMethodHandle::argument(mh());
+KlassHandle bound_recv_type;
+{
+oop receiver = java_lang_invoke_BoundMethodHandle::argument(mh());
+if (receiver != NULL)
+bound_recv_type = KlassHandle(THREAD, receiver->klass());
+}
 Handle mtype(THREAD, java_lang_invoke_MethodHandle::type(mh()));
-KlassHandle bound_recv_type;
-if (receiver != NULL)  bound_recv_type = KlassHandle(THREAD, receiver->klass());
 verify_method_type(m, mtype, true, bound_recv_type, CHECK);
 int receiver_pos = m->size_of_parameters() - 1;
 // Verify MH.vmargslot, which should point at the bound receiver.
 verify_BoundMethodHandle_with_receiver(mh, m, CHECK);
 }
 java_lang_invoke_BoundMethodHandle::set_vmtarget(mh(), m());
-DEBUG_ONLY(int junk; klassOop junk2);
+DEBUG_ONLY(KlassHandle junk1; int junk2);
-assert(MethodHandles::decode_method(mh(), junk2, junk) == m(), "properly stored for later decoding");
+assert(MethodHandles::decode_method(mh(), junk1, junk2) == m, "properly stored for later decoding");
 assert(decode_MethodHandle_stack_pushes(mh()) == 1, "BMH pushes one stack slot");
 // Done!
 java_lang_invoke_MethodHandle::set_vmentry(mh(), MethodHandles::entry(MethodHandles::_bound_ref_direct_mh));
 }
 verify_vmargslot(mh, insert_after, java_lang_invoke_BoundMethodHandle::vmargslot(mh()), CHECK);
 verify_vmslots(mh, CHECK);
 }
 // Get bound type and required slots.
-oop ptype_oop = java_lang_invoke_MethodType::ptype(java_lang_invoke_MethodHandle::type(target()), argnum);
+BasicType ptype;
-BasicType ptype = java_lang_Class::as_BasicType(ptype_oop);
+{
+oop ptype_oop = java_lang_invoke_MethodType::ptype(java_lang_invoke_MethodHandle::type(target()), argnum);
+ptype = java_lang_Class::as_BasicType(ptype_oop);
+}
 int slots_pushed = type2size[ptype];
 // If (a) the target is a direct non-dispatched method handle,
 // or (b) the target is a dispatched direct method handle and we
 // are binding the receiver, cut out the middle-man.
 // Do this by decoding the DMH and using its methodOop directly as vmtarget.
 bool direct_to_method = false;
 if (OptimizeMethodHandles &&
 target->klass() == SystemDictionary::DirectMethodHandle_klass() &&
 (argnum == 0 || java_lang_invoke_DirectMethodHandle::vmindex(target()) < 0)) {
-int decode_flags = 0; klassOop receiver_limit_oop = NULL;
+KlassHandle receiver_limit; int decode_flags = 0;
-methodHandle m(THREAD, decode_method(target(), receiver_limit_oop, decode_flags));
+methodHandle m = decode_method(target(), receiver_limit, decode_flags);
 if (m.is_null()) { THROW_MSG(vmSymbols::java_lang_InternalError(), "DMH failed to decode"); }
 DEBUG_ONLY(int m_vmslots = m->size_of_parameters() - slots_pushed); // pos. of 1st arg.
 assert(java_lang_invoke_BoundMethodHandle::vmslots(mh()) == m_vmslots, "type w/ m sig");
 if (argnum == 0 && (decode_flags & _dmf_has_receiver) != 0) {
-KlassHandle receiver_limit(THREAD, receiver_limit_oop);
 init_BoundMethodHandle_with_receiver(mh, m,
 receiver_limit, decode_flags,
 CHECK);
 return;
 }
 }
 }
 void MethodHandles::init_AdapterMethodHandle(Handle mh, Handle target, int argnum, TRAPS) {
-oop  argument   = java_lang_invoke_AdapterMethodHandle::argument(mh());
 int  argslot    = java_lang_invoke_AdapterMethodHandle::vmargslot(mh());
 jint conversion = java_lang_invoke_AdapterMethodHandle::conversion(mh());
 jint conv_op    = adapter_conversion_op(conversion);
 // adjust the adapter code to the internal EntryKind enumeration:
 // Early returns out of this method leave the DMH in an unfinished state.
 assert(java_lang_invoke_MethodHandle::vmentry(mh()) == NULL, "must be safely null");
 // which method are we really talking about?
 if (target_jh == NULL) { THROW(vmSymbols::java_lang_InternalError()); }
-oop target_oop = JNIHandles::resolve_non_null(target_jh);
+Handle target(THREAD, JNIHandles::resolve_non_null(target_jh));
-if (java_lang_invoke_MemberName::is_instance(target_oop) &&
+if (java_lang_invoke_MemberName::is_instance(target()) &&
-java_lang_invoke_MemberName::vmindex(target_oop) == VM_INDEX_UNINITIALIZED) {
+java_lang_invoke_MemberName::vmindex(target()) == VM_INDEX_UNINITIALIZED) {
-Handle mname(THREAD, target_oop);
+MethodHandles::resolve_MemberName(target, CHECK);
-MethodHandles::resolve_MemberName(mname, CHECK);
+}
-target_oop = mname(); // in case of GC
-}
+KlassHandle receiver_limit; int decode_flags = 0;
+methodHandle m = MethodHandles::decode_method(target(), receiver_limit, decode_flags);
-int decode_flags = 0; klassOop receiver_limit = NULL;
-methodHandle m(THREAD,
-MethodHandles::decode_method(target_oop,
-receiver_limit, decode_flags));
 if (m.is_null()) { THROW_MSG(vmSymbols::java_lang_InternalError(), "no such method"); }
 // The trusted Java code that calls this method should already have performed
 // access checks on behalf of the given caller.  But, we can verify this.
 if (VerifyMethodHandles && caller_jh != NULL) {
 if (!java_lang_invoke_MethodHandle::is_instance(target())) {
 // Target object is a reflective method.  (%%% Do we need this alternate path?)
 Untested("init_BMH of non-MH");
 if (argnum != 0) { THROW(vmSymbols::java_lang_InternalError()); }
-int decode_flags = 0; klassOop receiver_limit_oop = NULL;
+KlassHandle receiver_limit; int decode_flags = 0;
-methodHandle m(THREAD,
+methodHandle m = MethodHandles::decode_method(target(), receiver_limit, decode_flags);
-MethodHandles::decode_method(target(),
-receiver_limit_oop,
-decode_flags));
-KlassHandle receiver_limit(THREAD, receiver_limit_oop);
 MethodHandles::init_BoundMethodHandle_with_receiver(mh, m,
 receiver_limit,
 decode_flags,
 CHECK);
 return;
 JVM_ENTRY(jint, MHN_getNamedCon(JNIEnv *env, jobject igcls, jint which, jobjectArray box_jh)) {
 #ifndef PRODUCT
 if (which >= 0 && which < con_value_count) {
 int con = con_values[which];
-objArrayOop box = (objArrayOop) JNIHandles::resolve(box_jh);
+objArrayHandle box(THREAD, (objArrayOop) JNIHandles::resolve(box_jh));
-if (box != NULL && box->klass() == Universe::objectArrayKlassObj() && box->length() > 0) {
+if (box.not_null() && box->klass() == Universe::objectArrayKlassObj() && box->length() > 0) {
 const char* str = &con_names[0];
 for (int i = 0; i < which; i++)
 str += strlen(str) + 1;   // skip name and null
-oop name = java_lang_String::create_oop_from_str(str, CHECK_0);
+oop name = java_lang_String::create_oop_from_str(str, CHECK_0);  // possible safepoint
 box->obj_at_put(0, name);
 }
 return con;
 }
 #endif
 //          int matchFlags, Class<?> caller, int skip, MemberName[] results);
 JVM_ENTRY(jint, MHN_getMembers(JNIEnv *env, jobject igcls,
 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;
-klassOop k_oop = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz_jh));
+KlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz_jh)));
-objArrayOop results = (objArrayOop) JNIHandles::resolve(results_jh);
+objArrayHandle results(THREAD, (objArrayOop) JNIHandles::resolve(results_jh));
-if (results == NULL || !results->is_objArray())       return -1;
+if (results.is_null() || !results->is_objArray())  return -1;
 TempNewSymbol name = NULL;
 TempNewSymbol sig = NULL;
 if (name_jh != NULL) {
 name = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(name_jh));
 if (sig_jh != NULL) {
 sig = java_lang_String::as_symbol_or_null(JNIHandles::resolve_non_null(sig_jh));
 if (sig == NULL)  return 0; // a match is not possible
 }
-klassOop caller = NULL;
+KlassHandle caller;
 if (caller_jh != NULL) {
 oop caller_oop = JNIHandles::resolve_non_null(caller_jh);
 if (!java_lang_Class::is_instance(caller_oop))  return -1;
-caller = java_lang_Class::as_klassOop(caller_oop);
+caller = KlassHandle(THREAD, java_lang_Class::as_klassOop(caller_oop));
 }
-if (name != NULL && sig != NULL && results != NULL) {
+if (name != NULL && sig != NULL && results.not_null()) {
 // try a direct resolve
 // %%% TO DO
 }
-int res = MethodHandles::find_MemberNames(k_oop, name, sig, mflags,
+int res = MethodHandles::find_MemberNames(k(), name, sig, mflags,
-caller, skip, results);
+caller(), skip, results());
 // TO DO: expand at least some of the MemberNames, to avoid massive callbacks
 return res;
 }
 JVM_END

changeset 9323	20cc2230dc8a
parent 9134	189a8c094016
child 9630	d6419e4395e3