truffle: src/share/vm/classfile/systemDictionary.cpp comparison

comparison src/share/vm/classfile/systemDictionary.cpp @ 6266:1d7922586cf6

7023639: JSR 292 method handle invocation needs a fast path for compiled code 6984705: JSR 292 method handle creation should not go through JNI Summary: remove assembly code for JDK 7 chained method handles Reviewed-by: jrose, twisti, kvn, mhaupt Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>

author	twisti
date	Tue, 24 Jul 2012 10:51:00 -0700
parents	e74da3c2b827
children	957c266d8bc5 da91efe96a93

comparison

equal deleted inserted replaced

-:aba91a731143
+:1d7922586cf6
 #include "classfile/loaderConstraints.hpp"
 #include "classfile/placeholders.hpp"
 #include "classfile/resolutionErrors.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "classfile/vmSymbols.hpp"
+#include "compiler/compileBroker.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/interpreter.hpp"
 #include "memory/gcLocker.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/instanceKlass.hpp"
 // Forwards to resolve_instance_class_or_null
 klassOop SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) {
-assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");
+assert(!THREAD->is_Compiler_thread(),
+err_msg("can not load classes with compiler thread: class=%s, classloader=%s",
+class_name->as_C_string(),
+class_loader.is_null() ? "null" : class_loader->klass()->klass_part()->name()->as_C_string()));
 if (FieldType::is_array(class_name)) {
 return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
 } else if (FieldType::is_obj(class_name)) {
 ResourceMark rm(THREAD);
 // Ignore wrapping L and ;.
 }
 return NULL;
 }
-methodOop SystemDictionary::find_method_handle_invoke(Symbol* name,
+methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid,
 Symbol* signature,
-KlassHandle accessing_klass,
+TRAPS) {
-TRAPS) {
+methodHandle empty;
-if (!EnableInvokeDynamic)  return NULL;
+assert(EnableInvokeDynamic, "");
-vmSymbols::SID name_id = vmSymbols::find_sid(name);
+assert(MethodHandles::is_signature_polymorphic(iid) &&
-assert(name_id != vmSymbols::NO_SID, "must be a known name");
+MethodHandles::is_signature_polymorphic_intrinsic(iid) &&
-unsigned int hash  = invoke_method_table()->compute_hash(signature, name_id);
+iid != vmIntrinsics::_invokeGeneric,
+err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid)));
+unsigned int hash  = invoke_method_table()->compute_hash(signature, iid);
 int          index = invoke_method_table()->hash_to_index(hash);
-SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, name_id);
+SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, iid);
-methodHandle non_cached_result;
+methodHandle m;
 if (spe == NULL || spe->property_oop() == NULL) {
 spe = NULL;
 // Must create lots of stuff here, but outside of the SystemDictionary lock.
-if (THREAD->is_Compiler_thread())
+m = methodOopDesc::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
-return NULL;              // do not attempt from within compiler
+CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier,
-bool for_invokeGeneric = (name_id != vmSymbols::VM_SYMBOL_ENUM_NAME(invokeExact_name));
+methodHandle(), CompileThreshold, "MH", CHECK_(empty));
-bool found_on_bcp = false;
-Handle mt = find_method_handle_type(signature, accessing_klass,
-for_invokeGeneric,
-found_on_bcp, CHECK_NULL);
-KlassHandle  mh_klass = SystemDictionaryHandles::MethodHandle_klass();
-methodHandle m = methodOopDesc::make_invoke_method(mh_klass, name, signature,
-mt, CHECK_NULL);
 // Now grab the lock.  We might have to throw away the new method,
 // if a racing thread has managed to install one at the same time.
-if (found_on_bcp) {
+{
-MutexLocker ml(SystemDictionary_lock, Thread::current());
+MutexLocker ml(SystemDictionary_lock, THREAD);
-spe = invoke_method_table()->find_entry(index, hash, signature, name_id);
+spe = invoke_method_table()->find_entry(index, hash, signature, iid);
 if (spe == NULL)
-spe = invoke_method_table()->add_entry(index, hash, signature, name_id);
+spe = invoke_method_table()->add_entry(index, hash, signature, iid);
-if (spe->property_oop() == NULL) {
+if (spe->property_oop() == NULL)
 spe->set_property_oop(m());
-// Link m to his method type, if it is suitably generic.
+}
-oop mtform = java_lang_invoke_MethodType::form(mt());
+}
-if (mtform != NULL && mt() == java_lang_invoke_MethodTypeForm::erasedType(mtform)
-// vmlayout must be an invokeExact:
+assert(spe != NULL && spe->property_oop() != NULL, "");
-&& name_id == vmSymbols::VM_SYMBOL_ENUM_NAME(invokeExact_name)
+m = methodOop(spe->property_oop());
-&& java_lang_invoke_MethodTypeForm::vmlayout_offset_in_bytes() > 0) {
+assert(m->is_method(), "");
-java_lang_invoke_MethodTypeForm::init_vmlayout(mtform, m());
-}
+return m;
+}
+// Helper for unpacking the return value from linkMethod and linkCallSite.
+static methodHandle unpack_method_and_appendix(Handle mname,
+objArrayHandle appendix_box,
+Handle* appendix_result,
+TRAPS) {
+methodHandle empty;
+if (mname.not_null()) {
+oop vmtarget = java_lang_invoke_MemberName::vmtarget(mname());
+if (vmtarget != NULL && vmtarget->is_method()) {
+methodOop m = methodOop(vmtarget);
+oop appendix = appendix_box->obj_at(0);
+if (TraceMethodHandles) {
+#ifndef PRODUCT
+tty->print("Linked method="INTPTR_FORMAT": ", m);
+m->print();
+if (appendix != NULL) { tty->print("appendix = "); appendix->print(); }
+tty->cr();
+#endif //PRODUCT
 }
-} else {
+(*appendix_result) = Handle(THREAD, appendix);
-non_cached_result = m;
+return methodHandle(THREAD, m);
 }
 }
-if (spe != NULL && spe->property_oop() != NULL) {
+THROW_MSG_(vmSymbols::java_lang_LinkageError(), "bad value from MethodHandleNatives", empty);
-assert(spe->property_oop()->is_method(), "");
+return empty;
-return (methodOop) spe->property_oop();
+}
-} else {
-return non_cached_result();
+methodHandle SystemDictionary::find_method_handle_invoker(Symbol* name,
-}
+Symbol* signature,
-}
+KlassHandle accessing_klass,
+Handle* appendix_result,
+TRAPS) {
+methodHandle empty;
+assert(EnableInvokeDynamic, "");
+assert(!THREAD->is_Compiler_thread(), "");
+Handle method_type =
+SystemDictionary::find_method_handle_type(signature, accessing_klass, CHECK_(empty));
+if (false) {  // FIXME: Decide if the Java upcall should resolve signatures.
+method_type = java_lang_String::create_from_symbol(signature, CHECK_(empty));
+}
+KlassHandle  mh_klass = SystemDictionaryHandles::MethodHandle_klass();
+int ref_kind = JVM_REF_invokeVirtual;
+Handle name_str = StringTable::intern(name, CHECK_(empty));
+objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
+assert(appendix_box->obj_at(0) == NULL, "");
+// call java.lang.invoke.MethodHandleNatives::linkMethod(... String, MethodType) -> MemberName
+JavaCallArguments args;
+args.push_oop(accessing_klass()->java_mirror());
+args.push_int(ref_kind);
+args.push_oop(mh_klass()->java_mirror());
+args.push_oop(name_str());
+args.push_oop(method_type());
+args.push_oop(appendix_box());
+JavaValue result(T_OBJECT);
+JavaCalls::call_static(&result,
+SystemDictionary::MethodHandleNatives_klass(),
+vmSymbols::linkMethod_name(),
+vmSymbols::linkMethod_signature(),
+&args, CHECK_(empty));
+Handle mname(THREAD, (oop) result.get_jobject());
+return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD);
+}
 // Ask Java code to find or construct a java.lang.invoke.MethodType for the given
 // signature, as interpreted relative to the given class loader.
 // Because of class loader constraints, all method handle usage must be
 // consistent with this loader.
 Handle SystemDictionary::find_method_handle_type(Symbol* signature,
 KlassHandle accessing_klass,
-bool for_invokeGeneric,
-bool& return_bcp_flag,
 TRAPS) {
+Handle empty;
+vmIntrinsics::ID null_iid = vmIntrinsics::_none;  // distinct from all method handle invoker intrinsics
+unsigned int hash  = invoke_method_table()->compute_hash(signature, null_iid);
+int          index = invoke_method_table()->hash_to_index(hash);
+SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
+if (spe != NULL && spe->property_oop() != NULL) {
+assert(java_lang_invoke_MethodType::is_instance(spe->property_oop()), "");
+return Handle(THREAD, spe->property_oop());
+} else if (THREAD->is_Compiler_thread()) {
+warning("SystemDictionary::find_method_handle_type called from compiler thread");  // FIXME
+return Handle();  // do not attempt from within compiler, unless it was cached
+}
 Handle class_loader, protection_domain;
 bool is_on_bcp = true;  // keep this true as long as we can materialize from the boot classloader
-Handle empty;
 int npts = ArgumentCount(signature).size();
 objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty));
 int arg = 0;
 Handle rt;                            // the return type from the signature
 ResourceMark rm(THREAD);
 for (SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 oop mirror = NULL;
 if (is_on_bcp) {
+// Note:  class_loader & protection_domain are both null at this point.
 mirror = ss.as_java_mirror(class_loader, protection_domain,
 SignatureStream::ReturnNull, CHECK_(empty));
 if (mirror == NULL) {
 // fall back from BCP to accessing_klass
 if (accessing_klass.not_null()) {
 }
 if (ss.at_return_type())
 rt = Handle(THREAD, mirror);
 else
 pts->obj_at_put(arg++, mirror);
 // Check accessibility.
 if (ss.is_object() && accessing_klass.not_null()) {
 klassOop sel_klass = java_lang_Class::as_klassOop(mirror);
+mirror = NULL;  // safety
 // Emulate constantPoolOopDesc::verify_constant_pool_resolve.
 if (Klass::cast(sel_klass)->oop_is_objArray())
 sel_klass = objArrayKlass::cast(sel_klass)->bottom_klass();
 if (Klass::cast(sel_klass)->oop_is_instance()) {
 KlassHandle sel_kh(THREAD, sel_klass);
 vmSymbols::findMethodHandleType_name(),
 vmSymbols::findMethodHandleType_signature(),
 &args, CHECK_(empty));
 Handle method_type(THREAD, (oop) result.get_jobject());
-if (for_invokeGeneric) {
+if (is_on_bcp) {
-// call java.lang.invoke.MethodHandleNatives::notifyGenericMethodType(MethodType) -> void
+// We can cache this MethodType inside the JVM.
-JavaCallArguments args(Handle(THREAD, method_type()));
+MutexLocker ml(SystemDictionary_lock, THREAD);
-JavaValue no_result(T_VOID);
+spe = invoke_method_table()->find_entry(index, hash, signature, null_iid);
-JavaCalls::call_static(&no_result,
+if (spe == NULL)
-SystemDictionary::MethodHandleNatives_klass(),
+spe = invoke_method_table()->add_entry(index, hash, signature, null_iid);
-vmSymbols::notifyGenericMethodType_name(),
+if (spe->property_oop() == NULL) {
-vmSymbols::notifyGenericMethodType_signature(),
+spe->set_property_oop(method_type());
-&args, THREAD);
+}
-if (HAS_PENDING_EXCEPTION) {
+}
-// If the notification fails, just kill it.
-CLEAR_PENDING_EXCEPTION;
+// report back to the caller with the MethodType
-}
-}
-// report back to the caller with the MethodType and the "on_bcp" flag
-return_bcp_flag = is_on_bcp;
 return method_type;
 }
 // Ask Java code to find or construct a method handle constant.
 Handle SystemDictionary::link_method_handle_constant(KlassHandle caller,
 TRAPS) {
 Handle empty;
 Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty));
 Handle type;
 if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') {
-bool ignore_is_on_bcp = false;
+type = find_method_handle_type(signature, caller, CHECK_(empty));
-type = find_method_handle_type(signature, caller, false, ignore_is_on_bcp, CHECK_(empty));
 } else {
 ResourceMark rm(THREAD);
 SignatureStream ss(signature, false);
 if (!ss.is_done()) {
 oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(),
 return Handle(THREAD, (oop) result.get_jobject());
 }
 // Ask Java code to find or construct a java.lang.invoke.CallSite for the given
 // name and signature, as interpreted relative to the given class loader.
-Handle SystemDictionary::make_dynamic_call_site(Handle bootstrap_method,
+methodHandle SystemDictionary::find_dynamic_call_site_invoker(KlassHandle caller,
-Symbol* name,
+Handle bootstrap_specifier,
-methodHandle signature_invoker,
+Symbol* name,
-Handle info,
+Symbol* type,
-methodHandle caller_method,
+Handle* appendix_result,
-int caller_bci,
+TRAPS) {
-TRAPS) {
+methodHandle empty;
-Handle empty;
+Handle bsm, info;
-guarantee(bootstrap_method.not_null() &&
+if (java_lang_invoke_MethodHandle::is_instance(bootstrap_specifier())) {
-java_lang_invoke_MethodHandle::is_instance(bootstrap_method()),
+bsm = bootstrap_specifier;
+} else {
+assert(bootstrap_specifier->is_objArray(), "");
+objArrayHandle args(THREAD, (objArrayOop) bootstrap_specifier());
+int len = args->length();
+assert(len >= 1, "");
+bsm = Handle(THREAD, args->obj_at(0));
+if (len > 1) {
+objArrayOop args1 = oopFactory::new_objArray(SystemDictionary::Object_klass(), len-1, CHECK_(empty));
+for (int i = 1; i < len; i++)
+args1->obj_at_put(i-1, args->obj_at(i));
+info = Handle(THREAD, args1);
+}
+}
+guarantee(java_lang_invoke_MethodHandle::is_instance(bsm()),
 "caller must supply a valid BSM");
-Handle caller_mname = MethodHandles::new_MemberName(CHECK_(empty));
+Handle method_name = java_lang_String::create_from_symbol(name, CHECK_(empty));
-MethodHandles::init_MemberName(caller_mname(), caller_method());
+Handle method_type = find_method_handle_type(type, caller, CHECK_(empty));
-// call java.lang.invoke.MethodHandleNatives::makeDynamicCallSite(bootm, name, mtype, info, caller_mname, caller_pos)
+objArrayHandle appendix_box = oopFactory::new_objArray(SystemDictionary::Object_klass(), 1, CHECK_(empty));
-oop name_str_oop = StringTable::intern(name, CHECK_(empty)); // not a handle!
+assert(appendix_box->obj_at(0) == NULL, "");
-JavaCallArguments args(Handle(THREAD, bootstrap_method()));
-args.push_oop(name_str_oop);
+// call java.lang.invoke.MethodHandleNatives::linkCallSite(caller, bsm, name, mtype, info, &appendix)
-args.push_oop(signature_invoker->method_handle_type());
+JavaCallArguments args;
+args.push_oop(caller->java_mirror());
+args.push_oop(bsm());
+args.push_oop(method_name());
+args.push_oop(method_type());
 args.push_oop(info());
-args.push_oop(caller_mname());
+args.push_oop(appendix_box);
-args.push_int(caller_bci);
 JavaValue result(T_OBJECT);
 JavaCalls::call_static(&result,
 SystemDictionary::MethodHandleNatives_klass(),
-vmSymbols::makeDynamicCallSite_name(),
+vmSymbols::linkCallSite_name(),
-vmSymbols::makeDynamicCallSite_signature(),
+vmSymbols::linkCallSite_signature(),
 &args, CHECK_(empty));
-oop call_site_oop = (oop) result.get_jobject();
+Handle mname(THREAD, (oop) result.get_jobject());
-assert(call_site_oop->is_oop()
+return unpack_method_and_appendix(mname, appendix_box, appendix_result, THREAD);
-/*&& java_lang_invoke_CallSite::is_instance(call_site_oop)*/, "must be sane");
-if (TraceMethodHandles) {
-#ifndef PRODUCT
-tty->print_cr("Linked invokedynamic bci=%d site="INTPTR_FORMAT":", caller_bci, call_site_oop);
-call_site_oop->print();
-tty->cr();
-#endif //PRODUCT
-}
-return call_site_oop;
-}
-Handle SystemDictionary::find_bootstrap_method(methodHandle caller_method, int caller_bci,
-int cache_index,
-Handle& argument_info_result,
-TRAPS) {
-Handle empty;
-constantPoolHandle pool;
-{
-klassOop caller = caller_method->method_holder();
-if (!Klass::cast(caller)->oop_is_instance())  return empty;
-pool = constantPoolHandle(THREAD, instanceKlass::cast(caller)->constants());
-}
-int constant_pool_index = pool->cache()->entry_at(cache_index)->constant_pool_index();
-constantTag tag = pool->tag_at(constant_pool_index);
-if (tag.is_invoke_dynamic()) {
-// JVM_CONSTANT_InvokeDynamic is an ordered pair of [bootm, name&type], plus optional arguments
-// The bootm, being a JVM_CONSTANT_MethodHandle, has its own cache entry.
-int bsm_index = pool->invoke_dynamic_bootstrap_method_ref_index_at(constant_pool_index);
-if (bsm_index != 0) {
-int bsm_index_in_cache = pool->cache()->entry_at(cache_index)->bootstrap_method_index_in_cache();
-DEBUG_ONLY(int bsm_index_2 = pool->cache()->entry_at(bsm_index_in_cache)->constant_pool_index());
-assert(bsm_index == bsm_index_2, "BSM constant lifted to cache");
-if (TraceMethodHandles) {
-tty->print_cr("resolving bootstrap method for "PTR_FORMAT" at %d at cache[%d]CP[%d]...",
-(intptr_t) caller_method(), caller_bci, cache_index, constant_pool_index);
-}
-oop bsm_oop = pool->resolve_cached_constant_at(bsm_index_in_cache, CHECK_(empty));
-if (TraceMethodHandles) {
-tty->print_cr("bootstrap method for "PTR_FORMAT" at %d retrieved as "PTR_FORMAT":",
-(intptr_t) caller_method(), caller_bci, (intptr_t) bsm_oop);
-}
-assert(bsm_oop->is_oop(), "must be sane");
-// caller must verify that it is of type MethodHandle
-Handle bsm(THREAD, bsm_oop);
-bsm_oop = NULL;  // safety
-// Extract the optional static arguments.
-Handle argument_info;  // either null, or one arg, or Object[]{arg...}
-int argc = pool->invoke_dynamic_argument_count_at(constant_pool_index);
-if (TraceInvokeDynamic) {
-tty->print_cr("find_bootstrap_method: [%d/%d] CONSTANT_InvokeDynamic: %d[%d]",
-constant_pool_index, cache_index, bsm_index, argc);
-}
-if (argc > 0) {
-objArrayHandle arg_array;
-if (argc > 1) {
-objArrayOop arg_array_oop = oopFactory::new_objArray(SystemDictionary::Object_klass(), argc, CHECK_(empty));
-arg_array = objArrayHandle(THREAD, arg_array_oop);
-argument_info = arg_array;
-}
-for (int arg_i = 0; arg_i < argc; arg_i++) {
-int arg_index = pool->invoke_dynamic_argument_index_at(constant_pool_index, arg_i);
-oop arg_oop = pool->resolve_possibly_cached_constant_at(arg_index, CHECK_(empty));
-if (arg_array.is_null()) {
-argument_info = Handle(THREAD, arg_oop);
-} else {
-arg_array->obj_at_put(arg_i, arg_oop);
-}
-}
-}
-argument_info_result = argument_info;  // return argument_info to caller
-return bsm;
-}
-} else {
-ShouldNotReachHere();  // verifier does not allow this
-}
-return empty;
 }
 // Since the identity hash code for symbols changes when the symbols are
 // moved from the regular perm gen (hash in the mark word) to the shared
 // spaces (hash is the address), the classes loaded into the dictionary

Mercurial > hg > truffle

comparison src/share/vm/classfile/systemDictionary.cpp @ 6266:1d7922586cf6