truffle: src/share/vm/classfile/systemDictionary.cpp comparison

comparison src/share/vm/classfile/systemDictionary.cpp @ 2181:d25d4ca69222

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Wed, 16 Feb 2011 13:47:20 +0100
parents	06f017f7daa7 3582bf76420e
children	2ab52cda08e5

comparison

equal deleted inserted replaced

-:50b45e2d9725
+:d25d4ca69222
 void SystemDictionary::compute_java_system_loader(TRAPS) {
 KlassHandle system_klass(THREAD, WK_KLASS(ClassLoader_klass));
 JavaValue result(T_OBJECT);
 JavaCalls::call_static(&result,
 KlassHandle(THREAD, WK_KLASS(ClassLoader_klass)),
-vmSymbolHandles::getSystemClassLoader_name(),
+vmSymbols::getSystemClassLoader_name(),
-vmSymbolHandles::void_classloader_signature(),
+vmSymbols::void_classloader_signature(),
 CHECK);
 _java_system_loader = (oop)result.get_jobject();
 }
 // debugging
 #ifdef ASSERT
 // return true if class_name contains no '.' (internal format is '/')
-bool SystemDictionary::is_internal_format(symbolHandle class_name) {
+bool SystemDictionary::is_internal_format(Symbol* class_name) {
-if (class_name.not_null()) {
+if (class_name != NULL) {
 ResourceMark rm;
 char* name = class_name->as_C_string();
 return strchr(name, '.') == NULL;
 } else {
 return true;
 // ----------------------------------------------------------------------------
 // Resolving of classes
 // Forwards to resolve_or_null
-klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {
+klassOop SystemDictionary::resolve_or_fail(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, TRAPS) {
 klassOop klass = resolve_or_null(class_name, class_loader, protection_domain, THREAD);
 if (HAS_PENDING_EXCEPTION || klass == NULL) {
 KlassHandle k_h(THREAD, klass);
 // can return a null klass
 klass = handle_resolution_exception(class_name, class_loader, protection_domain, throw_error, k_h, THREAD);
 }
 return klass;
 }
-klassOop SystemDictionary::handle_resolution_exception(symbolHandle class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) {
+klassOop SystemDictionary::handle_resolution_exception(Symbol* class_name, Handle class_loader, Handle protection_domain, bool throw_error, KlassHandle klass_h, TRAPS) {
 if (HAS_PENDING_EXCEPTION) {
 // If we have a pending exception we forward it to the caller, unless throw_error is true,
 // in which case we have to check whether the pending exception is a ClassNotFoundException,
 // and if so convert it to a NoClassDefFoundError
 // And chain the original ClassNotFoundException
 }
 return (klassOop)klass_h();
 }
-klassOop SystemDictionary::resolve_or_fail(symbolHandle class_name,
+klassOop SystemDictionary::resolve_or_fail(Symbol* class_name,
 bool throw_error, TRAPS)
 {
 return resolve_or_fail(class_name, Handle(), Handle(), throw_error, THREAD);
 }
 // Forwards to resolve_instance_class_or_null
-klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {
+klassOop SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) {
 // (tw) May we do this?
-// assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");
+//assert(!THREAD->is_Compiler_thread(), "Can not load classes with the Compiler thread");
-if (FieldType::is_array(class_name())) {
+if (FieldType::is_array(class_name)) {
 return resolve_array_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
+} else if (FieldType::is_obj(class_name)) {
+ResourceMark rm(THREAD);
+// Ignore wrapping L and ;.
+TempNewSymbol name = SymbolTable::new_symbol(class_name->as_C_string() + 1,
+class_name->utf8_length() - 2, CHECK_NULL);
+return resolve_instance_class_or_null(name, class_loader, protection_domain, CHECK_NULL);
 } else {
 return resolve_instance_class_or_null(class_name, class_loader, protection_domain, CHECK_NULL);
 }
 }
-klassOop SystemDictionary::resolve_or_null(symbolHandle class_name, TRAPS) {
+klassOop SystemDictionary::resolve_or_null(Symbol* class_name, TRAPS) {
 return resolve_or_null(class_name, Handle(), Handle(), THREAD);
 }
 // Forwards to resolve_instance_class_or_null
-klassOop SystemDictionary::resolve_array_class_or_null(symbolHandle class_name,
+klassOop SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 TRAPS) {
-assert(FieldType::is_array(class_name()), "must be array");
+assert(FieldType::is_array(class_name), "must be array");
-jint dimension;
-symbolOop object_key;
 klassOop k = NULL;
-// dimension and object_key are assigned as a side-effect of this call
+FieldArrayInfo fd;
-BasicType t = FieldType::get_array_info(class_name(),
+// dimension and object_key in FieldArrayInfo are assigned as a side-effect
-&dimension,
+// of this call
-&object_key,
+BasicType t = FieldType::get_array_info(class_name, fd, CHECK_NULL);
-CHECK_NULL);
 if (t == T_OBJECT) {
-symbolHandle h_key(THREAD, object_key);
 // naked oop "k" is OK here -- we assign back into it
-k = SystemDictionary::resolve_instance_class_or_null(h_key,
+k = SystemDictionary::resolve_instance_class_or_null(fd.object_key(),
 class_loader,
 protection_domain,
 CHECK_NULL);
 if (k != NULL) {
-k = Klass::cast(k)->array_klass(dimension, CHECK_NULL);
+k = Klass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
 }
 } else {
 k = Universe::typeArrayKlassObj(t);
-k = typeArrayKlass::cast(k)->array_klass(dimension, CHECK_NULL);
+k = typeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
 }
 return k;
 }
 //      4.3 calls resolve_super_or_fail Super in parallel on own thread T2
 //      4.4 finds T2, Super -> throws class circularity
 // Must be called, even if superclass is null, since this is
 // where the placeholder entry is created which claims this
 // thread is loading this class/classloader.
-klassOop SystemDictionary::resolve_super_or_fail(symbolHandle child_name,
+klassOop SystemDictionary::resolve_super_or_fail(Symbol* child_name,
-symbolHandle class_name,
+Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 bool is_superclass,
 TRAPS) {
 // Try to get one of the well-known klasses.
 // They are trusted, and do not participate in circularities.
 if (LinkWellKnownClasses) {
-klassOop k = find_well_known_klass(class_name());
+klassOop k = find_well_known_klass(class_name);
 if (k != NULL) {
 return k;
 }
 }
 // so we don't throw an exception here.
 // see: nsk redefclass014 & java.lang.instrument Instrument032
 if ((childk != NULL ) && (is_superclass) &&
 ((quicksuperk = instanceKlass::cast(childk)->super()) != NULL) &&
-((Klass::cast(quicksuperk)->name() == class_name()) &&
+((Klass::cast(quicksuperk)->name() == class_name) &&
 (Klass::cast(quicksuperk)->class_loader()  == class_loader()))) {
 return quicksuperk;
 } else {
 PlaceholderEntry* probe = placeholders()->get_entry(p_index, p_hash, child_name, class_loader);
 if (probe && probe->check_seen_thread(THREAD, PlaceholderTable::LOAD_SUPER)) {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_ClassCircularityError(), child_name->as_C_string());
 }
 // java.lang.Object should have been found above
-assert(class_name() != NULL, "null super class for resolving");
+assert(class_name != NULL, "null super class for resolving");
 // Resolve the super class or interface, check results on return
 klassOop superk = NULL;
 superk = SystemDictionary::resolve_or_null(class_name,
 class_loader,
 protection_domain,
 KlassHandle system_loader(THREAD, SystemDictionary::ClassLoader_klass());
 JavaCalls::call_special(&result,
 class_loader,
 system_loader,
-vmSymbolHandles::checkPackageAccess_name(),
+vmSymbols::checkPackageAccess_name(),
-vmSymbolHandles::class_protectiondomain_signature(),
+vmSymbols::class_protectiondomain_signature(),
 Handle(THREAD, klass->java_mirror()),
 protection_domain,
 THREAD);
 if (TraceProtectionDomainVerification) {
 // If no exception has been thrown, we have validated the protection domain
 // Insert the protection domain of the initiating class into the set.
 {
 // We recalculate the entry here -- we've called out to java since
 // the last time it was calculated.
-symbolHandle kn(THREAD, klass->name());
+Symbol*  kn = klass->name();
 unsigned int d_hash = dictionary()->compute_hash(kn, class_loader);
 int d_index = dictionary()->hash_to_index(d_hash);
 MutexLocker mu(SystemDictionary_lock, THREAD);
 {
 // Caller must check for pending exception
 // Returns non-null klassOop if other thread has completed load
 // and we are done,
 // If return null klassOop and no pending exception, the caller must load the class
 instanceKlassHandle SystemDictionary::handle_parallel_super_load(
-symbolHandle name, symbolHandle superclassname, Handle class_loader,
+Symbol* name, Symbol* superclassname, Handle class_loader,
 Handle protection_domain, Handle lockObject, TRAPS) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
 unsigned int d_hash = dictionary()->compute_hash(name, class_loader);
 int d_index = dictionary()->hash_to_index(d_hash);
 }
 return (nh);
 }
-klassOop SystemDictionary::resolve_instance_class_or_null(symbolHandle class_name, Handle class_loader, Handle protection_domain, TRAPS) {
+klassOop SystemDictionary::resolve_instance_class_or_null(Symbol* name, Handle class_loader, Handle protection_domain, TRAPS) {
-assert(class_name.not_null() && !FieldType::is_array(class_name()), "invalid class name");
+assert(name != NULL && !FieldType::is_array(name) &&
-// First check to see if we should remove wrapping L and ;
+!FieldType::is_obj(name), "invalid class name");
-symbolHandle name;
-if (FieldType::is_obj(class_name())) {
-ResourceMark rm(THREAD);
-// Ignore wrapping L and ;.
-name = oopFactory::new_symbol_handle(class_name()->as_C_string() + 1, class_name()->utf8_length() - 2, CHECK_NULL);
-} else {
-name = class_name;
-}
 // UseNewReflection
 // Fix for 4474172; see evaluation for more details
 class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
 bool class_has_been_loaded   = false;
 bool super_load_in_progress  = false;
 bool havesupername = false;
 instanceKlassHandle k;
 PlaceholderEntry* placeholder;
-symbolHandle superclassname;
+Symbol* superclassname = NULL;
 {
 MutexLocker mu(SystemDictionary_lock, THREAD);
 klassOop check = find_class(d_index, d_hash, name, class_loader);
 if (check != NULL) {
 } else {
 placeholder = placeholders()->get_entry(p_index, p_hash, name, class_loader);
 if (placeholder && placeholder->super_load_in_progress()) {
 super_load_in_progress = true;
 if (placeholder->havesupername() == true) {
-superclassname = symbolHandle(THREAD, placeholder->supername());
+superclassname = placeholder->supername();
 havesupername = true;
 }
 }
 }
 }
 //    This classloader supports parallelism at the classloader level,
 //    but only allows a single load of a class/classloader pair.
 //    No performance benefit and no deadlock issues.
 // case 5. parallelCapable user level classloaders - without objectLocker
 //    Allow parallel classloading of a class/classloader pair
-symbolHandle nullsymbolHandle;
 bool throw_circularity_error = false;
 {
 MutexLocker mu(SystemDictionary_lock, THREAD);
 if (class_loader.is_null() || !is_parallelCapable(class_loader)) {
 PlaceholderEntry* oldprobe = placeholders()->get_entry(p_index, p_hash, name, class_loader);
 // All cases: add LOAD_INSTANCE
 // case 3: UnsyncloadClass || case 5: parallelCapable: allow competing threads to try
 // LOAD_INSTANCE in parallel
 // add placeholder entry even if error - callers will remove on error
 if (!throw_circularity_error && !class_has_been_loaded) {
-PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, class_loader, PlaceholderTable::LOAD_INSTANCE, nullsymbolHandle, THREAD);
+PlaceholderEntry* newprobe = placeholders()->find_and_add(p_index, p_hash, name, class_loader, PlaceholderTable::LOAD_INSTANCE, NULL, THREAD);
 // For class loaders that do not acquire the classloader object lock,
 // if they did not catch another thread holding LOAD_INSTANCE,
 // need a check analogous to the acquire ObjectLocker/find_class
 // i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL
 // one final check if the load has already completed
 #ifdef ASSERT
 {
 Handle loader (THREAD, k->class_loader());
 MutexLocker mu(SystemDictionary_lock, THREAD);
-oop kk = find_class_or_placeholder(name, loader);
+oop kk = find_class(name, loader);
 assert(kk == k(), "should be present in dictionary");
 }
 #endif
 // return if the protection domain in NULL
 //
 // Callers should be aware that an entry could be added just after
 // _dictionary->bucket(index) is read here, so the caller will not see
 // the new entry.
-klassOop SystemDictionary::find(symbolHandle class_name,
+klassOop SystemDictionary::find(Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 TRAPS) {
 // UseNewReflection
 }
 // Look for a loaded instance or array klass by name.  Do not do any loading.
 // return NULL in case of error.
-klassOop SystemDictionary::find_instance_or_array_klass(symbolHandle class_name,
+klassOop SystemDictionary::find_instance_or_array_klass(Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 TRAPS) {
 klassOop k = NULL;
-assert(class_name() != NULL, "class name must be non NULL");
+assert(class_name != NULL, "class name must be non NULL");
 // Try to get one of the well-known klasses.
 if (LinkWellKnownClasses) {
-k = find_well_known_klass(class_name());
+k = find_well_known_klass(class_name);
 if (k != NULL) {
 return k;
 }
 }
-if (FieldType::is_array(class_name())) {
+if (FieldType::is_array(class_name)) {
 // The name refers to an array.  Parse the name.
-jint dimension;
+// dimension and object_key in FieldArrayInfo are assigned as a
-symbolOop object_key;
+// side-effect of this call
+FieldArrayInfo fd;
-// dimension and object_key are assigned as a side-effect of this call
+BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL));
-BasicType t = FieldType::get_array_info(class_name(), &dimension,
-&object_key, CHECK_(NULL));
 if (t != T_OBJECT) {
 k = Universe::typeArrayKlassObj(t);
 } else {
-symbolHandle h_key(THREAD, object_key);
+k = SystemDictionary::find(fd.object_key(), class_loader, protection_domain, THREAD);
-k = SystemDictionary::find(h_key, class_loader, protection_domain, THREAD);
 }
 if (k != NULL) {
-k = Klass::cast(k)->array_klass_or_null(dimension);
+k = Klass::cast(k)->array_klass_or_null(fd.dimension());
 }
 } else {
 k = find(class_name, class_loader, protection_domain, THREAD);
 }
 return k;
 }
 // Quick range check for names of well-known classes:
-static symbolOop wk_klass_name_limits[2] = {NULL, NULL};
+static Symbol* wk_klass_name_limits[2] = {NULL, NULL};
 #ifndef PRODUCT
 static int find_wkk_calls, find_wkk_probes, find_wkk_wins;
 // counts for "hello world": 3983, 1616, 1075
 //  => 60% hit after limit guard, 25% total win rate
 #endif
-klassOop SystemDictionary::find_well_known_klass(symbolOop class_name) {
+klassOop SystemDictionary::find_well_known_klass(Symbol* class_name) {
 // A bounds-check on class_name will quickly get a negative result.
 NOT_PRODUCT(find_wkk_calls++);
 if (class_name >= wk_klass_name_limits[0] &&
 class_name <= wk_klass_name_limits[1]) {
 NOT_PRODUCT(find_wkk_probes++);
 }
 // Note: this method is much like resolve_from_stream, but
 // updates no supplemental data structures.
 // TODO consolidate the two methods with a helper routine?
-klassOop SystemDictionary::parse_stream(symbolHandle class_name,
+klassOop SystemDictionary::parse_stream(Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 ClassFileStream* st,
 KlassHandle host_klass,
 GrowableArray<Handle>* cp_patches,
 TRAPS) {
-symbolHandle parsed_name;
+TempNewSymbol parsed_name = NULL;
 // Parse the stream. Note that we do this even though this klass might
 // already be present in the SystemDictionary, otherwise we would not
 // throw potential ClassFormatErrors.
 //
 cp_patches,
 parsed_name,
 true,
 THREAD);
 // We don't redefine the class, so we just need to clean up whether there
 // was an error or not (don't want to modify any system dictionary
 // data structures).
 // Parsed name could be null if we threw an error before we got far
 // enough along to parse it -- in that case, there is nothing to clean up.
-if (!parsed_name.is_null()) {
+if (parsed_name != NULL) {
 unsigned int p_hash = placeholders()->compute_hash(parsed_name,
 class_loader);
 int p_index = placeholders()->hash_to_index(p_hash);
 {
 MutexLocker mu(SystemDictionary_lock, THREAD);
 // Add a klass to the system from a stream (called by jni_DefineClass and
 // JVM_DefineClass).
 // Note: class_name can be NULL. In that case we do not know the name of
 // the class until we have parsed the stream.
-klassOop SystemDictionary::resolve_from_stream(symbolHandle class_name,
+klassOop SystemDictionary::resolve_from_stream(Symbol* class_name,
 Handle class_loader,
 Handle protection_domain,
 ClassFileStream* st,
 bool verify,
 TRAPS) {
 // Make sure we are synchronized on the class loader before we proceed
 Handle lockObject = compute_loader_lock_object(class_loader, THREAD);
 check_loader_lock_contention(lockObject, THREAD);
 ObjectLocker ol(lockObject, THREAD, DoObjectLock);
-symbolHandle parsed_name;
+TempNewSymbol parsed_name = NULL;
 // Parse the stream. Note that we do this even though this klass might
 // already be present in the SystemDictionary, otherwise we would not
 // throw potential ClassFormatErrors.
 //
 THREAD);
 const char* pkg = "java/";
 if (!HAS_PENDING_EXCEPTION &&
 !class_loader.is_null() &&
-!parsed_name.is_null() &&
+parsed_name != NULL &&
 !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) {
 // It is illegal to define classes in the "java." package from
 // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
 ResourceMark rm(THREAD);
 char* name = parsed_name->as_C_string();
 Exceptions::_throw_msg(THREAD_AND_LOCATION,
 vmSymbols::java_lang_SecurityException(), message);
 }
 if (!HAS_PENDING_EXCEPTION) {
-assert(!parsed_name.is_null(), "Sanity");
+assert(parsed_name != NULL, "Sanity");
-assert(class_name.is_null() || class_name() == parsed_name(),
+assert(class_name == NULL || class_name == parsed_name, "name mismatch");
-"name mismatch");
 // Verification prevents us from creating names with dots in them, this
 // asserts that that's the case.
 assert(is_internal_format(parsed_name),
 "external class name format used internally");
 // If parsing the class file or define_instance_class failed, we
 // need to remove the placeholder added on our behalf. But we
 // must make sure parsed_name is valid first (it won't be if we had
 // a format error before the class was parsed far enough to
 // find the name).
-if (HAS_PENDING_EXCEPTION && !parsed_name.is_null()) {
+if (HAS_PENDING_EXCEPTION && parsed_name != NULL) {
 unsigned int p_hash = placeholders()->compute_hash(parsed_name,
 class_loader);
 int p_index = placeholders()->hash_to_index(p_hash);
 {
 MutexLocker mu(SystemDictionary_lock, THREAD);
 // Make sure that we didn't leave a place holder in the
 // SystemDictionary; this is only done on success
 debug_only( {
 if (!HAS_PENDING_EXCEPTION) {
-assert(!parsed_name.is_null(), "parsed_name is still null?");
+assert(parsed_name != NULL, "parsed_name is still null?");
-symbolHandle h_name   (THREAD, k->name());
+Symbol*  h_name    = k->name();
 Handle h_loader (THREAD, k->class_loader());
 MutexLocker mu(SystemDictionary_lock, THREAD);
-oop check = find_class_or_placeholder(parsed_name, class_loader);
+klassOop check = find_class(parsed_name, class_loader);
 assert(check == k(), "should be present in the dictionary");
-oop check2 = find_class_or_placeholder(h_name, h_loader);
+klassOop check2 = find_class(h_name, h_loader);
 assert(check == check2, "name inconsistancy in SystemDictionary");
 }
 } );
 return k();
 // If there is a shared dictionary, then find the entry for the
 // given shared system class, if any.
-klassOop SystemDictionary::find_shared_class(symbolHandle class_name) {
+klassOop SystemDictionary::find_shared_class(Symbol* class_name) {
 if (shared_dictionary() != NULL) {
 unsigned int d_hash = dictionary()->compute_hash(class_name, Handle());
 int d_index = dictionary()->hash_to_index(d_hash);
 return shared_dictionary()->find_shared_class(d_index, d_hash, class_name);
 } else {
 // Update the class definition to include sibling classes and no
 // subclasses (yet).  [Classes in the shared space are not part of the
 // object hierarchy until loaded.]
 instanceKlassHandle SystemDictionary::load_shared_class(
-symbolHandle class_name, Handle class_loader, TRAPS) {
+Symbol* class_name, Handle class_loader, TRAPS) {
 instanceKlassHandle ik (THREAD, find_shared_class(class_name));
 return load_shared_class(ik, class_loader, THREAD);
 }
 // Note well!  Changes to this method may affect oop access order
 instanceKlassHandle SystemDictionary::load_shared_class(
 instanceKlassHandle ik, Handle class_loader, TRAPS) {
 assert(class_loader.is_null(), "non-null classloader for shared class?");
 if (ik.not_null()) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
-symbolHandle class_name(THREAD, ik->name());
+Symbol*  class_name = ik->name();
 // Found the class, now load the superclass and interfaces.  If they
 // are shared, add them to the main system dictionary and reset
 // their hierarchy references (supers, subs, and interfaces).
 if (ik->super() != NULL) {
-symbolHandle cn(THREAD, ik->super()->klass_part()->name());
+Symbol*  cn = ik->super()->klass_part()->name();
 resolve_super_or_fail(class_name, cn,
 class_loader, Handle(), true, CHECK_(nh));
 }
 objArrayHandle interfaces (THREAD, ik->local_interfaces());
 // Note: can not use instanceKlass::cast here because
 // interfaces' instanceKlass's C++ vtbls haven't been
 // reinitialized yet (they will be once the interface classes
 // are loaded)
-symbolHandle name (THREAD, k->klass_part()->name());
+Symbol*  name  = k->klass_part()->name();
 resolve_super_or_fail(class_name, name, class_loader, Handle(), false, CHECK_(nh));
 }
 // Adjust methods to recover missing data.  They need addresses for
 // interpreter entry points and their default native method address
 // system yet.  Call the DownloadManager method to make them appear in the
 // bootstrap class path and try again to load the named class.
 // Note that with delegation class loaders all classes in another loader will
 // first try to call this so it'd better be fast!!
 static instanceKlassHandle download_and_retry_class_load(
-symbolHandle class_name,
+Symbol* class_name,
 TRAPS) {
 klassOop dlm = SystemDictionary::sun_jkernel_DownloadManager_klass();
 instanceKlassHandle nk;
 // multiple classes could be not found and downloaded at the same time.
 // class sun.misc.DownloadManager;
 // public static String getBootClassPathEntryForClass(String className);
 JavaCalls::call_static(&result,
 KlassHandle(THREAD, dlm),
-vmSymbolHandles::getBootClassPathEntryForClass_name(),
+vmSymbols::getBootClassPathEntryForClass_name(),
-vmSymbolHandles::string_string_signature(),
+vmSymbols::string_string_signature(),
 class_string,
 CHECK_(nk));
 // Get result.string and add to bootclasspath
 assert(result.get_type() == T_OBJECT, "just checking");
 return ClassLoader::load_classfile(class_name, CHECK_(nk));
 }
 #endif // KERNEL
-instanceKlassHandle SystemDictionary::load_instance_class(symbolHandle class_name, Handle class_loader, TRAPS) {
+instanceKlassHandle SystemDictionary::load_instance_class(Symbol* class_name, Handle class_loader, TRAPS) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
 if (class_loader.is_null()) {
 // Search the shared system dictionary for classes preloaded into the
 // shared spaces.
 // a customer that counts on this call
 if (MustCallLoadClassInternal && has_loadClassInternal()) {
 JavaCalls::call_special(&result,
 class_loader,
 spec_klass,
-vmSymbolHandles::loadClassInternal_name(),
+vmSymbols::loadClassInternal_name(),
-vmSymbolHandles::string_class_signature(),
+vmSymbols::string_class_signature(),
 string,
 CHECK_(nh));
 } else {
 JavaCalls::call_virtual(&result,
 class_loader,
 spec_klass,
-vmSymbolHandles::loadClass_name(),
+vmSymbols::loadClass_name(),
-vmSymbolHandles::string_class_signature(),
+vmSymbols::string_class_signature(),
 string,
 CHECK_(nh));
 }
 assert(result.get_type() == T_OBJECT, "just checking");
 instanceKlassHandle k =
 instanceKlassHandle(THREAD, java_lang_Class::as_klassOop(obj));
 // For user defined Java class loaders, check that the name returned is
 // the same as that requested.  This check is done for the bootstrap
 // loader when parsing the class file.
-if (class_name() == k->name()) {
+if (class_name == k->name()) {
 return k;
 }
 }
 // Class is not found or has the wrong name, return NULL
 return nh;
 // define two different instanceKlasses for that class/classloader pair.
 // Existing classloaders will call define_instance_class with the
 // classloader lock held
 // Parallel classloaders will call find_or_define_instance_class
 // which will require a token to perform the define class
-symbolHandle name_h(THREAD, k->name());
+Symbol*  name_h = k->name();
 unsigned int d_hash = dictionary()->compute_hash(name_h, class_loader_h);
 int d_index = dictionary()->hash_to_index(d_hash);
 check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK);
 // Register class just loaded with class loader (placed in Vector)
 // False is the requested default.
 // For better performance, the class loaders should synchronize
 // findClass(), i.e. FindLoadedClass/DefineClassIfAbsent or they
 // potentially waste time reading and parsing the bytestream.
 // Note: VM callers should ensure consistency of k/class_name,class_loader
-instanceKlassHandle SystemDictionary::find_or_define_instance_class(symbolHandle class_name, Handle class_loader, instanceKlassHandle k, TRAPS) {
+instanceKlassHandle SystemDictionary::find_or_define_instance_class(Symbol* class_name, Handle class_loader, instanceKlassHandle k, TRAPS) {
 instanceKlassHandle nh = instanceKlassHandle(); // null Handle
-symbolHandle name_h(THREAD, k->name()); // passed in class_name may be null
+Symbol*  name_h = k->name(); // passed in class_name may be null
 unsigned int d_hash = dictionary()->compute_hash(name_h, class_loader);
 int d_index = dictionary()->hash_to_index(d_hash);
 // Hold SD lock around find_class and placeholder creation for DEFINE_CLASS
 return(instanceKlassHandle(THREAD, check));
 }
 }
 // Acquire define token for this class/classloader
-symbolHandle nullsymbolHandle;
+probe = placeholders()->find_and_add(p_index, p_hash, name_h, class_loader, PlaceholderTable::DEFINE_CLASS, NULL, THREAD);
-probe = placeholders()->find_and_add(p_index, p_hash, name_h, class_loader, PlaceholderTable::DEFINE_CLASS, nullsymbolHandle, THREAD);
 // Wait if another thread defining in parallel
 // All threads wait - even those that will throw duplicate class: otherwise
 // caller is surprised by LinkageError: duplicate, but findLoadedClass fails
 // if other thread has not finished updating dictionary
 while (probe->definer() != NULL) {
 // ----------------------------------------------------------------------------
 // Lookup
 klassOop SystemDictionary::find_class(int index, unsigned int hash,
-symbolHandle class_name,
+Symbol* class_name,
 Handle class_loader) {
 assert_locked_or_safepoint(SystemDictionary_lock);
 assert (index == dictionary()->index_for(class_name, class_loader),
 "incorrect index?");
 return k;
 }
 // Basic find on classes in the midst of being loaded
-symbolOop SystemDictionary::find_placeholder(int index, unsigned int hash,
+Symbol* SystemDictionary::find_placeholder(Symbol* class_name,
-symbolHandle class_name,
+Handle class_loader) {
-Handle class_loader) {
 assert_locked_or_safepoint(SystemDictionary_lock);
+unsigned int p_hash = placeholders()->compute_hash(class_name, class_loader);
-return placeholders()->find_entry(index, hash, class_name, class_loader);
+int p_index = placeholders()->hash_to_index(p_hash);
+return placeholders()->find_entry(p_index, p_hash, class_name, class_loader);
 }
 // Used for assertions and verification only
-oop SystemDictionary::find_class_or_placeholder(symbolHandle class_name,
+klassOop SystemDictionary::find_class(Symbol* class_name, Handle class_loader) {
-Handle class_loader) {
 #ifndef ASSERT
 guarantee(VerifyBeforeGC   ||
 VerifyDuringGC   ||
 VerifyBeforeExit ||
 VerifyAfterGC, "too expensive");
 #endif
 assert_locked_or_safepoint(SystemDictionary_lock);
-symbolOop class_name_ = class_name();
-oop class_loader_ = class_loader();
 // First look in the loaded class array
 unsigned int d_hash = dictionary()->compute_hash(class_name, class_loader);
 int d_index = dictionary()->hash_to_index(d_hash);
-oop lookup = find_class(d_index, d_hash, class_name, class_loader);
+return find_class(d_index, d_hash, class_name, class_loader);
-if (lookup == NULL) {
-// Next try the placeholders
-unsigned int p_hash = placeholders()->compute_hash(class_name,class_loader);
-int p_index = placeholders()->hash_to_index(p_hash);
-lookup = find_placeholder(p_index, p_hash, class_name, class_loader);
-}
-return lookup;
 }
 // Get the next class in the diictionary.
 klassOop SystemDictionary::try_get_next_class() {
 // represent classes we're actively loading.
 placeholders_do(blk);
 // Visit extra methods
 invoke_method_table()->oops_do(blk);
-// Loader constraints. We must keep the symbolOop used in the name alive.
-constraints()->always_strong_classes_do(blk);
-// Resolution errors keep the symbolOop for the error alive
-resolution_errors()->always_strong_classes_do(blk);
 }
 void SystemDictionary::placeholders_do(OopClosure* blk) {
 placeholders()->oops_do(blk);
 resolution_errors()->oops_do(f);
 }
 void SystemDictionary::preloaded_oops_do(OopClosure* f) {
-f->do_oop((oop*) &wk_klass_name_limits[0]);
-f->do_oop((oop*) &wk_klass_name_limits[1]);
 for (int k = (int)FIRST_WKID; k < (int)WKID_LIMIT; k++) {
 f->do_oop((oop*) &_well_known_klasses[k]);
 }
 {
 // Don't iterate over placeholders
 void SystemDictionary::classes_do(void f(klassOop, oop, TRAPS), TRAPS) {
 dictionary()->classes_do(f, CHECK);
 }
-void SystemDictionary::placeholders_do(void f(symbolOop, oop)) {
+void SystemDictionary::placeholders_do(void f(Symbol*, oop)) {
 placeholders()->entries_do(f);
 }
 void SystemDictionary::methods_do(void f(methodOop)) {
 dictionary()->methods_do(f);
 // if multiple threads calling this function, only one thread will load
 // the class.  The other threads will find the loaded version once the
 // class is loaded.
 klassOop aos = _abstract_ownable_synchronizer_klass;
 if (aos == NULL) {
-klassOop k = resolve_or_fail(vmSymbolHandles::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK);
+klassOop k = resolve_or_fail(vmSymbols::java_util_concurrent_locks_AbstractOwnableSynchronizer(), true, CHECK);
 // Force a fence to prevent any read before the write completes
 OrderAccess::fence();
 _abstract_ownable_synchronizer_klass = k;
 }
 }
 bool SystemDictionary::initialize_wk_klass(WKID id, int init_opt, TRAPS) {
 assert(id >= (int)FIRST_WKID && id < (int)WKID_LIMIT, "oob");
 int  info = wk_init_info[id - FIRST_WKID];
 int  sid  = (info >> CEIL_LG_OPTION_LIMIT);
-symbolHandle symbol = vmSymbolHandles::symbol_handle_at((vmSymbols::SID)sid);
+Symbol* symbol = vmSymbols::symbol_at((vmSymbols::SID)sid);
 klassOop*    klassp = &_well_known_klasses[id];
 bool must_load = (init_opt < SystemDictionary::Opt);
 bool try_load  = true;
 if (init_opt == SystemDictionary::Opt_Kernel) {
 #ifndef KERNEL
 int opt  = (info & right_n_bits(CEIL_LG_OPTION_LIMIT));
 initialize_wk_klass((WKID)id, opt, CHECK);
 // Update limits, so find_well_known_klass can be very fast:
-symbolOop s = vmSymbols::symbol_at((vmSymbols::SID)sid);
+Symbol* s = vmSymbols::symbol_at((vmSymbols::SID)sid);
 if (wk_klass_name_limits[1] == NULL) {
 wk_klass_name_limits[0] = wk_klass_name_limits[1] = s;
 } else if (wk_klass_name_limits[1] < s) {
 wk_klass_name_limits[1] = s;
 } else if (wk_klass_name_limits[0] > s) {
 instanceKlassHandle k,
 Handle class_loader, bool defining,
 TRAPS) {
 const char *linkage_error = NULL;
 {
-symbolHandle name (THREAD, k->name());
+Symbol*  name  = k->name();
 MutexLocker mu(SystemDictionary_lock, THREAD);
 klassOop check = find_class(d_index, d_hash, name, class_loader);
 if (check != (klassOop)NULL) {
 // if different instanceKlass - duplicate class definition,
 return;
 }
 }
 #ifdef ASSERT
-unsigned int p_hash = placeholders()->compute_hash(name, class_loader);
+Symbol* ph_check = find_placeholder(name, class_loader);
-int p_index = placeholders()->hash_to_index(p_hash);
+assert(ph_check == NULL || ph_check == name, "invalid symbol");
-symbolOop ph_check = find_placeholder(p_index, p_hash, name, class_loader);
-assert(ph_check == NULL || ph_check == name(), "invalid symbol");
 #endif
 if (linkage_error == NULL) {
 if (constraints()->check_or_update(k, class_loader, name) == false) {
 linkage_error = "loader constraint violation: loader (instance of %s)"
 instanceKlassHandle k,
 Handle class_loader,
 TRAPS) {
 // Compile_lock prevents systemDictionary updates during compilations
 assert_locked_or_safepoint(Compile_lock);
-symbolHandle name (THREAD, k->name());
+Symbol*  name  = k->name();
 {
 MutexLocker mu1(SystemDictionary_lock, THREAD);
 // See whether biased locking is enabled and if so set it for this
 assert (sd_check != NULL, "should have entry in system dictionary");
 // Changed to allow PH to remain to complete class circularity checking
 // while only one thread can define a class at one time, multiple
 // classes can resolve the superclass for a class at one time,
 // and the placeholder is used to track that
-//  symbolOop ph_check = find_placeholder(p_index, p_hash, name, class_loader);
+//  Symbol* ph_check = find_placeholder(name, class_loader);
 //  assert (ph_check == NULL, "should not have a placeholder entry");
 #endif
 SystemDictionary_lock->notify_all();
 }
 }
 klassOop SystemDictionary::find_constrained_instance_or_array_klass(
-symbolHandle class_name, Handle class_loader, TRAPS) {
+Symbol* class_name, Handle class_loader, TRAPS) {
 // First see if it has been loaded directly.
 // Force the protection domain to be null.  (This removes protection checks.)
 Handle no_protection_domain;
 klassOop klass = find_instance_or_array_klass(class_name, class_loader,
 return klass;
 // Now look to see if it has been loaded elsewhere, and is subject to
 // a loader constraint that would require this loader to return the
 // klass that is already loaded.
-if (FieldType::is_array(class_name())) {
+if (FieldType::is_array(class_name)) {
 // For array classes, their klassOops are not kept in the
 // constraint table. The element klassOops are.
-jint dimension;
+FieldArrayInfo fd;
-symbolOop object_key;
+BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(NULL));
-BasicType t = FieldType::get_array_info(class_name(), &dimension,
-&object_key, CHECK_(NULL));
 if (t != T_OBJECT) {
 klass = Universe::typeArrayKlassObj(t);
 } else {
-symbolHandle elem_name(THREAD, object_key);
 MutexLocker mu(SystemDictionary_lock, THREAD);
-klass = constraints()->find_constrained_klass(elem_name, class_loader);
+klass = constraints()->find_constrained_klass(fd.object_key(), class_loader);
 }
 // If element class already loaded, allocate array klass
 if (klass != NULL) {
-klass = Klass::cast(klass)->array_klass_or_null(dimension);
+klass = Klass::cast(klass)->array_klass_or_null(fd.dimension());
 }
 } else {
 MutexLocker mu(SystemDictionary_lock, THREAD);
 // Non-array classes are easy: simply check the constraint table.
 klass = constraints()->find_constrained_klass(class_name, class_loader);
 return klass;
 }
-bool SystemDictionary::add_loader_constraint(symbolHandle class_name,
+bool SystemDictionary::add_loader_constraint(Symbol* class_name,
 Handle class_loader1,
 Handle class_loader2,
 Thread* THREAD) {
-symbolHandle constraint_name;
+Symbol* constraint_name = NULL;
-if (!FieldType::is_array(class_name())) {
+if (!FieldType::is_array(class_name)) {
 constraint_name = class_name;
 } else {
 // For array classes, their klassOops are not kept in the
 // constraint table. The element classes are.
-jint dimension;
+FieldArrayInfo fd;
-symbolOop object_key;
+BasicType t = FieldType::get_array_info(class_name, fd, CHECK_(false));
-BasicType t = FieldType::get_array_info(class_name(), &dimension,
-&object_key, CHECK_(false));
 // primitive types always pass
 if (t != T_OBJECT) {
 return true;
 } else {
-constraint_name = symbolHandle(THREAD, object_key);
+constraint_name = fd.object_key();
 }
 }
 unsigned int d_hash1 = dictionary()->compute_hash(constraint_name, class_loader1);
 int d_index1 = dictionary()->hash_to_index(d_hash1);
 }
 }
 // Add entry to resolution error table to record the error when the first
 // attempt to resolve a reference to a class has failed.
-void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, symbolHandle error) {
+void SystemDictionary::add_resolution_error(constantPoolHandle pool, int which, Symbol* error) {
 unsigned int hash = resolution_errors()->compute_hash(pool, which);
 int index = resolution_errors()->hash_to_index(hash);
 {
 MutexLocker ml(SystemDictionary_lock, Thread::current());
 resolution_errors()->add_entry(index, hash, pool, which, error);
 }
 }
 // Lookup resolution error table. Returns error if found, otherwise NULL.
-symbolOop SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) {
+Symbol* SystemDictionary::find_resolution_error(constantPoolHandle pool, int which) {
 unsigned int hash = resolution_errors()->compute_hash(pool, which);
 int index = resolution_errors()->hash_to_index(hash);
 {
 MutexLocker ml(SystemDictionary_lock, Thread::current());
 ResolutionErrorEntry* entry = resolution_errors()->find_entry(index, hash, pool, which);
-return (entry != NULL) ? entry->error() : (symbolOop)NULL;
+return (entry != NULL) ? entry->error() : (Symbol*)NULL;
 }
 }
 // Signature constraints ensure that callers and callees agree about
 // signature will be resolved to the same class in both loaders.
 // Returns the name of the type that failed a loader constraint check, or
 // NULL if no constraint failed. The returned C string needs cleaning up
 // with a ResourceMark in the caller.  No exception except OOME is thrown.
 // Arrays are not added to the loader constraint table, their elements are.
-char* SystemDictionary::check_signature_loaders(symbolHandle signature,
+char* SystemDictionary::check_signature_loaders(Symbol* signature,
 Handle loader1, Handle loader2,
 bool is_method, TRAPS)  {
 // Nothing to do if loaders are the same.
 if (loader1() == loader2()) {
 return NULL;
 }
+ResourceMark rm(THREAD);
 SignatureStream sig_strm(signature, is_method);
 while (!sig_strm.is_done()) {
 if (sig_strm.is_object()) {
-symbolOop s = sig_strm.as_symbol(CHECK_NULL);
+Symbol* s = sig_strm.as_symbol(CHECK_NULL);
-symbolHandle sig (THREAD, s);
+Symbol*  sig  = s;
 if (!add_loader_constraint(sig, loader1, loader2, THREAD)) {
-return sig()->as_C_string();
+return sig->as_C_string();
 }
 }
 sig_strm.next();
 }
 return NULL;
 }
-methodOop SystemDictionary::find_method_handle_invoke(symbolHandle name,
+methodOop SystemDictionary::find_method_handle_invoke(Symbol* name,
-symbolHandle signature,
+Symbol* signature,
 KlassHandle accessing_klass,
 TRAPS) {
 if (!EnableMethodHandles)  return NULL;
-vmSymbols::SID name_id = vmSymbols::find_sid(name());
+vmSymbols::SID name_id = vmSymbols::find_sid(name);
 assert(name_id != vmSymbols::NO_SID, "must be a known name");
 unsigned int hash  = invoke_method_table()->compute_hash(signature, name_id);
 int          index = invoke_method_table()->hash_to_index(hash);
 SymbolPropertyEntry* spe = invoke_method_table()->find_entry(index, hash, signature, name_id);
 methodHandle non_cached_result;
 // (tw) May we do this?
 	//if (THREAD->is_Compiler_thread())
 //  return NULL;              // do not attempt from within compiler
 bool for_invokeGeneric = (name_id == vmSymbols::VM_SYMBOL_ENUM_NAME(invokeGeneric_name));
 bool found_on_bcp = false;
-Handle mt = find_method_handle_type(signature(), accessing_klass,
+Handle mt = find_method_handle_type(signature, accessing_klass,
 for_invokeGeneric,
 found_on_bcp, CHECK_NULL);
 KlassHandle  mh_klass = SystemDictionaryHandles::MethodHandle_klass();
 methodHandle m = methodOopDesc::make_invoke_method(mh_klass, name, signature,
 mt, CHECK_NULL);
 // Ask Java code to find or construct a java.dyn.MethodType for the given
 // signature, as interpreted relative to the given class loader.
 // Because of class loader constraints, all method handle usage must be
 // consistent with this loader.
-Handle SystemDictionary::find_method_handle_type(symbolHandle signature,
+Handle SystemDictionary::find_method_handle_type(Symbol* signature,
 KlassHandle accessing_klass,
 bool for_invokeGeneric,
 bool& return_bcp_flag,
 TRAPS) {
 Handle class_loader, protection_domain;
 bool is_on_bcp = true;  // keep this true as long as we can materialize from the boot classloader
 Handle empty;
-int npts = ArgumentCount(signature()).size();
+int npts = ArgumentCount(signature).size();
 objArrayHandle pts = oopFactory::new_objArray(SystemDictionary::Class_klass(), npts, CHECK_(empty));
 int arg = 0;
 Handle rt;                            // the return type from the signature
-for (SignatureStream ss(signature()); !ss.is_done(); ss.next()) {
+ResourceMark rm(THREAD);
+for (SignatureStream ss(signature); !ss.is_done(); ss.next()) {
 oop mirror = NULL;
 if (is_on_bcp) {
 mirror = ss.as_java_mirror(class_loader, protection_domain,
 SignatureStream::ReturnNull, CHECK_(empty));
 if (mirror == NULL) {
 // Ask Java code to find or construct a method handle constant.
 Handle SystemDictionary::link_method_handle_constant(KlassHandle caller,
 int ref_kind, //e.g., JVM_REF_invokeVirtual
 KlassHandle callee,
-symbolHandle name_sym,
+Symbol* name_sym,
-symbolHandle signature,
+Symbol* signature,
 TRAPS) {
 Handle empty;
-Handle name = java_lang_String::create_from_symbol(name_sym(), CHECK_(empty));
+Handle name = java_lang_String::create_from_symbol(name_sym, CHECK_(empty));
 Handle type;
 if (signature->utf8_length() > 0 && signature->byte_at(0) == '(') {
 bool ignore_is_on_bcp = false;
 type = find_method_handle_type(signature, caller, false, ignore_is_on_bcp, CHECK_(empty));
 } else {
-SignatureStream ss(signature(), false);
+ResourceMark rm(THREAD);
+SignatureStream ss(signature, false);
 if (!ss.is_done()) {
 oop mirror = ss.as_java_mirror(caller->class_loader(), caller->protection_domain(),
 SignatureStream::NCDFError, CHECK_(empty));
 type = Handle(THREAD, mirror);
 ss.next();
 }
 // Ask Java code to find or construct a java.dyn.CallSite for the given
 // name and signature, as interpreted relative to the given class loader.
 Handle SystemDictionary::make_dynamic_call_site(Handle bootstrap_method,
-symbolHandle name,
+Symbol* name,
 methodHandle signature_invoker,
 Handle info,
 methodHandle caller_method,
 int caller_bci,
 TRAPS) {
 Handle caller_mname = MethodHandles::new_MemberName(CHECK_(empty));
 MethodHandles::init_MemberName(caller_mname(), caller_method());
 // call sun.dyn.MethodHandleNatives::makeDynamicCallSite(bootm, name, mtype, info, caller_mname, caller_pos)
-oop name_str_oop = StringTable::intern(name(), CHECK_(empty)); // not a handle!
+oop name_str_oop = StringTable::intern(name, CHECK_(empty)); // not a handle!
 JavaCallArguments args(Handle(THREAD, bootstrap_method()));
 args.push_oop(name_str_oop);
 args.push_oop(signature_invoker->method_handle_type());
 args.push_oop(info());
 args.push_oop(caller_mname());
 constraints()->verify(dictionary(), placeholders());
 }
 void SystemDictionary::verify_obj_klass_present(Handle obj,
-symbolHandle class_name,
+Symbol* class_name,
 Handle class_loader) {
 GCMutexLocker mu(SystemDictionary_lock);
-oop probe = find_class_or_placeholder(class_name, class_loader);
+Symbol* name;
+klassOop probe = find_class(class_name, class_loader);
 if (probe == NULL) {
 probe = SystemDictionary::find_shared_class(class_name);
-}
+if (probe == NULL) {
-guarantee(probe != NULL &&
+name = find_placeholder(class_name, class_loader);
-(!probe->is_klass() || probe == obj()),
+}
-"Loaded klasses should be in SystemDictionary");
+}
+guarantee(probe != NULL || name != NULL,
+"Loaded klasses should be in SystemDictionary");
 }
 #ifndef PRODUCT
 // statistics code

Mercurial > hg > truffle

comparison src/share/vm/classfile/systemDictionary.cpp @ 2181:d25d4ca69222