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

equal deleted inserted replaced

-:582dd25571b2
+:96d498ec7ae1
 #include "oops/markOop.hpp"
 #include "oops/methodOop.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
-#include "oops/symbolOop.hpp"
+#include "oops/symbol.hpp"
 #include "oops/typeArrayKlass.hpp"
 #include "oops/typeArrayOop.hpp"
 #include "prims/jni.h"
 #include "prims/jniCheck.hpp"
 #include "prims/jniFastGetField.hpp"
 jclass cls = NULL;
 DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
 // Since exceptions can be thrown, class initialization can take place
 // if name is NULL no check for class name in .class stream has to be made.
-symbolHandle class_name;
 if (name != NULL) {
 const int str_len = (int)strlen(name);
-if (str_len > symbolOopDesc::max_length()) {
+if (str_len > Symbol::max_length()) {
 // It's impossible to create this class;  the name cannot fit
 // into the constant pool.
 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
 }
-class_name = oopFactory::new_symbol_handle(name, str_len, CHECK_NULL);
+}
-}
+TempNewSymbol class_name = SymbolTable::new_symbol(name, THREAD);
 ResourceMark rm(THREAD);
 ClassFileStream st((u1*) buf, bufLen, NULL);
 Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
 bool first_time = first_time_FindClass;
 first_time_FindClass = false;
 // Sanity check the name:  it cannot be null or larger than the maximum size
 // name we can fit in the constant pool.
-if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {
+if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
 }
 //%note jni_3
 Handle loader;
 // in the correct class context.
 if (loader.is_null() &&
 k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
 JavaValue result(T_OBJECT);
 JavaCalls::call_static(&result, k,
-vmSymbolHandles::getFromClass_name(),
+vmSymbols::getFromClass_name(),
-vmSymbolHandles::void_class_signature(),
+vmSymbols::void_class_signature(),
 thread);
 if (HAS_PENDING_EXCEPTION) {
 Handle ex(thread, thread->pending_exception());
 CLEAR_PENDING_EXCEPTION;
 THROW_HANDLE_0(ex);
 } else {
 // We call ClassLoader.getSystemClassLoader to obtain the system class loader.
 loader = Handle(THREAD, SystemDictionary::java_system_loader());
 }
-symbolHandle sym = oopFactory::new_symbol_handle(name, CHECK_NULL);
+TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
 result = find_class_from_class_loader(env, sym, true, loader,
 protection_domain, true, thread);
 if (TraceClassResolution && result != NULL) {
 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
 DTRACE_PROBE3(hotspot_jni, ThrowNew__entry, env, clazz, message);
 jint ret = JNI_OK;
 DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
 instanceKlass* k = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
-symbolHandle name = symbolHandle(THREAD, k->name());
+Symbol*  name = k->name();
 Handle class_loader (THREAD,  k->class_loader());
 Handle protection_domain (THREAD, k->protection_domain());
 THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
 ShouldNotReachHere();
 JNI_END
 JavaValue result(T_VOID);
 JavaCalls::call_virtual(&result,
 ex,
 KlassHandle(THREAD,
 SystemDictionary::Throwable_klass()),
-vmSymbolHandles::printStackTrace_name(),
+vmSymbols::printStackTrace_name(),
-vmSymbolHandles::void_method_signature(),
+vmSymbols::void_method_signature(),
 THREAD);
 // If an exception is thrown in the call it gets thrown away. Not much
 // we can do with it. The native code that calls this, does not check
 // for the exception - hence, it might still be in the thread when DestroyVM gets
 // called, potentially causing a few asserts to trigger - since no pending exception
 virtual void get_long   () = 0;
 virtual void get_float  () = 0;
 virtual void get_double () = 0;
 virtual void get_object () = 0;
-JNI_ArgumentPusher(Thread *thread, symbolOop signature)
+JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) {
-: SignatureIterator(thread, signature) {
 this->_return_type = T_ILLEGAL;
 _arguments = NULL;
 }
 public:
 _ap = rap;
 #endif
 }
 public:
-JNI_ArgumentPusherVaArg(Thread *thread, symbolOop signature, va_list rap)
+JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap)
-: JNI_ArgumentPusher(thread, signature) {
+: JNI_ArgumentPusher(signature) {
 set_ap(rap);
 }
-JNI_ArgumentPusherVaArg(Thread *thread, jmethodID method_id, va_list rap)
+JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
-: JNI_ArgumentPusher(thread, JNIHandles::resolve_jmethod_id(method_id)->signature()) {
+: JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) {
 set_ap(rap);
 }
 // Optimized path if we have the bitvector form of signature
 void iterate( uint64_t fingerprint ) {
 inline void get_object() { _arguments->push_oop(Handle((oop *)(_ap++)->l, false)); }
 inline void set_ap(const jvalue *rap) { _ap = rap; }
 public:
-JNI_ArgumentPusherArray(Thread *thread, symbolOop signature, const jvalue *rap)
+JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap)
-: JNI_ArgumentPusher(thread, signature) {
+: JNI_ArgumentPusher(signature) {
 set_ap(rap);
 }
-JNI_ArgumentPusherArray(Thread *thread, jmethodID method_id, const jvalue *rap)
+JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
-: JNI_ArgumentPusher(thread, JNIHandles::resolve_jmethod_id(method_id)->signature()) {
+: JNI_ArgumentPusher(JNIHandles::resolve_jmethod_id(method_id)->signature()) {
 set_ap(rap);
 }
 // Optimized path if we have the bitvector form of signature
 void iterate( uint64_t fingerprint ) {
 assert(!method.is_null() , "method should not be null");
 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
 KlassHandle spec_klass (THREAD, method->method_holder());
-symbolHandle name (THREAD, method->name());
+Symbol*  name  = method->name();
-symbolHandle signature (THREAD, method->signature());
+Symbol*  signature  = method->signature();
 CallInfo info;
 LinkResolver::resolve_interface_call(info, recv, recv_klass,  spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
 return info.selected_method();
 }
 assert(!method.is_null() , "method should not be null");
 KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
 if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
 KlassHandle spec_klass (THREAD, method->method_holder());
-symbolHandle name (THREAD, method->name());
+Symbol*  name  = method->name();
-symbolHandle signature (THREAD, method->signature());
+Symbol*  signature  = method->signature();
 CallInfo info;
 LinkResolver::resolve_virtual_call(info, recv, recv_klass,  spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
 return info.selected_method();
 }
 args->set_java_argument_object(&java_args);
 assert(method->is_static(), "method should be static");
 // Fill out JavaCallArguments object
-args->iterate( Fingerprinter(THREAD, method).fingerprint() );
+args->iterate( Fingerprinter(method).fingerprint() );
 // Initialize result type
 result->set_type(args->get_ret_type());
 // Invoke the method. Result is returned as oop.
 JavaCalls::call(result, method, &java_args, CHECK);
 // handle arguments
 assert(!method->is_static(), "method should not be static");
 args->push_receiver(h_recv); // Push jobject handle
 // Fill out JavaCallArguments object
-args->iterate( Fingerprinter(THREAD, method).fingerprint() );
+args->iterate( Fingerprinter(method).fingerprint() );
 // Initialize result type
 result->set_type(args->get_ret_type());
 // Invoke the method. Result is returned as oop.
 JavaCalls::call(result, method, &java_args, CHECK);
 DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
 instanceOop i = alloc_object(clazz, CHECK_NULL);
 obj = JNIHandles::make_local(env, i);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherArray ap(THREAD, methodID, args);
+JNI_ArgumentPusherArray ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
 return obj;
 JNI_END
 DT_RETURN_MARK_DECL(NewObjectV, jobject);
 DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
 instanceOop i = alloc_object(clazz, CHECK_NULL);
 obj = JNIHandles::make_local(env, i);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
 return obj;
 JNI_END
 DT_RETURN_MARK_DECL(NewObject, jobject);
 instanceOop i = alloc_object(clazz, CHECK_NULL);
 obj = JNIHandles::make_local(env, i);
 va_list args;
 va_start(args, methodID);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
 va_end(args);
 return obj;
 JNI_END
 // %%%% This code should probably just call into a method in the LinkResolver
 //
 // The class should have been loaded (we have an instance of the class
 // passed in) so the method and signature should already be in the symbol
 // table.  If they're not there, the method doesn't exist.
-symbolHandle signature =
+const char *name_to_probe = (name_str == NULL)
-symbolHandle(THREAD, SymbolTable::probe(sig, (int)strlen(sig)));
+? vmSymbols::object_initializer_name()->as_C_string()
-symbolHandle name;
+: name_str;
-if (name_str == NULL) {
+TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
-name = vmSymbolHandles::object_initializer_name();
+TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
-} else {
-name = symbolHandle(THREAD,
+if (name == NULL || signature == NULL) {
-SymbolTable::probe(name_str, (int)strlen(name_str)));
-}
-if (name.is_null() || signature.is_null()) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
 }
 // Throw a NoSuchMethodError exception if we have an instance of a
 // primitive java.lang.Class
 // Make sure class is linked and initialized before handing id's out to
 // methodOops.
 Klass::cast(klass())->initialize(CHECK_NULL);
 methodOop m;
-if (name() == vmSymbols::object_initializer_name() ||
+if (name == vmSymbols::object_initializer_name() ||
-name() == vmSymbols::class_initializer_name()) {
+name == vmSymbols::class_initializer_name()) {
 // Never search superclasses for constructors
 if (klass->oop_is_instance()) {
-m = instanceKlass::cast(klass())->find_method(name(), signature());
+m = instanceKlass::cast(klass())->find_method(name, signature);
 } else {
 m = NULL;
 }
 } else {
-m = klass->lookup_method(name(), signature());
+m = klass->lookup_method(name, signature);
 // Look up interfaces
 if (m == NULL && klass->oop_is_instance()) {
-m = instanceKlass::cast(klass())->lookup_method_in_all_interfaces(name(),
+m = instanceKlass::cast(klass())->lookup_method_in_all_interfaces(name,
-signature());
+signature);
 }
 }
 if (m == NULL || (m->is_static() != is_static)) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
 }
 (const ResultType&)ret);\
 \
 va_list args; \
 va_start(args, methodID); \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
 va_end(args); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 ResultType ret = 0;\
 DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 \
 ResultType ret = 0;\
 DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherArray ap(THREAD, methodID, args); \
+JNI_ArgumentPusherArray ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END
 DT_VOID_RETURN_MARK(CallVoidMethod);
 va_list args;
 va_start(args, methodID);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
 va_end(args);
 JNI_END
 JNIWrapper("CallVoidMethodV");
 DTRACE_PROBE3(hotspot_jni, CallVoidMethodV__entry, env, obj, methodID);
 DT_VOID_RETURN_MARK(CallVoidMethodV);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
 JNI_END
 JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
 JNIWrapper("CallVoidMethodA");
 DTRACE_PROBE3(hotspot_jni, CallVoidMethodA__entry, env, obj, methodID);
 DT_VOID_RETURN_MARK(CallVoidMethodA);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherArray ap(THREAD, methodID, args);
+JNI_ArgumentPusherArray ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
 JNI_END
 #define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag) \
 (const ResultType&)ret);\
 \
 va_list args; \
 va_start(args, methodID); \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
 va_end(args); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 ResultType ret;\
 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 \
 ResultType ret;\
 DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherArray ap(THREAD, methodID, args); \
+JNI_ArgumentPusherArray ap(methodID, args); \
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END
 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
 va_list args;
 va_start(args, methodID);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
 va_end(args);
 JNI_END
 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodV__entry,
 env, obj, cls, methodID);
 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
 JNI_END
 JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
 JNIWrapper("CallNonvirtualVoidMethodA");
 DTRACE_PROBE4(hotspot_jni, CallNonvirtualVoidMethodA__entry,
 env, obj, cls, methodID);
 DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherArray ap(THREAD, methodID, args);
+JNI_ArgumentPusherArray ap(methodID, args);
 jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
 JNI_END
 #define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag) \
 (const ResultType&)ret);\
 \
 va_list args; \
 va_start(args, methodID); \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
 va_end(args); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 ResultType ret = 0;\
 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args); \
+JNI_ArgumentPusherVaArg ap(methodID, args); \
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END \
 \
 ResultType ret = 0;\
 DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
 (const ResultType&)ret);\
 \
 JavaValue jvalue(Tag); \
-JNI_ArgumentPusherArray ap(THREAD, methodID, args); \
+JNI_ArgumentPusherArray ap(methodID, args); \
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
 ret = jvalue.get_##ResultType(); \
 return ret;\
 JNI_END
 DT_VOID_RETURN_MARK(CallStaticVoidMethod);
 va_list args;
 va_start(args, methodID);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
 va_end(args);
 JNI_END
 JNIWrapper("CallStaticVoidMethodV");
 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodV__entry, env, cls, methodID);
 DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherVaArg ap(THREAD, methodID, args);
+JNI_ArgumentPusherVaArg ap(methodID, args);
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
 JNI_END
 JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
 JNIWrapper("CallStaticVoidMethodA");
 DTRACE_PROBE3(hotspot_jni, CallStaticVoidMethodA__entry, env, cls, methodID);
 DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
 JavaValue jvalue(T_VOID);
-JNI_ArgumentPusherArray ap(THREAD, methodID, args);
+JNI_ArgumentPusherArray ap(methodID, args);
 jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
 JNI_END
 //
 DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
 // The class should have been loaded (we have an instance of the class
 // passed in) so the field and signature should already be in the symbol
 // table.  If they're not there, the field doesn't exist.
-symbolHandle fieldname =
+TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
-symbolHandle(THREAD, SymbolTable::probe(name, (int)strlen(name)));
+TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
-symbolHandle signame   =
+if (fieldname == NULL || signame == NULL) {
-symbolHandle(THREAD, SymbolTable::probe(sig, (int)strlen(sig)));
-if (fieldname.is_null() || signame.is_null()) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
 }
 KlassHandle k(THREAD,
 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
 // Make sure class is initialized before handing id's out to fields
 Klass::cast(k())->initialize(CHECK_NULL);
 fieldDescriptor fd;
 if (!Klass::cast(k())->oop_is_instance() ||
-!instanceKlass::cast(k())->find_field(fieldname(), signame(), false, &fd)) {
+!instanceKlass::cast(k())->find_field(fieldname, signame, false, &fd)) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
 }
 // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
 // It may also have hash bits for k, if VerifyJNIFields is turned on.
 DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
 // The class should have been loaded (we have an instance of the class
 // passed in) so the field and signature should already be in the symbol
 // table.  If they're not there, the field doesn't exist.
-symbolHandle fieldname =
+TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
-symbolHandle(THREAD, SymbolTable::probe(name, (int)strlen(name)));
+TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
-symbolHandle signame   =
+if (fieldname == NULL || signame == NULL) {
-symbolHandle(THREAD, SymbolTable::probe(sig, (int)strlen(sig)));
-if (fieldname.is_null() || signame.is_null()) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
 }
 KlassHandle k(THREAD,
 java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(clazz)));
 // Make sure class is initialized before handing id's out to static fields
 Klass::cast(k())->initialize(CHECK_NULL);
 fieldDescriptor fd;
 if (!Klass::cast(k())->oop_is_instance() ||
-!instanceKlass::cast(k())->find_field(fieldname(), signame(), true, &fd)) {
+!instanceKlass::cast(k())->find_field(fieldname, signame, true, &fd)) {
 THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
 }
 // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the klassOop
 JNIid* id = instanceKlass::cast(fd.field_holder())->jni_id_for(fd.offset());
 // The RegisterNatives call being attempted tried to register with a method that
 // is not native.  Ask JVM TI what prefixes have been specified.  Then check
 // to see if the native method is now wrapped with the prefixes.  See the
 // SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
 static methodOop find_prefixed_native(KlassHandle k,
-symbolHandle name, symbolHandle signature, TRAPS) {
+Symbol* name, Symbol* signature, TRAPS) {
 ResourceMark rm(THREAD);
 methodOop method;
 int name_len = name->utf8_length();
 char* name_str = name->as_utf8();
 int prefix_count;
 // try adding this prefix to the method name and see if it matches another method name
 int trial_len = name_len + prefix_len;
 char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
 strcpy(trial_name_str, prefix);
 strcat(trial_name_str, name_str);
-symbolHandle trial_name(THREAD, SymbolTable::probe(trial_name_str, trial_len));
+TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
-if (trial_name.is_null()) {
+if (trial_name == NULL) {
 continue; // no such symbol, so this prefix wasn't used, try the next prefix
 }
-method = Klass::cast(k())->lookup_method(trial_name(), signature());
+method = Klass::cast(k())->lookup_method(trial_name, signature);
 if (method == NULL) {
 continue; // signature doesn't match, try the next prefix
 }
 if (method->is_native()) {
 method->set_is_prefixed_native();
 name_str = trial_name_str;
 }
 return NULL; // not found
 }
-static bool register_native(KlassHandle k, symbolHandle name, symbolHandle signature, address entry, TRAPS) {
+static bool register_native(KlassHandle k, Symbol* name, Symbol* signature, address entry, TRAPS) {
-methodOop method = Klass::cast(k())->lookup_method(name(), signature());
+methodOop method = Klass::cast(k())->lookup_method(name, signature);
 if (method == NULL) {
 ResourceMark rm;
 stringStream st;
 st.print("Method %s name or signature does not match",
-methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name(), signature()));
+methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature));
 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
 }
 if (!method->is_native()) {
 // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
 method = find_prefixed_native(k, name, signature, THREAD);
 if (method == NULL) {
 ResourceMark rm;
 stringStream st;
 st.print("Method %s is not declared as native",
-methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name(), signature()));
+methodOopDesc::name_and_sig_as_C_string(Klass::cast(k()), name, signature));
 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
 }
 }
 if (entry != NULL) {
 int meth_name_len = (int)strlen(meth_name);
 // The class should have been loaded (we have an instance of the class
 // passed in) so the method and signature should already be in the symbol
 // table.  If they're not there, the method doesn't exist.
-symbolHandle name(THREAD, SymbolTable::probe(meth_name, meth_name_len));
+TempNewSymbol  name = SymbolTable::probe(meth_name, meth_name_len);
-symbolHandle signature(THREAD, SymbolTable::probe(meth_sig, (int)strlen(meth_sig)));
+TempNewSymbol  signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
-if (name.is_null() || signature.is_null()) {
+if (name == NULL || signature == NULL) {
 ResourceMark rm;
 stringStream st;
 st.print("Method %s.%s%s not found", Klass::cast(h_k())->external_name(), meth_name, meth_sig);
 // Must return negative value on failure
 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
 static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
 Handle loader;            // null (bootstrap) loader
 Handle protection_domain; // null protection domain
-symbolHandle sym = oopFactory::new_symbol_handle(name, CHECK_NULL);
+TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
 jclass result =  find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
 if (TraceClassResolution && result != NULL) {
 trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
 }

changeset 8076	96d498ec7ae1
parent 7414	940d84ca7fca
child 8725	8c1e3dd5fe1b