truffle: src/share/vm/prims/nativeLookup.cpp annotate

annotate src/share/vm/prims/nativeLookup.cpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	da91efe96a93
children	fb19af007ffc

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1142 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1142 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1142 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/oopFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/instanceKlass.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	33 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "oops/oop.inline.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	35 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "prims/jvm_misc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #include "prims/nativeLookup.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	38 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	39 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	40 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	41 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	42 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	43 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	44 # include "os_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	45 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	46 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	47 # include "os_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	48 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	49 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	50 # include "os_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	51 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	52 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	53 # include "os_bsd.inline.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	54 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	57 static void mangle_name_on(outputStream* st, Symbol* name, int begin, int end) {
0 a61af66fc99e Initial load duke parents: diff changeset	58 char* bytes = (char*)name->bytes() + begin;
a61af66fc99e Initial load duke parents: diff changeset	59 char* end_bytes = (char*)name->bytes() + end;
a61af66fc99e Initial load duke parents: diff changeset	60 while (bytes < end_bytes) {
a61af66fc99e Initial load duke parents: diff changeset	61 jchar c;
a61af66fc99e Initial load duke parents: diff changeset	62 bytes = UTF8::next(bytes, &c);
a61af66fc99e Initial load duke parents: diff changeset	63 if (c <= 0x7f && isalnum(c)) {
a61af66fc99e Initial load duke parents: diff changeset	64 st->put((char) c);
a61af66fc99e Initial load duke parents: diff changeset	65 } else {
a61af66fc99e Initial load duke parents: diff changeset	66 if (c == '_') st->print("_1");
a61af66fc99e Initial load duke parents: diff changeset	67 else if (c == '/') st->print("_");
a61af66fc99e Initial load duke parents: diff changeset	68 else if (c == ';') st->print("_2");
a61af66fc99e Initial load duke parents: diff changeset	69 else if (c == '[') st->print("_3");
a61af66fc99e Initial load duke parents: diff changeset	70 else st->print("_%.5x", c);
a61af66fc99e Initial load duke parents: diff changeset	71 }
a61af66fc99e Initial load duke parents: diff changeset	72 }
a61af66fc99e Initial load duke parents: diff changeset	73 }
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	76 static void mangle_name_on(outputStream* st, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	77 mangle_name_on(st, name, 0, name->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81 char* NativeLookup::pure_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	82 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	83 // Prefix
a61af66fc99e Initial load duke parents: diff changeset	84 st.print("Java_");
a61af66fc99e Initial load duke parents: diff changeset	85 // Klass name
a61af66fc99e Initial load duke parents: diff changeset	86 mangle_name_on(&st, method->klass_name());
a61af66fc99e Initial load duke parents: diff changeset	87 st.print("_");
a61af66fc99e Initial load duke parents: diff changeset	88 // Method name
a61af66fc99e Initial load duke parents: diff changeset	89 mangle_name_on(&st, method->name());
a61af66fc99e Initial load duke parents: diff changeset	90 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	91 }
a61af66fc99e Initial load duke parents: diff changeset	92
a61af66fc99e Initial load duke parents: diff changeset	93
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	94 char* NativeLookup::critical_jni_name(methodHandle method) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	95 stringStream st;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	96 // Prefix
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	97 st.print("JavaCritical_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	98 // Klass name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	99 mangle_name_on(&st, method->klass_name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	100 st.print("_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	101 // Method name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	102 mangle_name_on(&st, method->name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	103 return st.as_string();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	104 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	105
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	106
0 a61af66fc99e Initial load duke parents: diff changeset	107 char* NativeLookup::long_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	108 // Signature ignore the wrapping parenteses and the trailing return type
a61af66fc99e Initial load duke parents: diff changeset	109 stringStream st;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	110 Symbol* signature = method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	111 st.print("__");
a61af66fc99e Initial load duke parents: diff changeset	112 // find ')'
a61af66fc99e Initial load duke parents: diff changeset	113 int end;
a61af66fc99e Initial load duke parents: diff changeset	114 for (end = 0; end < signature->utf8_length() && signature->byte_at(end) != ')'; end++);
a61af66fc99e Initial load duke parents: diff changeset	115 // skip first '('
a61af66fc99e Initial load duke parents: diff changeset	116 mangle_name_on(&st, signature, 1, end);
a61af66fc99e Initial load duke parents: diff changeset	117 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	118 }
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 extern "C" {
a61af66fc99e Initial load duke parents: diff changeset	121 void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls);
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 0 diff changeset	122 void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
0 a61af66fc99e Initial load duke parents: diff changeset	123 void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
5915 2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	124 void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
0 a61af66fc99e Initial load duke parents: diff changeset	125 }
a61af66fc99e Initial load duke parents: diff changeset	126
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	127 #define CC (char) / cast a literal from (const char) /
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	128 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	129
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	130 static JNINativeMethod lookup_special_native_methods[] = {
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	131 // Next two functions only exist for compatibility with 1.3.1 and earlier.
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	132 { CC"Java_java_io_ObjectOutputStream_getPrimitiveFieldValues", NULL, FN_PTR(JVM_GetPrimitiveFieldValues) }, // intercept ObjectOutputStream getPrimitiveFieldValues for faster serialization
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	133 { CC"Java_java_io_ObjectInputStream_setPrimitiveFieldValues", NULL, FN_PTR(JVM_SetPrimitiveFieldValues) }, // intercept ObjectInputStream setPrimitiveFieldValues for faster serialization
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	134
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	135 { CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) },
2357 8033953d67ff 7012648: move JSR 292 to package java.lang.invoke and adjust names jrose parents: 2356 diff changeset	136 { CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
5915 2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	137 { CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) },
2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	138 { CC"Java_sun_hotspot_WhiteBox_registerNatives", NULL, FN_PTR(JVM_RegisterWhiteBoxMethods) },
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	139 };
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	140
0 a61af66fc99e Initial load duke parents: diff changeset	141 static address lookup_special_native(char* jni_name) {
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	142 int i = !JDK_Version::is_gte_jdk14x_version() ? 0 : 2; // see comment in lookup_special_native_methods
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	143 int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	144 for (; i < count; i++) {
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	145 // NB: To ignore the jni prefix and jni postfix strstr is used matching.
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	146 if (strstr(jni_name, lookup_special_native_methods[i].name) != NULL) {
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	147 return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
0 a61af66fc99e Initial load duke parents: diff changeset	148 }
a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	151 }
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 address NativeLookup::lookup_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	154 address entry;
a61af66fc99e Initial load duke parents: diff changeset	155 // Compute complete JNI name for style
a61af66fc99e Initial load duke parents: diff changeset	156 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	157 if (os_style) os::print_jni_name_prefix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	158 st.print_raw(pure_name);
a61af66fc99e Initial load duke parents: diff changeset	159 st.print_raw(long_name);
a61af66fc99e Initial load duke parents: diff changeset	160 if (os_style) os::print_jni_name_suffix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	161 char* jni_name = st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	162
a61af66fc99e Initial load duke parents: diff changeset	163 // If the loader is null we have a system class, so we attempt a lookup in
a61af66fc99e Initial load duke parents: diff changeset	164 // the native Java library. This takes care of any bootstrapping problems.
a61af66fc99e Initial load duke parents: diff changeset	165 // Note: It is critical for bootstrapping that Java_java_lang_ClassLoader_00024NativeLibrary_find
a61af66fc99e Initial load duke parents: diff changeset	166 // gets found the first time around - otherwise an infinite loop can occure. This is
a61af66fc99e Initial load duke parents: diff changeset	167 // another VM/library dependency
a61af66fc99e Initial load duke parents: diff changeset	168 Handle loader(THREAD,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	169 InstanceKlass::cast(method->method_holder())->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	170 if (loader.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	171 entry = lookup_special_native(jni_name);
a61af66fc99e Initial load duke parents: diff changeset	172 if (entry == NULL) {
1980 828eafbd85cc 6348631: remove the use of the HPI library from Hotspot ikrylov parents: 1972 diff changeset	173 entry = (address) os::dll_lookup(os::native_java_library(), jni_name);
0 a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	176 in_base_library = true;
a61af66fc99e Initial load duke parents: diff changeset	177 return entry;
a61af66fc99e Initial load duke parents: diff changeset	178 }
a61af66fc99e Initial load duke parents: diff changeset	179 }
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181 // Otherwise call static method findNative in ClassLoader
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 710 diff changeset	182 KlassHandle klass (THREAD, SystemDictionary::ClassLoader_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	183 Handle name_arg = java_lang_String::create_from_str(jni_name, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 JavaValue result(T_LONG);
a61af66fc99e Initial load duke parents: diff changeset	186 JavaCalls::call_static(&result,
a61af66fc99e Initial load duke parents: diff changeset	187 klass,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	188 vmSymbols::findNative_name(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	189 vmSymbols::classloader_string_long_signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	190 // Arguments
a61af66fc99e Initial load duke parents: diff changeset	191 loader,
a61af66fc99e Initial load duke parents: diff changeset	192 name_arg,
a61af66fc99e Initial load duke parents: diff changeset	193 CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	194 entry = (address) (intptr_t) result.get_jlong();
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 if (entry == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	197 // findNative didn't find it, if there are any agent libraries look in them
a61af66fc99e Initial load duke parents: diff changeset	198 AgentLibrary* agent;
a61af66fc99e Initial load duke parents: diff changeset	199 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
1980 828eafbd85cc 6348631: remove the use of the HPI library from Hotspot ikrylov parents: 1972 diff changeset	200 entry = (address) os::dll_lookup(agent->os_lib(), jni_name);
0 a61af66fc99e Initial load duke parents: diff changeset	201 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	202 return entry;
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204 }
a61af66fc99e Initial load duke parents: diff changeset	205 }
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 return entry;
a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	211 address NativeLookup::lookup_critical_style(methodHandle method, char* pure_name, const char* long_name, int args_size, bool os_style) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	212 if (!method->has_native_function()) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	213 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	214 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	215
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	216 address current_entry = method->native_function();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	217
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	218 char dll_name[JVM_MAXPATHLEN];
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	219 int offset;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	220 if (os::dll_address_to_library_name(current_entry, dll_name, sizeof(dll_name), &offset)) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	221 char ebuf[32];
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	222 void* dll = os::dll_load(dll_name, ebuf, sizeof(ebuf));
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	223 if (dll != NULL) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	224 // Compute complete JNI name for style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	225 stringStream st;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	226 if (os_style) os::print_jni_name_prefix_on(&st, args_size);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	227 st.print_raw(pure_name);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	228 st.print_raw(long_name);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	229 if (os_style) os::print_jni_name_suffix_on(&st, args_size);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	230 char* jni_name = st.as_string();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	231 return (address)os::dll_lookup(dll, jni_name);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	232 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	233 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	234
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	235 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	236 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	237
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	238
0 a61af66fc99e Initial load duke parents: diff changeset	239 // Check all the formats of native implementation name to see if there is one
a61af66fc99e Initial load duke parents: diff changeset	240 // for the specified method.
a61af66fc99e Initial load duke parents: diff changeset	241 address NativeLookup::lookup_entry(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	242 address entry = NULL;
a61af66fc99e Initial load duke parents: diff changeset	243 in_base_library = false;
a61af66fc99e Initial load duke parents: diff changeset	244 // Compute pure name
a61af66fc99e Initial load duke parents: diff changeset	245 char* pure_name = pure_jni_name(method);
a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 // Compute argument size
a61af66fc99e Initial load duke parents: diff changeset	248 int args_size = 1 // JNIEnv
a61af66fc99e Initial load duke parents: diff changeset	249 + (method->is_static() ? 1 : 0) // class for static methods
a61af66fc99e Initial load duke parents: diff changeset	250 + method->size_of_parameters(); // actual parameters
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252
a61af66fc99e Initial load duke parents: diff changeset	253 // 1) Try JNI short style
a61af66fc99e Initial load duke parents: diff changeset	254 entry = lookup_style(method, pure_name, "", args_size, true, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	255 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 // Compute long name
a61af66fc99e Initial load duke parents: diff changeset	258 char* long_name = long_jni_name(method);
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // 2) Try JNI long style
a61af66fc99e Initial load duke parents: diff changeset	261 entry = lookup_style(method, pure_name, long_name, args_size, true, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	262 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 // 3) Try JNI short style without os prefix/suffix
a61af66fc99e Initial load duke parents: diff changeset	265 entry = lookup_style(method, pure_name, "", args_size, false, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	266 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // 4) Try JNI long style without os prefix/suffix
a61af66fc99e Initial load duke parents: diff changeset	269 entry = lookup_style(method, pure_name, long_name, args_size, false, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	270
a61af66fc99e Initial load duke parents: diff changeset	271 return entry; // NULL indicates not found
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	274 // Check all the formats of native implementation name to see if there is one
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	275 // for the specified method.
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	276 address NativeLookup::lookup_critical_entry(methodHandle method) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	277 if (!CriticalJNINatives) return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	278
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	279 if (method->is_synchronized() \|\|
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	280 !method->is_static()) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	281 // Only static non-synchronized methods are allowed
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	282 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	283 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	284
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	285 ResourceMark rm;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	286 address entry = NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	287
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	288 Symbol* signature = method->signature();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	289 for (int end = 0; end < signature->utf8_length(); end++) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	290 if (signature->byte_at(end) == 'L') {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	291 // Don't allow object types
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	292 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	293 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	294 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	295
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	296 // Compute critical name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	297 char* critical_name = critical_jni_name(method);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	298
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	299 // Compute argument size
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	300 int args_size = 1 // JNIEnv
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	301 + (method->is_static() ? 1 : 0) // class for static methods
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	302 + method->size_of_parameters(); // actual parameters
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	303
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	304
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	305 // 1) Try JNI short style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	306 entry = lookup_critical_style(method, critical_name, "", args_size, true);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	307 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	308
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	309 // Compute long name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	310 char* long_name = long_jni_name(method);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	311
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	312 // 2) Try JNI long style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	313 entry = lookup_critical_style(method, critical_name, long_name, args_size, true);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	314 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	315
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	316 // 3) Try JNI short style without os prefix/suffix
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	317 entry = lookup_critical_style(method, critical_name, "", args_size, false);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	318 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	319
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	320 // 4) Try JNI long style without os prefix/suffix
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	321 entry = lookup_critical_style(method, critical_name, long_name, args_size, false);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	322
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	323 return entry; // NULL indicates not found
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	324 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	325
0 a61af66fc99e Initial load duke parents: diff changeset	326 // Check if there are any JVM TI prefixes which have been applied to the native method name.
a61af66fc99e Initial load duke parents: diff changeset	327 // If any are found, remove them before attemping the look up of the
a61af66fc99e Initial load duke parents: diff changeset	328 // native implementation again.
a61af66fc99e Initial load duke parents: diff changeset	329 // See SetNativeMethodPrefix in the JVM TI Spec for more details.
a61af66fc99e Initial load duke parents: diff changeset	330 address NativeLookup::lookup_entry_prefixed(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	331 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 int prefix_count;
a61af66fc99e Initial load duke parents: diff changeset	334 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
a61af66fc99e Initial load duke parents: diff changeset	335 char* in_name = method->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	336 char* wrapper_name = in_name;
a61af66fc99e Initial load duke parents: diff changeset	337 // last applied prefix will be first -- go backwards
a61af66fc99e Initial load duke parents: diff changeset	338 for (int i = prefix_count-1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	339 char* prefix = prefixes[i];
a61af66fc99e Initial load duke parents: diff changeset	340 size_t prefix_len = strlen(prefix);
a61af66fc99e Initial load duke parents: diff changeset	341 if (strncmp(prefix, wrapper_name, prefix_len) == 0) {
a61af66fc99e Initial load duke parents: diff changeset	342 // has this prefix remove it
a61af66fc99e Initial load duke parents: diff changeset	343 wrapper_name += prefix_len;
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345 }
a61af66fc99e Initial load duke parents: diff changeset	346 if (wrapper_name != in_name) {
a61af66fc99e Initial load duke parents: diff changeset	347 // we have a name for a wrapping method
a61af66fc99e Initial load duke parents: diff changeset	348 int wrapper_name_len = (int)strlen(wrapper_name);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	349 TempNewSymbol wrapper_symbol = SymbolTable::probe(wrapper_name, wrapper_name_len);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	350 if (wrapper_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	351 KlassHandle kh(method->method_holder());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	352 Method* wrapper_method = Klass::cast(kh())->lookup_method(wrapper_symbol,
0 a61af66fc99e Initial load duke parents: diff changeset	353 method->signature());
a61af66fc99e Initial load duke parents: diff changeset	354 if (wrapper_method != NULL && !wrapper_method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	355 // we found a wrapper method, use its native entry
a61af66fc99e Initial load duke parents: diff changeset	356 method->set_is_prefixed_native();
a61af66fc99e Initial load duke parents: diff changeset	357 return lookup_entry(wrapper_method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 }
a61af66fc99e Initial load duke parents: diff changeset	361 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 address NativeLookup::lookup_base(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	365 address entry = NULL;
a61af66fc99e Initial load duke parents: diff changeset	366 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	367
a61af66fc99e Initial load duke parents: diff changeset	368 entry = lookup_entry(method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	369 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	370
a61af66fc99e Initial load duke parents: diff changeset	371 // standard native method resolution has failed. Check if there are any
a61af66fc99e Initial load duke parents: diff changeset	372 // JVM TI prefixes which have been applied to the native method name.
a61af66fc99e Initial load duke parents: diff changeset	373 entry = lookup_entry_prefixed(method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	374 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 // Native function not found, throw UnsatisfiedLinkError
a61af66fc99e Initial load duke parents: diff changeset	377 THROW_MSG_0(vmSymbols::java_lang_UnsatisfiedLinkError(),
a61af66fc99e Initial load duke parents: diff changeset	378 method->name_and_sig_as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	379 }
a61af66fc99e Initial load duke parents: diff changeset	380
a61af66fc99e Initial load duke parents: diff changeset	381
a61af66fc99e Initial load duke parents: diff changeset	382 address NativeLookup::lookup(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	383 if (!method->has_native_function()) {
6271 93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	384 address entry =
93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	385 method->intrinsic_id() == vmIntrinsics::_invokeGeneric ?
93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	386 SharedRuntime::native_method_throw_unsupported_operation_exception_entry() :
93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	387 lookup_base(method, in_base_library, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	388 method->set_native_function(entry,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	389 Method::native_bind_event_is_interesting);
0 a61af66fc99e Initial load duke parents: diff changeset	390 // -verbose:jni printing
a61af66fc99e Initial load duke parents: diff changeset	391 if (PrintJNIResolving) {
a61af66fc99e Initial load duke parents: diff changeset	392 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	393 tty->print_cr("[Dynamic-linking native method %s.%s ... JNI]",
a61af66fc99e Initial load duke parents: diff changeset	394 Klass::cast(method->method_holder())->external_name(),
a61af66fc99e Initial load duke parents: diff changeset	395 method->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	396 }
a61af66fc99e Initial load duke parents: diff changeset	397 }
a61af66fc99e Initial load duke parents: diff changeset	398 return method->native_function();
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 address NativeLookup::base_library_lookup(const char* class_name, const char* method_name, const char* signature) {
a61af66fc99e Initial load duke parents: diff changeset	402 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	403 bool in_base_library = true; // SharedRuntime inits some math methods.
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	404 TempNewSymbol c_name = SymbolTable::new_symbol(class_name, CATCH);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	405 TempNewSymbol m_name = SymbolTable::new_symbol(method_name, CATCH);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	406 TempNewSymbol s_name = SymbolTable::new_symbol(signature, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	407
a61af66fc99e Initial load duke parents: diff changeset	408 // Find the class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	409 Klass* k = SystemDictionary::resolve_or_fail(c_name, true, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	410 instanceKlassHandle klass (THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	411
a61af66fc99e Initial load duke parents: diff changeset	412 // Find method and invoke standard lookup
a61af66fc99e Initial load duke parents: diff changeset	413 methodHandle method (THREAD,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	414 klass->uncached_lookup_method(m_name, s_name));
0 a61af66fc99e Initial load duke parents: diff changeset	415 address result = lookup(method, in_base_library, CATCH);
a61af66fc99e Initial load duke parents: diff changeset	416 assert(in_base_library, "must be in basic library");
a61af66fc99e Initial load duke parents: diff changeset	417 guarantee(result != NULL, "must be non NULL");
a61af66fc99e Initial load duke parents: diff changeset	418 return result;
a61af66fc99e Initial load duke parents: diff changeset	419 }

Mercurial > hg > truffle

annotate src/share/vm/prims/nativeLookup.cpp @ 6862:8a5ea0a9ccc4