truffle: src/share/vm/prims/jvm.cpp comparison

comparison src/share/vm/prims/jvm.cpp @ 2177:3582bf76420e

6990754: Use native memory and reference counting to implement SymbolTable Summary: move symbols from permgen into C heap and reference count them Reviewed-by: never, acorn, jmasa, stefank

author	coleenp
date	Thu, 27 Jan 2011 16:11:27 -0800
parents	ccfcb502af3f
children	d70fe6ab4436

comparison

equal deleted inserted replaced

-:27e4ea99855d
+:3582bf76420e
 JavaThread* jthread = JavaThread::current();
 if (jthread->has_last_Java_frame()) {
 vframeStream vfst(jthread);
 // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames
-symbolHandle access_controller = oopFactory::new_symbol_handle("java/security/AccessController", CHECK);
+TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);
 klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);
-symbolHandle privileged_action = oopFactory::new_symbol_handle("java/security/PrivilegedAction", CHECK);
+TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);
 klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);
 methodOop last_caller = NULL;
 while (!vfst.at_end()) {
 line_number = vfst.method()->line_number_from_bci(vfst.bci());
 if (line_number == -1) {
 // show method name if it's a native method
 trace = vfst.method()->name_and_sig_as_C_string();
 }
-symbolOop s = instanceKlass::cast(caller)->source_file_name();
+Symbol* s = instanceKlass::cast(caller)->source_file_name();
 if (s != NULL) {
 source_file = s->as_C_string();
 }
 }
 }
 Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);
 Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);
 JavaCalls::call_virtual(&r,
 props,
 KlassHandle(THREAD, SystemDictionary::Properties_klass()),
-vmSymbolHandles::put_name(),
+vmSymbols::put_name(),
-vmSymbolHandles::object_object_object_signature(),
+vmSymbols::object_object_object_signature(),
 key_str,
 value_str,
 THREAD);
 }
 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,
 const char* name))
 JVMWrapper2("JVM_FindClassFromBootLoader %s", name);
 // Java libraries should ensure that name is never null...
-if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {
+if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
 // It's impossible to create this class;  the name cannot fit
 // into the constant pool.
 return NULL;
 }
-symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL);
+TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
 klassOop k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);
 if (k == NULL) {
 return NULL;
 }
 jboolean init, jobject loader,
 jboolean throwError))
 JVMWrapper3("JVM_FindClassFromClassLoader %s throw %s", name,
 throwError ? "error" : "exception");
 // Java libraries should ensure that name is never null...
-if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {
+if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
 // It's impossible to create this class;  the name cannot fit
 // into the constant pool.
 if (throwError) {
 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
 } else {
 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name);
 }
 }
-symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL);
+TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
 Handle h_loader(THREAD, JNIHandles::resolve(loader));
 jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
 Handle(), throwError, THREAD);
 if (TraceClassResolution && result != NULL) {
 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,
 jboolean init, jclass from))
 JVMWrapper2("JVM_FindClassFromClass %s", name);
-if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {
+if (name == NULL || (int)strlen(name) > 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);
 }
-symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL);
+TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
 oop from_class_oop = JNIHandles::resolve(from);
 klassOop from_class = (from_class_oop == NULL)
 ? (klassOop)NULL
 : java_lang_Class::as_klassOop(from_class_oop);
 oop class_loader = NULL;
 ClassLoader::perf_app_classfile_bytes_read()->inc(len);
 }
 // 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;
+TempNewSymbol class_name = NULL;
 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);
+class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL);
 }
 ResourceMark rm(THREAD);
 ClassFileStream st((u1*) buf, len, (char *)source);
 Handle class_loader (THREAD, JNIHandles::resolve(loader));
 const char* str   = java_lang_String::as_utf8_string(string());
 // Sanity check, don't expect null
 if (str == NULL) return NULL;
 const int str_len = (int)strlen(str);
-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.
 return NULL;
 }
-symbolHandle klass_name = oopFactory::new_symbol_handle(str, str_len,CHECK_NULL);
+TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL);
 // Security Note:
 //   The Java level wrapper will perform the necessary security check allowing
 //   us to pass the NULL as the initiating class loader.
 Handle h_loader(THREAD, JNIHandles::resolve(loader));
 if ( pending_exception->is_a(SystemDictionary::Exception_klass()) &&
 !pending_exception->is_a(SystemDictionary::RuntimeException_klass())) {
 // Throw a java.security.PrivilegedActionException(Exception e) exception
 JavaCallArguments args(pending_exception);
-THROW_ARG_0(vmSymbolHandles::java_security_PrivilegedActionException(),
+THROW_ARG_0(vmSymbols::java_security_PrivilegedActionException(),
-vmSymbolHandles::exception_void_signature(),
+vmSymbols::exception_void_signature(),
 &args);
 }
 }
 if (pending_exception.not_null()) THROW_OOP_0(pending_exception());
 ResourceMark rm(THREAD);
 // Return null for arrays and primatives
 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
 if (Klass::cast(k)->oop_is_instance()) {
-symbolHandle sym = symbolHandle(THREAD, instanceKlass::cast(k)->generic_signature());
+Symbol* sym = instanceKlass::cast(k)->generic_signature();
-if (sym.is_null()) return NULL;
+if (sym == NULL) return NULL;
 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
 return (jstring) JNIHandles::make_local(env, str());
 }
 }
 return NULL;
 } else {
 k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);
 if (k_o == NULL) return NULL;
 }
 instanceKlassHandle k(THREAD, k_o);
-symbolOop name = cp->uncached_name_ref_at(index);
+Symbol* name = cp->uncached_name_ref_at(index);
-symbolOop sig  = cp->uncached_signature_ref_at(index);
+Symbol* sig  = cp->uncached_signature_ref_at(index);
 methodHandle m (THREAD, k->find_method(name, sig));
 if (m.is_null()) {
 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
 }
 oop method;
 } else {
 k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);
 if (k_o == NULL) return NULL;
 }
 instanceKlassHandle k(THREAD, k_o);
-symbolOop name = cp->uncached_name_ref_at(index);
+Symbol* name = cp->uncached_name_ref_at(index);
-symbolOop sig  = cp->uncached_signature_ref_at(index);
+Symbol* sig  = cp->uncached_signature_ref_at(index);
 fieldDescriptor fd;
 klassOop target_klass = k->find_field(name, sig, &fd);
 if (target_klass == NULL) {
 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
 }
 constantTag tag = cp->tag_at(index);
 if (!tag.is_field_or_method()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 int klass_ref = cp->uncached_klass_ref_index_at(index);
-symbolHandle klass_name (THREAD, cp->klass_name_at(klass_ref));
+Symbol*  klass_name  = cp->klass_name_at(klass_ref);
-symbolHandle member_name(THREAD, cp->uncached_name_ref_at(index));
+Symbol*  member_name = cp->uncached_name_ref_at(index);
-symbolHandle member_sig (THREAD, cp->uncached_signature_ref_at(index));
+Symbol*  member_sig  = cp->uncached_signature_ref_at(index);
 objArrayOop  dest_o = oopFactory::new_objArray(SystemDictionary::String_klass(), 3, CHECK_NULL);
 objArrayHandle dest(THREAD, dest_o);
 Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
 dest->obj_at_put(0, str());
 str = java_lang_String::create_from_symbol(member_name, CHECK_NULL);
 bounds_check(cp, index, CHECK_NULL);
 constantTag tag = cp->tag_at(index);
 if (!tag.is_symbol()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
-symbolOop sym_o = cp->symbol_at(index);
+Symbol* sym = cp->symbol_at(index);
-symbolHandle sym(THREAD, sym_o);
 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
 return (jstring) JNIHandles::make_local(str());
 }
 JVM_END
 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
 JVMWrapper("JVM_GetCPClassNameUTF");
 klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 constantPoolOop cp = instanceKlass::cast(k)->constants();
-symbolOop classname = cp->klass_name_at(cp_index);
+Symbol* classname = cp->klass_name_at(cp_index);
 return classname->as_utf8();
 JVM_END
 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
 constantPoolOop cp = instanceKlass::cast(k)->constants();
 switch (cp->tag_at(cp_index).value()) {
 case JVM_CONSTANT_Fieldref: {
 int class_index = cp->uncached_klass_ref_index_at(cp_index);
-symbolOop classname = cp->klass_name_at(class_index);
+Symbol* classname = cp->klass_name_at(class_index);
 return classname->as_utf8();
 }
 default:
 fatal("JVM_GetCPFieldClassNameUTF: illegal constant");
 }
 constantPoolOop cp = instanceKlass::cast(k)->constants();
 switch (cp->tag_at(cp_index).value()) {
 case JVM_CONSTANT_Methodref:
 case JVM_CONSTANT_InterfaceMethodref: {
 int class_index = cp->uncached_klass_ref_index_at(cp_index);
-symbolOop classname = cp->klass_name_at(class_index);
+Symbol* classname = cp->klass_name_at(class_index);
 return classname->as_utf8();
 }
 default:
 fatal("JVM_GetCPMethodClassNameUTF: illegal constant");
 }
 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
 constantPoolOop cp = instanceKlass::cast(k)->constants();
 constantPoolOop cp_called = instanceKlass::cast(k_called)->constants();
 switch (cp->tag_at(cp_index).value()) {
 case JVM_CONSTANT_Fieldref: {
-symbolOop name      = cp->uncached_name_ref_at(cp_index);
+Symbol* name      = cp->uncached_name_ref_at(cp_index);
-symbolOop signature = cp->uncached_signature_ref_at(cp_index);
+Symbol* signature = cp->uncached_signature_ref_at(cp_index);
 typeArrayOop fields = instanceKlass::cast(k_called)->fields();
 int fields_count = fields->length();
 for (int i = 0; i < fields_count; i += instanceKlass::next_offset) {
 if (cp_called->symbol_at(fields->ushort_at(i + instanceKlass::name_index_offset)) == name &&
 cp_called->symbol_at(fields->ushort_at(i + instanceKlass::signature_index_offset)) == signature) {
 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
 constantPoolOop cp = instanceKlass::cast(k)->constants();
 switch (cp->tag_at(cp_index).value()) {
 case JVM_CONSTANT_Methodref:
 case JVM_CONSTANT_InterfaceMethodref: {
-symbolOop name      = cp->uncached_name_ref_at(cp_index);
+Symbol* name      = cp->uncached_name_ref_at(cp_index);
-symbolOop signature = cp->uncached_signature_ref_at(cp_index);
+Symbol* signature = cp->uncached_signature_ref_at(cp_index);
 objArrayOop methods = instanceKlass::cast(k_called)->methods();
 int methods_count = methods->length();
 for (int i = 0; i < methods_count; i++) {
 methodOop method = methodOop(methods->obj_at(i));
 if (method->name() == name && method->signature() == signature) {
 Handle obj(THREAD, thread->threadObj());
 JavaValue result(T_VOID);
 JavaCalls::call_virtual(&result,
 obj,
 KlassHandle(THREAD, SystemDictionary::Thread_klass()),
-vmSymbolHandles::run_method_name(),
+vmSymbols::run_method_name(),
-vmSymbolHandles::void_method_signature(),
+vmSymbols::void_method_signature(),
 THREAD);
 }
 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
 ResourceMark rm(THREAD);
 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
 Handle class_name_str = java_lang_String::internalize_classname(h_name, CHECK_0);
 const char* str = java_lang_String::as_utf8_string(class_name_str());
-symbolHandle class_name_sym =
+TempNewSymbol class_name_sym = SymbolTable::probe(str, (int)strlen(str));
-symbolHandle(THREAD, SymbolTable::probe(str, (int)strlen(str)));
+if (class_name_sym == NULL) {
-if (class_name_sym.is_null()) {
 return -1;
 }
 int depth = 0;
 for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
 if (!vfst.method()->is_native()) {
 klassOop holder = vfst.method()->method_holder();
 assert(holder->is_klass(), "just checking");
-if (instanceKlass::cast(holder)->name() == class_name_sym()) {
+if (instanceKlass::cast(holder)->name() == class_name_sym) {
 return depth;
 }
 depth++;
 }
 }
 Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName));
 Handle string = java_lang_String::internalize_classname(classname, CHECK_NULL);
 const char* str = java_lang_String::as_utf8_string(string());
-if (str == NULL || (int)strlen(str) > symbolOopDesc::max_length()) {
+if (str == NULL || (int)strlen(str) > 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(), str);
 }
-symbolHandle name = oopFactory::new_symbol_handle(str, CHECK_NULL);
+TempNewSymbol name = SymbolTable::new_symbol(str, CHECK_NULL);
 Handle curr_klass (THREAD, JNIHandles::resolve(currClass));
 // Find the most recent class on the stack with a non-null classloader
 oop loader = NULL;
 oop protection_domain = NULL;
 if (curr_klass.is_null()) {
 JVM_END
 // Shared JNI/JVM entry points //////////////////////////////////////////////////////////////
-jclass find_class_from_class_loader(JNIEnv* env, symbolHandle name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS) {
+jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS) {
 // Security Note:
 //   The Java level wrapper will perform the necessary security check allowing
 //   us to pass the NULL as the initiating class loader.
 klassOop klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
 JvmtiVMObjectAllocEventCollector oam;
 if (name == NULL) return NULL;
 Handle str (THREAD, JNIHandles::resolve_non_null(name));
 const char* cstr = java_lang_String::as_utf8_string(str());
-symbolHandle field_name =
+TempNewSymbol field_name = SymbolTable::probe(cstr, (int)strlen(cstr));
-symbolHandle(THREAD, SymbolTable::probe(cstr, (int)strlen(cstr)));
+if (field_name == NULL) {
-if (field_name.is_null()) {
 THROW_0(vmSymbols::java_lang_NoSuchFieldException());
 }
 oop mirror = JNIHandles::resolve_non_null(cls);
-oop result = Reflection::reflect_field(mirror, field_name(), which, CHECK_NULL);
+oop result = Reflection::reflect_field(mirror, field_name, which, CHECK_NULL);
 if (result == NULL) {
 THROW_0(vmSymbols::java_lang_NoSuchFieldException());
 }
 return JNIHandles::make_local(env, result);
 JVM_END
 THROW_0(vmSymbols::java_lang_NullPointerException());
 }
 Handle str (THREAD, JNIHandles::resolve_non_null(name));
 const char* cstr = java_lang_String::as_utf8_string(str());
-symbolHandle method_name =
+TempNewSymbol method_name = SymbolTable::probe(cstr, (int)strlen(cstr));
-symbolHandle(THREAD, SymbolTable::probe(cstr, (int)strlen(cstr)));
+if (method_name == NULL) {
-if (method_name.is_null()) {
 THROW_0(vmSymbols::java_lang_NoSuchMethodException());
 }
 oop mirror = JNIHandles::resolve_non_null(cls);
 objArrayHandle tarray (THREAD, objArrayOop(JNIHandles::resolve(types)));
 objArrayHandle dest(THREAD, dest_o);
 klassOop enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
 dest->obj_at_put(0, Klass::cast(enc_k)->java_mirror());
 int encl_method_method_idx = ik_h->enclosing_method_method_index();
 if (encl_method_method_idx != 0) {
-symbolOop sym_o = ik_h->constants()->symbol_at(
+Symbol* sym = ik_h->constants()->symbol_at(
 extract_low_short_from_int(
 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
-symbolHandle sym(THREAD, sym_o);
 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
 dest->obj_at_put(1, str());
-sym_o = ik_h->constants()->symbol_at(
+sym = ik_h->constants()->symbol_at(
 extract_high_short_from_int(
 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
-sym = symbolHandle(THREAD, sym_o);
 str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
 dest->obj_at_put(2, str());
 }
 return (jobjectArray) JNIHandles::make_local(dest());
 }

Mercurial > hg > truffle

comparison src/share/vm/prims/jvm.cpp @ 2177:3582bf76420e