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

equal deleted inserted replaced

-:98dfaf0f9442
+:3d44a84147cc
 #if INCLUDE_JFR
 { CC"Java_jdk_jfr_internal_JVM_registerNatives",                 NULL, FN_PTR(jfr_register_natives)            },
 #endif
 };
-static address lookup_special_native(char* jni_name) {
+static address lookup_special_native(const char* jni_name) {
 int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
 for (int i = 0; i < count; i++) {
 // NB: To ignore the jni prefix and jni postfix strstr is used matching.
 if (strstr(jni_name, lookup_special_native_methods[i].name) != NULL) {
 return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
 return NULL;
 }
 address NativeLookup::lookup_style(const methodHandle& method, char* pure_name, const char* long_name, int args_size, bool os_style, bool& in_base_library, TRAPS) {
 address entry;
-// Compute complete JNI name for style
+const char* jni_name = compute_complete_jni_name(pure_name, long_name, args_size, os_style);
-stringStream st;
-if (os_style) os::print_jni_name_prefix_on(&st, args_size);
-st.print_raw(pure_name);
-st.print_raw(long_name);
-if (os_style) os::print_jni_name_suffix_on(&st, args_size);
-char* jni_name = st.as_string();
 // If the loader is null we have a system class, so we attempt a lookup in
 // the native Java library. This takes care of any bootstrapping problems.
 // Note: It is critical for bootstrapping that Java_java_lang_ClassLoader_00024NativeLibrary_find
 // gets found the first time around - otherwise an infinite loop can occure. This is
 }
 return entry;
 }
+const char* NativeLookup::compute_complete_jni_name(const char* pure_name, const char* long_name, int args_size, bool os_style) {
-address NativeLookup::lookup_critical_style(const methodHandle& method, char* pure_name, const char* long_name, int args_size, bool os_style) {
+stringStream st;
-if (!method->has_native_function()) {
+if (os_style) {
-return NULL;
+os::print_jni_name_prefix_on(&st, args_size);
 }
-address current_entry = method->native_function();
+st.print_raw(pure_name);
+st.print_raw(long_name);
-char dll_name[JVM_MAXPATHLEN];
+if (os_style) {
-int offset;
+os::print_jni_name_suffix_on(&st, args_size);
-if (os::dll_address_to_library_name(current_entry, dll_name, sizeof(dll_name), &offset)) {
+}
-char ebuf[32];
-void* dll = os::dll_load(dll_name, ebuf, sizeof(ebuf));
+return st.as_string();
-if (dll != NULL) {
+}
-// Compute complete JNI name for style
-stringStream st;
+address NativeLookup::lookup_critical_style(void* dll, const char* pure_name, const char* long_name, int args_size, bool os_style) {
-if (os_style) os::print_jni_name_prefix_on(&st, args_size);
+const char* jni_name = compute_complete_jni_name(pure_name, long_name, args_size, os_style);
-st.print_raw(pure_name);
+assert(dll != NULL, "dll must be loaded");
-st.print_raw(long_name);
+return (address)os::dll_lookup(dll, jni_name);
-if (os_style) os::print_jni_name_suffix_on(&st, args_size);
+}
-char* jni_name = st.as_string();
-address critical_entry = (address)os::dll_lookup(dll, jni_name);
-// Close the handle to avoid keeping the library alive if the native method holder is unloaded.
-// This is fine because the library is still kept alive by JNI (see JVM_LoadLibrary). As soon
-// as the holder class and the library are unloaded (see JVM_UnloadLibrary), the native wrapper
-// that calls 'critical_entry' becomes unreachable and is unloaded as well.
-os::dll_unload(dll);
-return critical_entry;
-}
-}
-return NULL;
-}
 // Check all the formats of native implementation name to see if there is one
 // for the specified method.
 address NativeLookup::lookup_entry(const methodHandle& method, bool& in_base_library, TRAPS) {
 address entry = NULL;
 // Only static non-synchronized methods are allowed
 return NULL;
 }
 ResourceMark rm;
-address entry = NULL;
 Symbol* signature = method->signature();
 for (int end = 0; end < signature->utf8_length(); end++) {
 if (signature->char_at(end) == 'L') {
 // Don't allow object types
 return NULL;
 }
 }
-// Compute critical name
-char* critical_name = critical_jni_name(method);
 // Compute argument size
 int args_size = method->size_of_parameters();
 for (SignatureStream ss(signature); !ss.at_return_type(); ss.next()) {
 if (ss.is_array()) {
 args_size += T_INT_size; // array length parameter
 }
 }
+void* dll = dll_load(method);
+address entry = NULL;
+if (dll != NULL) {
+entry = lookup_critical_style(dll, method, args_size);
+// Close the handle to avoid keeping the library alive if the native method holder is unloaded.
+// This is fine because the library is still kept alive by JNI (see JVM_LoadLibrary). As soon
+// as the holder class and the library are unloaded (see JVM_UnloadLibrary), the native wrapper
+// that calls 'critical_entry' becomes unreachable and is unloaded as well.
+os::dll_unload(dll);
+}
+return entry; // NULL indicates not found
+}
+void* NativeLookup::dll_load(const methodHandle& method) {
+if (method->has_native_function()) {
+address current_entry = method->native_function();
+char dll_name[JVM_MAXPATHLEN];
+int offset;
+if (os::dll_address_to_library_name(current_entry, dll_name, sizeof(dll_name), &offset)) {
+char ebuf[32];
+return os::dll_load(dll_name, ebuf, sizeof(ebuf));
+}
+}
+return NULL;
+}
+address NativeLookup::lookup_critical_style(void* dll, const methodHandle& method, int args_size) {
+address entry = NULL;
+const char* critical_name = critical_jni_name(method);
 // 1) Try JNI short style
-entry = lookup_critical_style(method, critical_name, "",        args_size, true);
+entry = lookup_critical_style(dll, critical_name, "",        args_size, true);
-if (entry != NULL) return entry;
+if (entry != NULL) {
+return entry;
-// Compute long name
+}
-char* long_name = long_jni_name(method);
+const char* long_name = long_jni_name(method);
 // 2) Try JNI long style
-entry = lookup_critical_style(method, critical_name, long_name, args_size, true);
+entry = lookup_critical_style(dll, critical_name, long_name, args_size, true);
-if (entry != NULL) return entry;
+if (entry != NULL) {
+return entry;
+}
 // 3) Try JNI short style without os prefix/suffix
-entry = lookup_critical_style(method, critical_name, "",        args_size, false);
+entry = lookup_critical_style(dll, critical_name, "",        args_size, false);
-if (entry != NULL) return entry;
+if (entry != NULL) {
+return entry;
+}
 // 4) Try JNI long style without os prefix/suffix
-entry = lookup_critical_style(method, critical_name, long_name, args_size, false);
+return lookup_critical_style(dll, critical_name, long_name, args_size, false);
-return entry; // NULL indicates not found
 }
 // Check if there are any JVM TI prefixes which have been applied to the native method name.
 // If any are found, remove them before attemping the look up of the
 // native implementation again.

changeset 57600	3d44a84147cc
parent 54847	59ea39bb2809
child 57710	05ff6e27de45