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

annotate src/share/vm/prims/nativeLookup.cpp @ 8733:9def4075da6d

8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate(). Reviewed-by: johnc, ysr Contributed-by: tamao <tao.mao@oracle.com>

author	tamao
date	Tue, 05 Mar 2013 15:36:56 -0800
parents	db9981fd3124
children	5fc51c1ecdeb f0bc60565ba8

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"
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
3960 f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	53 #ifdef TARGET_OS_FAMILY_bsd
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	54 # include "os_bsd.inline.hpp"
f08d439fab8c 7089790: integrate bsd-port changes never parents: 2460 diff changeset	55 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	58 static void mangle_name_on(outputStream* st, Symbol* name, int begin, int end) {
0 a61af66fc99e Initial load duke parents: diff changeset	59 char* bytes = (char*)name->bytes() + begin;
a61af66fc99e Initial load duke parents: diff changeset	60 char* end_bytes = (char*)name->bytes() + end;
a61af66fc99e Initial load duke parents: diff changeset	61 while (bytes < end_bytes) {
a61af66fc99e Initial load duke parents: diff changeset	62 jchar c;
a61af66fc99e Initial load duke parents: diff changeset	63 bytes = UTF8::next(bytes, &c);
a61af66fc99e Initial load duke parents: diff changeset	64 if (c <= 0x7f && isalnum(c)) {
a61af66fc99e Initial load duke parents: diff changeset	65 st->put((char) c);
a61af66fc99e Initial load duke parents: diff changeset	66 } else {
a61af66fc99e Initial load duke parents: diff changeset	67 if (c == '_') st->print("_1");
a61af66fc99e Initial load duke parents: diff changeset	68 else if (c == '/') st->print("_");
a61af66fc99e Initial load duke parents: diff changeset	69 else if (c == ';') st->print("_2");
a61af66fc99e Initial load duke parents: diff changeset	70 else if (c == '[') st->print("_3");
a61af66fc99e Initial load duke parents: diff changeset	71 else st->print("_%.5x", c);
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
a61af66fc99e Initial load duke parents: diff changeset	76
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	77 static void mangle_name_on(outputStream* st, Symbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	78 mangle_name_on(st, name, 0, name->utf8_length());
a61af66fc99e Initial load duke parents: diff changeset	79 }
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82 char* NativeLookup::pure_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	83 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	84 // Prefix
a61af66fc99e Initial load duke parents: diff changeset	85 st.print("Java_");
a61af66fc99e Initial load duke parents: diff changeset	86 // Klass name
a61af66fc99e Initial load duke parents: diff changeset	87 mangle_name_on(&st, method->klass_name());
a61af66fc99e Initial load duke parents: diff changeset	88 st.print("_");
a61af66fc99e Initial load duke parents: diff changeset	89 // Method name
a61af66fc99e Initial load duke parents: diff changeset	90 mangle_name_on(&st, method->name());
a61af66fc99e Initial load duke parents: diff changeset	91 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	92 }
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	95 char* NativeLookup::critical_jni_name(methodHandle method) {
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	96 stringStream st;
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	97 // Prefix
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	98 st.print("JavaCritical_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	99 // Klass name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	100 mangle_name_on(&st, method->klass_name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	101 st.print("_");
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	102 // Method name
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	103 mangle_name_on(&st, method->name());
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	104 return st.as_string();
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
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3960 diff changeset	107
0 a61af66fc99e Initial load duke parents: diff changeset	108 char* NativeLookup::long_jni_name(methodHandle method) {
a61af66fc99e Initial load duke parents: diff changeset	109 // Signature ignore the wrapping parenteses and the trailing return type
a61af66fc99e Initial load duke parents: diff changeset	110 stringStream st;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	111 Symbol* signature = method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	112 st.print("__");
a61af66fc99e Initial load duke parents: diff changeset	113 // find ')'
a61af66fc99e Initial load duke parents: diff changeset	114 int end;
a61af66fc99e Initial load duke parents: diff changeset	115 for (end = 0; end < signature->utf8_length() && signature->byte_at(end) != ')'; end++);
a61af66fc99e Initial load duke parents: diff changeset	116 // skip first '('
a61af66fc99e Initial load duke parents: diff changeset	117 mangle_name_on(&st, signature, 1, end);
a61af66fc99e Initial load duke parents: diff changeset	118 return st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	119 }
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 extern "C" {
a61af66fc99e Initial load duke parents: diff changeset	122 void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls);
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 0 diff changeset	123 void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls);
0 a61af66fc99e Initial load duke parents: diff changeset	124 void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass);
5915 2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	125 void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass);
0 a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	128 #define CC (char) / cast a literal from (const char) /
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	129 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	130
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	131 static JNINativeMethod lookup_special_native_methods[] = {
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	132 // 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	133 { 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	134 { 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	135
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	136 { 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	137 { 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	138 { CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) },
2d503de963b3 7148152: Add whitebox testing API to HotSpot mgerdin parents: 4873 diff changeset	139 { 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	140 };
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	141
0 a61af66fc99e Initial load duke parents: diff changeset	142 static address lookup_special_native(char* jni_name) {
2356 72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	143 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	144 int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	145 for (; i < count; i++) {
72dee110246f 6839872: remove implementation inheritance from JSR 292 APIs jrose parents: 2177 diff changeset	146 // 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	147 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	148 return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
0 a61af66fc99e Initial load duke parents: diff changeset	149 }
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	152 }
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 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	155 address entry;
a61af66fc99e Initial load duke parents: diff changeset	156 // Compute complete JNI name for style
a61af66fc99e Initial load duke parents: diff changeset	157 stringStream st;
a61af66fc99e Initial load duke parents: diff changeset	158 if (os_style) os::print_jni_name_prefix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	159 st.print_raw(pure_name);
a61af66fc99e Initial load duke parents: diff changeset	160 st.print_raw(long_name);
a61af66fc99e Initial load duke parents: diff changeset	161 if (os_style) os::print_jni_name_suffix_on(&st, args_size);
a61af66fc99e Initial load duke parents: diff changeset	162 char* jni_name = st.as_string();
a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 // If the loader is null we have a system class, so we attempt a lookup in
a61af66fc99e Initial load duke parents: diff changeset	165 // the native Java library. This takes care of any bootstrapping problems.
a61af66fc99e Initial load duke parents: diff changeset	166 // Note: It is critical for bootstrapping that Java_java_lang_ClassLoader_00024NativeLibrary_find
a61af66fc99e Initial load duke parents: diff changeset	167 // gets found the first time around - otherwise an infinite loop can occure. This is
a61af66fc99e Initial load duke parents: diff changeset	168 // 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	169 Handle loader(THREAD, 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) {
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	331 #if INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	332 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 int prefix_count;
a61af66fc99e Initial load duke parents: diff changeset	335 char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
a61af66fc99e Initial load duke parents: diff changeset	336 char* in_name = method->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	337 char* wrapper_name = in_name;
a61af66fc99e Initial load duke parents: diff changeset	338 // last applied prefix will be first -- go backwards
a61af66fc99e Initial load duke parents: diff changeset	339 for (int i = prefix_count-1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	340 char* prefix = prefixes[i];
a61af66fc99e Initial load duke parents: diff changeset	341 size_t prefix_len = strlen(prefix);
a61af66fc99e Initial load duke parents: diff changeset	342 if (strncmp(prefix, wrapper_name, prefix_len) == 0) {
a61af66fc99e Initial load duke parents: diff changeset	343 // has this prefix remove it
a61af66fc99e Initial load duke parents: diff changeset	344 wrapper_name += prefix_len;
a61af66fc99e Initial load duke parents: diff changeset	345 }
a61af66fc99e Initial load duke parents: diff changeset	346 }
a61af66fc99e Initial load duke parents: diff changeset	347 if (wrapper_name != in_name) {
a61af66fc99e Initial load duke parents: diff changeset	348 // we have a name for a wrapping method
a61af66fc99e Initial load duke parents: diff changeset	349 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	350 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	351 if (wrapper_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	352 KlassHandle kh(method->method_holder());
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	353 Method* wrapper_method = kh()->lookup_method(wrapper_symbol,
0 a61af66fc99e Initial load duke parents: diff changeset	354 method->signature());
a61af66fc99e Initial load duke parents: diff changeset	355 if (wrapper_method != NULL && !wrapper_method->is_native()) {
a61af66fc99e Initial load duke parents: diff changeset	356 // we found a wrapper method, use its native entry
a61af66fc99e Initial load duke parents: diff changeset	357 method->set_is_prefixed_native();
a61af66fc99e Initial load duke parents: diff changeset	358 return lookup_entry(wrapper_method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 }
a61af66fc99e Initial load duke parents: diff changeset	361 }
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	362 #endif // INCLUDE_JVMTI
0 a61af66fc99e Initial load duke parents: diff changeset	363 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	364 }
a61af66fc99e Initial load duke parents: diff changeset	365
a61af66fc99e Initial load duke parents: diff changeset	366 address NativeLookup::lookup_base(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	367 address entry = NULL;
a61af66fc99e Initial load duke parents: diff changeset	368 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 entry = lookup_entry(method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	371 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373 // standard native method resolution has failed. Check if there are any
a61af66fc99e Initial load duke parents: diff changeset	374 // JVM TI prefixes which have been applied to the native method name.
a61af66fc99e Initial load duke parents: diff changeset	375 entry = lookup_entry_prefixed(method, in_base_library, THREAD);
a61af66fc99e Initial load duke parents: diff changeset	376 if (entry != NULL) return entry;
a61af66fc99e Initial load duke parents: diff changeset	377
a61af66fc99e Initial load duke parents: diff changeset	378 // Native function not found, throw UnsatisfiedLinkError
a61af66fc99e Initial load duke parents: diff changeset	379 THROW_MSG_0(vmSymbols::java_lang_UnsatisfiedLinkError(),
a61af66fc99e Initial load duke parents: diff changeset	380 method->name_and_sig_as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	381 }
a61af66fc99e Initial load duke parents: diff changeset	382
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 address NativeLookup::lookup(methodHandle method, bool& in_base_library, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	385 if (!method->has_native_function()) {
6271 93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	386 address entry =
93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	387 method->intrinsic_id() == vmIntrinsics::_invokeGeneric ?
93c71eb28866 7188911: nightly failures after JSR 292 lazy method handle update (round 2) twisti parents: 5915 diff changeset	388 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	389 lookup_base(method, in_base_library, CHECK_NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	390 method->set_native_function(entry,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	391 Method::native_bind_event_is_interesting);
0 a61af66fc99e Initial load duke parents: diff changeset	392 // -verbose:jni printing
a61af66fc99e Initial load duke parents: diff changeset	393 if (PrintJNIResolving) {
a61af66fc99e Initial load duke parents: diff changeset	394 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	395 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	396 method->method_holder()->external_name(),
0 a61af66fc99e Initial load duke parents: diff changeset	397 method->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400 return method->native_function();
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 address NativeLookup::base_library_lookup(const char* class_name, const char* method_name, const char* signature) {
a61af66fc99e Initial load duke parents: diff changeset	404 EXCEPTION_MARK;
a61af66fc99e Initial load duke parents: diff changeset	405 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	406 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	407 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	408 TempNewSymbol s_name = SymbolTable::new_symbol(signature, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 // Find the class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6271 diff changeset	411 Klass* k = SystemDictionary::resolve_or_fail(c_name, true, CATCH);
0 a61af66fc99e Initial load duke parents: diff changeset	412 instanceKlassHandle klass (THREAD, k);
a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 // Find method and invoke standard lookup
a61af66fc99e Initial load duke parents: diff changeset	415 methodHandle method (THREAD,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1980 diff changeset	416 klass->uncached_lookup_method(m_name, s_name));
0 a61af66fc99e Initial load duke parents: diff changeset	417 address result = lookup(method, in_base_library, CATCH);
a61af66fc99e Initial load duke parents: diff changeset	418 assert(in_base_library, "must be in basic library");
a61af66fc99e Initial load duke parents: diff changeset	419 guarantee(result != NULL, "must be non NULL");
a61af66fc99e Initial load duke parents: diff changeset	420 return result;
a61af66fc99e Initial load duke parents: diff changeset	421 }

Mercurial > hg > truffle

annotate src/share/vm/prims/nativeLookup.cpp @ 8733:9def4075da6d