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

annotate src/share/vm/prims/nativeLookup.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	386dd1c71858
children	52b4284cb496

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17889 386dd1c71858 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults. lfoltan parents: 17795 diff changeset	2 * Copyright (c) 1997, 2014, 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"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6983 diff changeset	43 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	44 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	45 # include "os_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	46 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	47 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	48 # include "os_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	49 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	50 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	51 # include "os_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	52 #endif
14411 bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 10276 diff changeset	53 #ifdef TARGET_OS_FAMILY_aix
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 10276 diff changeset	54 # include "os_aix.inline.hpp"
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 10276 diff changeset	55 #endif
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	56 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	57 # include "os_bsd.inline.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	58 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	61 static void mangle_name_on(outputStream* st, Symbol* name, int begin, int end) {
0 a61af66fc99e Initial load duke parents: diff changeset	62 char* bytes = (char*)name->bytes() + begin;
a61af66fc99e Initial load duke parents: diff changeset	63 char* end_bytes = (char*)name->bytes() + end;
a61af66fc99e Initial load duke parents: diff changeset	64 while (bytes < end_bytes) {
a61af66fc99e Initial load duke parents: diff changeset	65 jchar c;
a61af66fc99e Initial load duke parents: diff changeset	66 bytes = UTF8::next(bytes, &c);
a61af66fc99e Initial load duke parents: diff changeset	67 if (c <= 0x7f && isalnum(c)) {
a61af66fc99e Initial load duke parents: diff changeset	68 st->put((char) c);
a61af66fc99e Initial load duke parents: diff changeset	69 } else {
a61af66fc99e Initial load duke parents: diff changeset	70 if (c == '_') st->print("_1");
a61af66fc99e Initial load duke parents: diff changeset	71 else if (c == '/') st->print("_");
a61af66fc99e Initial load duke parents: diff changeset	72 else if (c == ';') st->print("_2");
a61af66fc99e Initial load duke parents: diff changeset	73 else if (c == '[') st->print("_3");
a61af66fc99e Initial load duke parents: diff changeset	74 else st->print("_%.5x", c);
a61af66fc99e Initial load duke parents: diff changeset	75 }
a61af66fc99e Initial load duke parents: diff changeset	76 }
a61af66fc99e Initial load duke parents: diff changeset	77 }
a61af66fc99e Initial load duke parents: diff changeset	78
a61af66fc99e Initial load duke parents: diff changeset	79
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	80 static void mangle_name_on(outputStream* st, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	81 mangle_name_on(st, name, 0, name->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84
a61af66fc99e Initial load duke parents: diff changeset	85 char* NativeLookup::pure_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	86 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	87 // Prefix
a61af66fc99e Initial load duke parents: diff changeset	88 st.print("Java_");
a61af66fc99e Initial load duke parents: diff changeset	89 // Klass name
a61af66fc99e Initial load duke parents: diff changeset	90 mangle_name_on(&st, method->klass_name());
a61af66fc99e Initial load duke parents: diff changeset	91 st.print("_");
a61af66fc99e Initial load duke parents: diff changeset	92 // Method name
a61af66fc99e Initial load duke parents: diff changeset	93 mangle_name_on(&st, method->name());
a61af66fc99e Initial load duke parents: diff changeset	94 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	95 }
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	98 char* NativeLookup::critical_jni_name(methodHandle method) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	99 stringStream st;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	100 // Prefix
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	101 st.print("JavaCritical_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	102 // Klass name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	103 mangle_name_on(&st, method->klass_name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	104 st.print("_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	105 // Method name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	106 mangle_name_on(&st, method->name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	107 return st.as_string();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	108 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	109
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	110
0 a61af66fc99e Initial load duke parents: diff changeset	111 char* NativeLookup::long_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	112 // Signature ignore the wrapping parenteses and the trailing return type
a61af66fc99e Initial load duke parents: diff changeset	113 stringStream st;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	114 Symbol* signature = method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	115 st.print("__");
a61af66fc99e Initial load duke parents: diff changeset	116 // find ')'
a61af66fc99e Initial load duke parents: diff changeset	117 int end;
a61af66fc99e Initial load duke parents: diff changeset	118 for (end = 0; end < signature->utf8_length() && signature->byte_at(end) != ')'; end++);
a61af66fc99e Initial load duke parents: diff changeset	119 // skip first '('
a61af66fc99e Initial load duke parents: diff changeset	120 mangle_name_on(&st, signature, 1, end);
a61af66fc99e Initial load duke parents: diff changeset	121 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	122 }
a61af66fc99e Initial load duke parents: diff changeset	123
a61af66fc99e Initial load duke parents: diff changeset	124 extern "C" {
a61af66fc99e Initial load duke parents: diff changeset	125 void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls);
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 0 diff changeset	126 void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
0 a61af66fc99e Initial load duke parents: diff changeset	127 void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
5915 2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	128 void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
0 a61af66fc99e Initial load duke parents: diff changeset	129 }
a61af66fc99e Initial load duke parents: diff changeset	130
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	131 #define CC (char) / cast a literal from (const char) /
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	132 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	133
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	134 static JNINativeMethod lookup_special_native_methods[] = {
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 count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
12813 675ffabf3798 8024087: Remove dead JVM_{Get,Set}PrimitiveFieldValues functions mikael parents: 10276 diff changeset	143 for (int i = 0; i < count; i++) {
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	144 // 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	145 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	146 return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
0 a61af66fc99e Initial load duke parents: diff changeset	147 }
a61af66fc99e Initial load duke parents: diff changeset	148 }
a61af66fc99e Initial load duke parents: diff changeset	149 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 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	153 address entry;
a61af66fc99e Initial load duke parents: diff changeset	154 // Compute complete JNI name for style
a61af66fc99e Initial load duke parents: diff changeset	155 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	156 if (os_style) os::print_jni_name_prefix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	157 st.print_raw(pure_name);
a61af66fc99e Initial load duke parents: diff changeset	158 st.print_raw(long_name);
a61af66fc99e Initial load duke parents: diff changeset	159 if (os_style) os::print_jni_name_suffix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	160 char* jni_name = st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // If the loader is null we have a system class, so we attempt a lookup in
a61af66fc99e Initial load duke parents: diff changeset	163 // the native Java library. This takes care of any bootstrapping problems.
a61af66fc99e Initial load duke parents: diff changeset	164 // Note: It is critical for bootstrapping that Java_java_lang_ClassLoader_00024NativeLibrary_find
a61af66fc99e Initial load duke parents: diff changeset	165 // gets found the first time around - otherwise an infinite loop can occure. This is
a61af66fc99e Initial load duke parents: diff changeset	166 // another VM/library dependency
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6854 diff changeset	167 Handle loader(THREAD, method->method_holder()->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	168 if (loader.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	169 entry = lookup_special_native(jni_name);
a61af66fc99e Initial load duke parents: diff changeset	170 if (entry == NULL) {
1980 828eafbd85cc 6348631: remove the use of the HPI library from Hotspot ikrylov parents: 1972 diff changeset	171 entry = (address) os::dll_lookup(os::native_java_library(), jni_name);
0 a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	174 in_base_library = true;
a61af66fc99e Initial load duke parents: diff changeset	175 return entry;
a61af66fc99e Initial load duke parents: diff changeset	176 }
a61af66fc99e Initial load duke parents: diff changeset	177 }
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // Otherwise call static method findNative in ClassLoader
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 710 diff changeset	180 KlassHandle klass (THREAD, SystemDictionary::ClassLoader_klass());
0 a61af66fc99e Initial load duke parents: diff changeset	181 Handle name_arg = java_lang_String::create_from_str(jni_name, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	182
a61af66fc99e Initial load duke parents: diff changeset	183 JavaValue result(T_LONG);
a61af66fc99e Initial load duke parents: diff changeset	184 JavaCalls::call_static(&result,
a61af66fc99e Initial load duke parents: diff changeset	185 klass,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	186 vmSymbols::findNative_name(),
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	187 vmSymbols::classloader_string_long_signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	188 // Arguments
a61af66fc99e Initial load duke parents: diff changeset	189 loader,
a61af66fc99e Initial load duke parents: diff changeset	190 name_arg,
a61af66fc99e Initial load duke parents: diff changeset	191 CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	192 entry = (address) (intptr_t) result.get_jlong();
a61af66fc99e Initial load duke parents: diff changeset	193
a61af66fc99e Initial load duke parents: diff changeset	194 if (entry == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	195 // findNative didn't find it, if there are any agent libraries look in them
a61af66fc99e Initial load duke parents: diff changeset	196 AgentLibrary* agent;
a61af66fc99e Initial load duke parents: diff changeset	197 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	198 entry = (address) os::dll_lookup(agent->os_lib(), jni_name);
0 a61af66fc99e Initial load duke parents: diff changeset	199 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	200 return entry;
a61af66fc99e Initial load duke parents: diff changeset	201 }
a61af66fc99e Initial load duke parents: diff changeset	202 }
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 return entry;
a61af66fc99e Initial load duke parents: diff changeset	206 }
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	209 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	210 if (!method->has_native_function()) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	211 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	212 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	213
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	214 address current_entry = method->native_function();
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 char dll_name[JVM_MAXPATHLEN];
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	217 int offset;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	218 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	219 char ebuf[32];
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	220 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	221 if (dll != NULL) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	222 // Compute complete JNI name for style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	223 stringStream st;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	224 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	225 st.print_raw(pure_name);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	226 st.print_raw(long_name);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	227 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	228 char* jni_name = st.as_string();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	229 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	230 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	231 }
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 return NULL;
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
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	236
0 a61af66fc99e Initial load duke parents: diff changeset	237 // Check all the formats of native implementation name to see if there is one
a61af66fc99e Initial load duke parents: diff changeset	238 // for the specified method.
a61af66fc99e Initial load duke parents: diff changeset	239 address NativeLookup::lookup_entry(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	240 address entry = NULL;
a61af66fc99e Initial load duke parents: diff changeset	241 in_base_library = false;
a61af66fc99e Initial load duke parents: diff changeset	242 // Compute pure name
a61af66fc99e Initial load duke parents: diff changeset	243 char* pure_name = pure_jni_name(method);
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 // Compute argument size
a61af66fc99e Initial load duke parents: diff changeset	246 int args_size = 1 // JNIEnv
a61af66fc99e Initial load duke parents: diff changeset	247 + (method->is_static() ? 1 : 0) // class for static methods
a61af66fc99e Initial load duke parents: diff changeset	248 + method->size_of_parameters(); // actual parameters
a61af66fc99e Initial load duke parents: diff changeset	249
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 // 1) Try JNI short style
a61af66fc99e Initial load duke parents: diff changeset	252 entry = lookup_style(method, pure_name, "", args_size, true, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	253 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255 // Compute long name
a61af66fc99e Initial load duke parents: diff changeset	256 char* long_name = long_jni_name(method);
a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 // 2) Try JNI long style
a61af66fc99e Initial load duke parents: diff changeset	259 entry = lookup_style(method, pure_name, long_name, args_size, true, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	260 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	261
a61af66fc99e Initial load duke parents: diff changeset	262 // 3) Try JNI short style without os prefix/suffix
a61af66fc99e Initial load duke parents: diff changeset	263 entry = lookup_style(method, pure_name, "", args_size, false, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	264 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 // 4) Try JNI long style without os prefix/suffix
a61af66fc99e Initial load duke parents: diff changeset	267 entry = lookup_style(method, pure_name, long_name, args_size, false, in_base_library, CHECK_NULL);
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 return entry; // NULL indicates not found
a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	272 // 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	273 // for the specified method.
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	274 address NativeLookup::lookup_critical_entry(methodHandle method) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	275 if (!CriticalJNINatives) return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	276
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	277 if (method->is_synchronized() \|\|
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	278 !method->is_static()) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	279 // Only static non-synchronized methods are allowed
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	280 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	281 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	282
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	283 ResourceMark rm;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	284 address entry = NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	285
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	286 Symbol* signature = method->signature();
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	287 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	288 if (signature->byte_at(end) == 'L') {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	289 // Don't allow object types
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	290 return NULL;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	291 }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	292 }
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 // Compute critical name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	295 char* critical_name = critical_jni_name(method);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	296
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	297 // Compute argument size
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	298 int args_size = 1 // JNIEnv
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	299 + (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	300 + method->size_of_parameters(); // actual parameters
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	301
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	302
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	303 // 1) Try JNI short style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	304 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	305 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	306
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	307 // Compute long name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	308 char* long_name = long_jni_name(method);
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	309
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	310 // 2) Try JNI long style
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	311 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	312 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	313
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	314 // 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	315 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	316 if (entry != NULL) return entry;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	317
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	318 // 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	319 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	320
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	321 return entry; // NULL indicates not found
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
0 a61af66fc99e Initial load duke parents: diff changeset	324 // Check if there are any JVM TI prefixes which have been applied to the native method name.
a61af66fc99e Initial load duke parents: diff changeset	325 // If any are found, remove them before attemping the look up of the
a61af66fc99e Initial load duke parents: diff changeset	326 // native implementation again.
a61af66fc99e Initial load duke parents: diff changeset	327 // See SetNativeMethodPrefix in the JVM TI Spec for more details.
a61af66fc99e Initial load duke parents: diff changeset	328 address NativeLookup::lookup_entry_prefixed(methodHandle method, bool& in_base_library, TRAPS) {
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	329 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	330 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 int prefix_count;
a61af66fc99e Initial load duke parents: diff changeset	333 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
a61af66fc99e Initial load duke parents: diff changeset	334 char* in_name = method->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	335 char* wrapper_name = in_name;
a61af66fc99e Initial load duke parents: diff changeset	336 // last applied prefix will be first -- go backwards
a61af66fc99e Initial load duke parents: diff changeset	337 for (int i = prefix_count-1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	338 char* prefix = prefixes[i];
a61af66fc99e Initial load duke parents: diff changeset	339 size_t prefix_len = strlen(prefix);
a61af66fc99e Initial load duke parents: diff changeset	340 if (strncmp(prefix, wrapper_name, prefix_len) == 0) {
a61af66fc99e Initial load duke parents: diff changeset	341 // has this prefix remove it
a61af66fc99e Initial load duke parents: diff changeset	342 wrapper_name += prefix_len;
a61af66fc99e Initial load duke parents: diff changeset	343 }
a61af66fc99e Initial load duke parents: diff changeset	344 }
a61af66fc99e Initial load duke parents: diff changeset	345 if (wrapper_name != in_name) {
a61af66fc99e Initial load duke parents: diff changeset	346 // we have a name for a wrapping method
a61af66fc99e Initial load duke parents: diff changeset	347 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	348 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	349 if (wrapper_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	350 KlassHandle kh(method->method_holder());
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	351 Method* wrapper_method = kh()->lookup_method(wrapper_symbol,
0 a61af66fc99e Initial load duke parents: diff changeset	352 method->signature());
a61af66fc99e Initial load duke parents: diff changeset	353 if (wrapper_method != NULL && !wrapper_method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	354 // we found a wrapper method, use its native entry
a61af66fc99e Initial load duke parents: diff changeset	355 method->set_is_prefixed_native();
a61af66fc99e Initial load duke parents: diff changeset	356 return lookup_entry(wrapper_method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	357 }
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359 }
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	360 #endif // INCLUDE_JVMTI
0 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()) {
10276 f0bc60565ba8 7196277: JSR 292: Two jck/runtime tests crash on java.lang.invoke.MethodHandle.invokeExact twisti parents: 8001 diff changeset	384 address entry = lookup_base(method, in_base_library, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	385 method->set_native_function(entry,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	386 Method::native_bind_event_is_interesting);
0 a61af66fc99e Initial load duke parents: diff changeset	387 // -verbose:jni printing
a61af66fc99e Initial load duke parents: diff changeset	388 if (PrintJNIResolving) {
a61af66fc99e Initial load duke parents: diff changeset	389 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	390 tty->print_cr("[Dynamic-linking native method %s.%s ... JNI]",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6854 diff changeset	391 method->method_holder()->external_name(),
0 a61af66fc99e Initial load duke parents: diff changeset	392 method->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394 }
a61af66fc99e Initial load duke parents: diff changeset	395 return method->native_function();
a61af66fc99e Initial load duke parents: diff changeset	396 }
a61af66fc99e Initial load duke parents: diff changeset	397
a61af66fc99e Initial load duke parents: diff changeset	398 address NativeLookup::base_library_lookup(const char* class_name, const char* method_name, const char* signature) {
a61af66fc99e Initial load duke parents: diff changeset	399 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	400 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	401 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	402 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	403 TempNewSymbol s_name = SymbolTable::new_symbol(signature, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	404
a61af66fc99e Initial load duke parents: diff changeset	405 // Find the class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	406 Klass* k = SystemDictionary::resolve_or_fail(c_name, true, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	407 instanceKlassHandle klass (THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	408
a61af66fc99e Initial load duke parents: diff changeset	409 // Find method and invoke standard lookup
a61af66fc99e Initial load duke parents: diff changeset	410 methodHandle method (THREAD,
17889 386dd1c71858 8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults. lfoltan parents: 17795 diff changeset	411 klass->uncached_lookup_method(m_name, s_name, Klass::normal));
0 a61af66fc99e Initial load duke parents: diff changeset	412 address result = lookup(method, in_base_library, CATCH);
a61af66fc99e Initial load duke parents: diff changeset	413 assert(in_base_library, "must be in basic library");
a61af66fc99e Initial load duke parents: diff changeset	414 guarantee(result != NULL, "must be non NULL");
a61af66fc99e Initial load duke parents: diff changeset	415 return result;
a61af66fc99e Initial load duke parents: diff changeset	416 }

Mercurial > hg > truffle

annotate src/share/vm/prims/nativeLookup.cpp @ 20543:e7d0505c8a30