jdk-sandbox: comparison src/hotspot/share/interpreter/linkResolver.cpp

equal deleted inserted replaced

-:57ad70bcf06c
+:15936b142f86
 if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
 resolved_klass = resolved_method_holder;
 }
 _resolved_klass  = resolved_klass;
 _selected_klass  = resolved_klass;
-_resolved_method = resolved_method;
+_resolved_method = methodHandle(THREAD, resolved_method);
-_selected_method = resolved_method;
+_selected_method = methodHandle(THREAD, resolved_method);
 // classify:
 CallKind kind = CallInfo::unknown_kind;
 int index = resolved_method->vtable_index();
 if (resolved_method->can_be_statically_bound()) {
 kind = CallInfo::direct_call;
 // Could be an Object method inherited into an interface, but still a vtable call.
 kind = CallInfo::vtable_call;
 } else if (!resolved_klass->is_interface()) {
 // A default or miranda method.  Compute the vtable index.
 index = LinkResolver::vtable_index_of_interface_method(resolved_klass,
-resolved_method);
+_resolved_method);
 assert(index >= 0 , "we should have valid vtable index at this point");
 kind = CallInfo::vtable_call;
 } else if (resolved_method->has_vtable_index()) {
 // Can occur if an interface redeclares a method of Object.
 DEBUG_ONLY(verify());
 }
 void CallInfo::set_resolved_method_name(TRAPS) {
-Method* m = _resolved_method();
+assert(_resolved_method() != NULL, "Should already have a Method*");
-assert(m != NULL, "Should already have a Method*");
+oop rmethod_name = java_lang_invoke_ResolvedMethodName::find_resolved_method(_resolved_method, CHECK);
-oop rmethod_name = java_lang_invoke_ResolvedMethodName::find_resolved_method(m, CHECK);
 _resolved_method_name = Handle(THREAD, rmethod_name);
 }
 #ifdef ASSERT
 void CallInfo::verify() {
 return result;
 }
 // returns first instance method
 // Looks up method in classes, then looks up local default methods
-methodHandle LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
+Method* LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
 Symbol* name,
 Symbol* signature,
 Klass::PrivateLookupMode private_mode, TRAPS) {
 Method* result = klass->uncached_lookup_method(name, signature, Klass::find_overpass, private_mode);
 while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {
 Klass* super_klass = result->method_holder()->super();
 result = super_klass->uncached_lookup_method(name, signature, Klass::find_overpass, private_mode);
 }
 if (klass->is_array_klass()) {
 // Only consider klass and super klass for arrays
-return methodHandle(THREAD, result);
+return result;
 }
 if (result == NULL) {
 Array<Method*>* default_methods = InstanceKlass::cast(klass)->default_methods();
 if (default_methods != NULL) {
 result = InstanceKlass::find_method(default_methods, name, signature);
 assert(result == NULL || !result->is_static(), "static defaults not allowed");
 }
 }
-return methodHandle(THREAD, result);
+return result;
 }
 int LinkResolver::vtable_index_of_interface_method(Klass* klass,
 const methodHandle& resolved_method) {
 // interfaces.  Function lookup_method_in_klasses() already looked for
 // the method in the default methods table.
 return ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::skip_defaults);
 }
-methodHandle LinkResolver::lookup_polymorphic_method(
+Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
-const LinkInfo& link_info,
+Handle *appendix_result_or_null,
-Handle *appendix_result_or_null,
+TRAPS) {
-TRAPS) {
 Klass* klass = link_info.resolved_klass();
 Symbol* name = link_info.name();
 Symbol* full_signature = link_info.signature();
 vmIntrinsics::ID iid = MethodHandles::signature_polymorphic_name_id(name);
 tty->print_cr("lookup_polymorphic_method %s %s => basic %s",
 name->as_C_string(),
 full_signature->as_C_string(),
 basic_signature->as_C_string());
 }
-methodHandle result = SystemDictionary::find_method_handle_intrinsic(iid,
+Method* result = SystemDictionary::find_method_handle_intrinsic(iid,
 basic_signature,
 CHECK_NULL);
-if (result.not_null()) {
+if (result != NULL) {
 assert(result->is_method_handle_intrinsic(), "MH.invokeBasic or MH.linkTo* intrinsic");
 assert(result->intrinsic_id() != vmIntrinsics::_invokeGeneric, "wrong place to find this");
 assert(basic_signature == result->signature(), "predict the result signature");
 if (TraceMethodHandles) {
 ttyLocker ttyl;
 }
 }
 Handle appendix;
 Handle method_type;
-methodHandle result = SystemDictionary::find_method_handle_invoker(
+Method* result = SystemDictionary::find_method_handle_invoker(
 klass,
 name,
 full_signature,
 link_info.current_klass(),
 &appendix,
 result->print_on(tty);
 tty->print("  lookup_polymorphic_method => appendix = ");
 if (appendix.is_null())  tty->print_cr("(none)");
 else                     appendix->print_on(tty);
 }
-if (result.not_null()) {
+if (result != NULL) {
 #ifdef ASSERT
 ResourceMark rm(THREAD);
 TempNewSymbol basic_signature =
 MethodHandles::lookup_basic_type_signature(full_signature, CHECK_NULL);
 );
 return;
 }
 }
-methodHandle LinkResolver::resolve_method_statically(Bytecodes::Code code,
+Method* LinkResolver::resolve_method_statically(Bytecodes::Code code,
 const constantPoolHandle& pool, int index, TRAPS) {
 // This method is used only
 // (1) in C2 from InlineTree::ok_to_inline (via ciMethod::check_call),
 // and
 // (2) in Bytecode_invoke::static_target
 // It appears to fail when applied to an invokeinterface call site.
 if (pool->has_preresolution()
 || (resolved_klass == SystemDictionary::MethodHandle_klass() &&
 MethodHandles::is_signature_polymorphic_name(resolved_klass, link_info.name()))) {
 Method* result = ConstantPool::method_at_if_loaded(pool, index);
 if (result != NULL) {
-return methodHandle(THREAD, result);
+return result;
 }
 }
 if (code == Bytecodes::_invokeinterface) {
 return resolve_interface_method(link_info, code, THREAD);
 sel_klass->class_in_module_of_loader(false, true));
 THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
 }
 }
-methodHandle LinkResolver::resolve_method(const LinkInfo& link_info,
+Method* LinkResolver::resolve_method(const LinkInfo& link_info,
 Bytecodes::Code code, TRAPS) {
 Handle nested_exception;
 Klass* resolved_klass = link_info.resolved_klass();
 // 1. For invokevirtual, cannot call an interface method
 if (resolved_method.is_null() && !resolved_klass->is_array_klass()) { // not found in the class hierarchy
 resolved_method = methodHandle(THREAD, lookup_method_in_interfaces(link_info));
 if (resolved_method.is_null()) {
 // JSR 292:  see if this is an implicitly generated method MethodHandle.linkToVirtual(*...), etc
-resolved_method = lookup_polymorphic_method(link_info, (Handle*)NULL, THREAD);
+Method* method = lookup_polymorphic_method(link_info, (Handle*)NULL, THREAD);
+resolved_method = methodHandle(THREAD, method);
 if (HAS_PENDING_EXCEPTION) {
 nested_exception = Handle(THREAD, PENDING_EXCEPTION);
 CLEAR_PENDING_EXCEPTION;
 }
 }
 // check loader constraints
 check_method_loader_constraints(link_info, resolved_method, "method", CHECK_NULL);
 }
-return resolved_method;
+return resolved_method();
 }
 static void trace_method_resolution(const char* prefix,
 Klass* klass,
 Klass* resolved_klass,
-const methodHandle& method,
+Method* method,
 bool logitables,
 int index = -1) {
 #ifndef PRODUCT
 ResourceMark rm;
 Log(itables) logi;
 st->cr();
 #endif // PRODUCT
 }
 // Do linktime resolution of a method in the interface within the context of the specied bytecode.
-methodHandle LinkResolver::resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS) {
+Method* LinkResolver::resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS) {
 Klass* resolved_klass = link_info.resolved_klass();
 // check if klass is interface
 if (!resolved_klass->is_interface()) {
 if (log_develop_is_enabled(Trace, itables)) {
 char buf[200];
 jio_snprintf(buf, sizeof(buf), "%s resolved interface method: caller-class:",
 Bytecodes::name(code));
-trace_method_resolution(buf, link_info.current_klass(), resolved_klass,
+trace_method_resolution(buf, link_info.current_klass(), resolved_klass, resolved_method(), true);
-resolved_method, true);
+}
-}
+return resolved_method();
-return resolved_method;
 }
 //------------------------------------------------------------------------------------------------------------------------
 // Field resolution
 current_klass->external_name());
 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
 }
 if (fd.constants()->pool_holder()->major_version() >= 53) {
-methodHandle m = link_info.current_method();
+Method* m = link_info.current_method();
-assert(!m.is_null(), "information about the current method must be available for 'put' bytecodes");
+assert(m != NULL, "information about the current method must be available for 'put' bytecodes");
 bool is_initialized_static_final_update = (byte == Bytecodes::_putstatic &&
 fd.is_static() &&
-!m()->is_static_initializer());
+!m->is_static_initializer());
 bool is_initialized_instance_final_update = ((byte == Bytecodes::_putfield || byte == Bytecodes::_nofast_putfield) &&
 !fd.is_static() &&
 !m->is_object_initializer());
 if (is_initialized_static_final_update || is_initialized_instance_final_update) {
 ss.print("Update to %s final field %s.%s attempted from a different method (%s) than the initializer method %s ",
 is_static ? "static" : "non-static", resolved_klass->external_name(), fd.name()->as_C_string(),
-m()->name()->as_C_string(),
+m->name()->as_C_string(),
 is_static ? "<clinit>" : "<init>");
 THROW_MSG(vmSymbols::java_lang_IllegalAccessError(), ss.as_string());
 }
 }
 }
 void LinkResolver::resolve_static_call(CallInfo& result,
 const LinkInfo& link_info,
 bool initialize_class, TRAPS) {
-methodHandle resolved_method = linktime_resolve_static_method(link_info, CHECK);
+Method* resolved_method = linktime_resolve_static_method(link_info, CHECK);
 // The resolved class can change as a result of this resolution.
 Klass* resolved_klass = resolved_method->method_holder();
 // Initialize klass (this should only happen if everything is ok)
 link_info.check_access() ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
 resolved_method = linktime_resolve_static_method(new_info, CHECK);
 }
 // setup result
-result.set_static(resolved_klass, resolved_method, CHECK);
+result.set_static(resolved_klass, methodHandle(THREAD, resolved_method), CHECK);
 }
 // throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
+Method* LinkResolver::linktime_resolve_static_method(const LinkInfo& link_info, TRAPS) {
 Klass* resolved_klass = link_info.resolved_klass();
-methodHandle resolved_method;
+Method* resolved_method;
 if (!resolved_klass->is_interface()) {
 resolved_method = resolve_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
 } else {
 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokestatic, CHECK_NULL);
 }
 // check if static
 if (!resolved_method->is_static()) {
 ResourceMark rm(THREAD);
 stringStream ss;
 ss.print("Expected static method '");
-resolved_method()->print_external_name(&ss);
+resolved_method->print_external_name(&ss);
 ss.print("'");
 THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
 }
 return resolved_method;
 }
 void LinkResolver::resolve_special_call(CallInfo& result,
 Handle recv,
 const LinkInfo& link_info,
 TRAPS) {
-methodHandle resolved_method = linktime_resolve_special_method(link_info, CHECK);
+Method* resolved_method = linktime_resolve_special_method(link_info, CHECK);
-runtime_resolve_special_method(result, link_info, resolved_method, recv, CHECK);
+runtime_resolve_special_method(result, link_info, methodHandle(THREAD, resolved_method), recv, CHECK);
 }
 // throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info,
+Method* LinkResolver::linktime_resolve_special_method(const LinkInfo& link_info, TRAPS) {
-TRAPS) {
 // Invokespecial is called for multiple special reasons:
 // <init>
 // local private method invocation, for classes and interfaces
 // superclass.method, which can also resolve to a default method
 // and the selected method is recalculated relative to the direct superclass
 // superinterface.method, which explicitly does not check shadowing
 Klass* resolved_klass = link_info.resolved_klass();
-methodHandle resolved_method;
+Method* resolved_method;
 if (!resolved_klass->is_interface()) {
 resolved_method = resolve_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
 } else {
 resolved_method = resolve_interface_method(link_info, Bytecodes::_invokespecial, CHECK_NULL);
 // in super interfaces.
 if (current_klass->is_subclass_of(resolved_klass) &&
 current_klass != resolved_klass) {
 // Lookup super method
 Klass* super_klass = current_klass->super();
-sel_method = lookup_instance_method_in_klasses(super_klass,
+Method* instance_method = lookup_instance_method_in_klasses(super_klass,
 resolved_method->name(),
 resolved_method->signature(),
 Klass::find_private, CHECK);
+sel_method = methodHandle(THREAD, instance_method);
 // check if found
 if (sel_method.is_null()) {
 ResourceMark rm(THREAD);
 stringStream ss;
 ss.print("'");
 THROW_MSG(vmSymbols::java_lang_AbstractMethodError(), ss.as_string());
 }
 if (log_develop_is_enabled(Trace, itables)) {
 trace_method_resolution("invokespecial selected method: resolved-class:",
-resolved_klass, resolved_klass, sel_method, true);
+resolved_klass, resolved_klass, sel_method(), true);
 }
 // setup result
 result.set_static(resolved_klass, sel_method, CHECK);
 }
 void LinkResolver::resolve_virtual_call(CallInfo& result, Handle recv, Klass* receiver_klass,
 const LinkInfo& link_info,
 bool check_null_and_abstract, TRAPS) {
-methodHandle resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
+Method* resolved_method = linktime_resolve_virtual_method(link_info, CHECK);
-runtime_resolve_virtual_method(result, resolved_method,
+runtime_resolve_virtual_method(result, methodHandle(THREAD, resolved_method),
 link_info.resolved_klass(),
 recv, receiver_klass,
 check_null_and_abstract, CHECK);
 }
 // throws linktime exceptions
-methodHandle LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
+Method* LinkResolver::linktime_resolve_virtual_method(const LinkInfo& link_info,
 TRAPS) {
 // normal method resolution
-methodHandle resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
+Method* resolved_method = resolve_method(link_info, Bytecodes::_invokevirtual, CHECK_NULL);
 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
 // check if private interface method
 throw_abstract_method_error(resolved_method, selected_method, recv_klass, CHECK);
 }
 if (log_develop_is_enabled(Trace, vtables)) {
 trace_method_resolution("invokevirtual selected method: receiver-class:",
-recv_klass, resolved_klass, selected_method,
+recv_klass, resolved_klass, selected_method(),
 false, vtable_index);
 }
 // setup result
 result.set_virtual(resolved_klass, recv_klass, resolved_method, selected_method, vtable_index, CHECK);
 }
 void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
 const LinkInfo& link_info,
 bool check_null_and_abstract, TRAPS) {
 // throws linktime exceptions
-methodHandle resolved_method = linktime_resolve_interface_method(link_info, CHECK);
+Method* resolved_method = linktime_resolve_interface_method(link_info, CHECK);
-runtime_resolve_interface_method(result, resolved_method,link_info.resolved_klass(),
+methodHandle mh(THREAD, resolved_method);
+runtime_resolve_interface_method(result, mh, link_info.resolved_klass(),
 recv, recv_klass, check_null_and_abstract, CHECK);
 }
-methodHandle LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
+Method* LinkResolver::linktime_resolve_interface_method(const LinkInfo& link_info,
 TRAPS) {
 // normal interface method resolution
-methodHandle resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
+Method* resolved_method = resolve_interface_method(link_info, Bytecodes::_invokeinterface, CHECK_NULL);
 assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
 assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
 return resolved_method;
 }
 if (!resolved_method()->is_private()) {
 // do lookup based on receiver klass
 // This search must match the linktime preparation search for itable initialization
 // to correctly enforce loader constraints for interface method inheritance.
 // Private methods are skipped as the resolved method was not private.
-selected_method = lookup_instance_method_in_klasses(recv_klass,
+Method* method = lookup_instance_method_in_klasses(recv_klass,
 resolved_method->name(),
 resolved_method->signature(),
 Klass::skip_private, CHECK);
+selected_method = methodHandle(THREAD, method);
 if (selected_method.is_null() && !check_null_and_abstract) {
 // In theory this is a harmless placeholder value, but
 // in practice leaving in null affects the nsk default method tests.
 // This needs further study.
 }
 }
 if (log_develop_is_enabled(Trace, itables)) {
 trace_method_resolution("invokeinterface selected method: receiver-class:",
-recv_klass, resolved_klass, selected_method, true);
+recv_klass, resolved_klass, selected_method(), true);
 }
 // setup result
 if (resolved_method->has_vtable_index()) {
 int vtable_index = resolved_method->vtable_index();
 log_develop_trace(itables)("  -- vtable index: %d", vtable_index);
 result.set_virtual(resolved_klass, resolved_klass, resolved_method, resolved_method, index, CHECK);
 }
 }
-methodHandle LinkResolver::linktime_resolve_interface_method_or_null(
+Method* LinkResolver::linktime_resolve_interface_method_or_null(
 const LinkInfo& link_info) {
 EXCEPTION_MARK;
-methodHandle method_result = linktime_resolve_interface_method(link_info, THREAD);
+Method* method_result = linktime_resolve_interface_method(link_info, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 } else {
 return method_result;
 }
 }
-methodHandle LinkResolver::linktime_resolve_virtual_method_or_null(
+Method* LinkResolver::linktime_resolve_virtual_method_or_null(
 const LinkInfo& link_info) {
 EXCEPTION_MARK;
-methodHandle method_result = linktime_resolve_virtual_method(link_info, THREAD);
+Method* method_result = linktime_resolve_virtual_method(link_info, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 } else {
 return method_result;
 }
 }
-methodHandle LinkResolver::resolve_virtual_call_or_null(
+Method* LinkResolver::resolve_virtual_call_or_null(
 Klass* receiver_klass,
 const LinkInfo& link_info) {
 EXCEPTION_MARK;
 CallInfo info;
 resolve_virtual_call(info, Handle(), receiver_klass, link_info, false, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 }
 return info.selected_method();
 }
-methodHandle LinkResolver::resolve_interface_call_or_null(
+Method* LinkResolver::resolve_interface_call_or_null(
 Klass* receiver_klass,
 const LinkInfo& link_info) {
 EXCEPTION_MARK;
 CallInfo info;
 resolve_interface_call(info, Handle(), receiver_klass, link_info, false, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 }
 return info.selected_method();
 }
 int LinkResolver::resolve_virtual_vtable_index(Klass* receiver_klass,
 return Method::invalid_vtable_index;
 }
 return info.vtable_index();
 }
-methodHandle LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
+Method* LinkResolver::resolve_static_call_or_null(const LinkInfo& link_info) {
 EXCEPTION_MARK;
 CallInfo info;
 resolve_static_call(info, link_info, /*initialize_class*/false, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 }
 return info.selected_method();
 }
-methodHandle LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
+Method* LinkResolver::resolve_special_call_or_null(const LinkInfo& link_info) {
 EXCEPTION_MARK;
 CallInfo info;
 resolve_special_call(info, Handle(), link_info, THREAD);
 if (HAS_PENDING_EXCEPTION) {
 CLEAR_PENDING_EXCEPTION;
-return methodHandle();
+return NULL;
 }
 return info.selected_method();
 }
 Klass* resolved_klass = link_info.resolved_klass();
 assert(resolved_klass == SystemDictionary::MethodHandle_klass() ||
 resolved_klass == SystemDictionary::VarHandle_klass(), "");
 assert(MethodHandles::is_signature_polymorphic_name(link_info.name()), "");
 Handle       resolved_appendix;
-methodHandle resolved_method = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
+Method* resolved_method = lookup_polymorphic_method(link_info, &resolved_appendix, CHECK);
-result.set_handle(resolved_klass, resolved_method, resolved_appendix, CHECK);
+result.set_handle(resolved_klass, methodHandle(THREAD, resolved_method), resolved_appendix, CHECK);
 }
 void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHandle& pool, int indy_index, TRAPS) {
 ConstantPoolCacheEntry* cpce = pool->invokedynamic_cp_cache_entry_at(indy_index);
 int pool_index = cpce->constant_pool_index();

changeset 59056	15936b142f86
parent 58545	725244418646