--- a/src/hotspot/share/classfile/systemDictionary.cpp Thu Nov 02 18:44:44 2017 +0300
+++ b/src/hotspot/share/classfile/systemDictionary.cpp Thu Nov 02 11:00:34 2017 -0500
@@ -371,7 +371,6 @@
ClassLoaderData* loader_data = class_loader_data(class_loader);
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(child_name);
- int d_index = dictionary->hash_to_index(d_hash);
unsigned int p_hash = placeholders()->compute_hash(child_name);
int p_index = placeholders()->hash_to_index(p_hash);
// can't throw error holding a lock
@@ -379,7 +378,7 @@
bool throw_circularity_error = false;
{
MutexLocker mu(SystemDictionary_lock, THREAD);
- Klass* childk = find_class(d_index, d_hash, child_name, dictionary);
+ Klass* childk = find_class(d_hash, child_name, dictionary);
Klass* quicksuperk;
// to support // loading: if child done loading, just return superclass
// if class_name, & class_loader don't match:
@@ -487,9 +486,9 @@
Symbol* kn = klass->name();
unsigned int d_hash = dictionary->compute_hash(kn);
- int d_index = dictionary->hash_to_index(d_hash);
MutexLocker mu(SystemDictionary_lock, THREAD);
+ int d_index = dictionary->hash_to_index(d_hash);
dictionary->add_protection_domain(d_index, d_hash, klass,
protection_domain, THREAD);
}
@@ -555,7 +554,6 @@
ClassLoaderData* loader_data = class_loader_data(class_loader);
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(name);
- int d_index = dictionary->hash_to_index(d_hash);
unsigned int p_hash = placeholders()->compute_hash(name);
int p_index = placeholders()->hash_to_index(p_hash);
@@ -579,7 +577,7 @@
if (!class_loader.is_null() && is_parallelCapable(class_loader)) {
MutexLocker mu(SystemDictionary_lock, THREAD);
// Check if classloading completed while we were loading superclass or waiting
- return find_class(d_index, d_hash, name, dictionary);
+ return find_class(d_hash, name, dictionary);
}
// must loop to both handle other placeholder updates
@@ -589,7 +587,7 @@
while (super_load_in_progress) {
MutexLocker mu(SystemDictionary_lock, THREAD);
// Check if classloading completed while we were loading superclass or waiting
- InstanceKlass* check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* check = find_class(d_hash, name, dictionary);
if (check != NULL) {
// Klass is already loaded, so just return it
return check;
@@ -670,6 +668,7 @@
class_loader = Handle(THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader()));
ClassLoaderData *loader_data = register_loader(class_loader, CHECK_NULL);
Dictionary* dictionary = loader_data->dictionary();
+ unsigned int d_hash = dictionary->compute_hash(name);
// Do lookup to see if class already exist and the protection domain
// has the right access
@@ -677,11 +676,10 @@
// All subsequent calls use find_class, and set has_loaded_class so that
// before we return a result we call out to java to check for valid protection domain
// to allow returning the Klass* and add it to the pd_set if it is valid
- unsigned int d_hash = dictionary->compute_hash(name);
- int d_index = dictionary->hash_to_index(d_hash);
- Klass* probe = dictionary->find(d_index, d_hash, name, protection_domain);
- if (probe != NULL) return probe;
-
+ {
+ Klass* probe = dictionary->find(d_hash, name, protection_domain);
+ if (probe != NULL) return probe;
+ }
// Non-bootstrap class loaders will call out to class loader and
// define via jvm/jni_DefineClass which will acquire the
@@ -716,7 +714,7 @@
{
MutexLocker mu(SystemDictionary_lock, THREAD);
- InstanceKlass* check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* check = find_class(d_hash, name, dictionary);
if (check != NULL) {
// Klass is already loaded, so just return it
class_has_been_loaded = true;
@@ -800,7 +798,7 @@
double_lock_wait(lockObject, THREAD);
}
// Check if classloading completed while we were waiting
- InstanceKlass* check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* check = find_class(d_hash, name, dictionary);
if (check != NULL) {
// Klass is already loaded, so just return it
k = check;
@@ -825,7 +823,7 @@
// i.e. now that we hold the LOAD_INSTANCE token on loading this class/CL
// one final check if the load has already completed
// class loaders holding the ObjectLock shouldn't find the class here
- InstanceKlass* check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* check = find_class(d_hash, name, dictionary);
if (check != NULL) {
// Klass is already loaded, so return it after checking/adding protection domain
k = check;
@@ -858,7 +856,7 @@
if (k == NULL && HAS_PENDING_EXCEPTION
&& PENDING_EXCEPTION->is_a(SystemDictionary::LinkageError_klass())) {
MutexLocker mu(SystemDictionary_lock, THREAD);
- InstanceKlass* check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* check = find_class(d_hash, name, dictionary);
if (check != NULL) {
// Klass is already loaded, so just use it
k = check;
@@ -873,7 +871,7 @@
if (!HAS_PENDING_EXCEPTION && k != NULL &&
k->class_loader() != class_loader()) {
- check_constraints(d_index, d_hash, k, class_loader, false, THREAD);
+ check_constraints(d_hash, k, class_loader, false, THREAD);
// Need to check for a PENDING_EXCEPTION again; check_constraints
// can throw and doesn't use the CHECK macro.
@@ -881,7 +879,7 @@
{ // Grabbing the Compile_lock prevents systemDictionary updates
// during compilations.
MutexLocker mu(Compile_lock, THREAD);
- update_dictionary(d_index, d_hash, p_index, p_hash,
+ update_dictionary(d_hash, p_index, p_hash,
k, class_loader, THREAD);
}
@@ -923,7 +921,7 @@
if (protection_domain() == NULL) return k;
// Check the protection domain has the right access
- if (dictionary->is_valid_protection_domain(d_index, d_hash, name,
+ if (dictionary->is_valid_protection_domain(d_hash, name,
protection_domain)) {
return k;
}
@@ -965,8 +963,7 @@
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(class_name);
- int d_index = dictionary->hash_to_index(d_hash);
- return dictionary->find(d_index, d_hash, class_name,
+ return dictionary->find(d_hash, class_name,
protection_domain);
}
@@ -1644,8 +1641,7 @@
Symbol* name_h = k->name();
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(name_h);
- int d_index = dictionary->hash_to_index(d_hash);
- check_constraints(d_index, d_hash, k, class_loader_h, true, CHECK);
+ check_constraints(d_hash, k, class_loader_h, true, CHECK);
// Register class just loaded with class loader (placed in Vector)
// Note we do this before updating the dictionary, as this can
@@ -1673,7 +1669,7 @@
// Add to systemDictionary - so other classes can see it.
// Grabs and releases SystemDictionary_lock
- update_dictionary(d_index, d_hash, p_index, p_hash,
+ update_dictionary(d_hash, p_index, p_hash,
k, class_loader_h, THREAD);
}
k->eager_initialize(THREAD);
@@ -1715,7 +1711,6 @@
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(name_h);
- int d_index = dictionary->hash_to_index(d_hash);
// Hold SD lock around find_class and placeholder creation for DEFINE_CLASS
unsigned int p_hash = placeholders()->compute_hash(name_h);
@@ -1726,7 +1721,7 @@
MutexLocker mu(SystemDictionary_lock, THREAD);
// First check if class already defined
if (UnsyncloadClass || (is_parallelDefine(class_loader))) {
- InstanceKlass* check = find_class(d_index, d_hash, name_h, dictionary);
+ InstanceKlass* check = find_class(d_hash, name_h, dictionary);
if (check != NULL) {
return check;
}
@@ -1748,7 +1743,7 @@
placeholders()->find_and_remove(p_index, p_hash, name_h, loader_data, PlaceholderTable::DEFINE_CLASS, THREAD);
SystemDictionary_lock->notify_all();
#ifdef ASSERT
- InstanceKlass* check = find_class(d_index, d_hash, name_h, dictionary);
+ InstanceKlass* check = find_class(d_hash, name_h, dictionary);
assert(check != NULL, "definer missed recording success");
#endif
return probe->instance_klass();
@@ -1823,10 +1818,11 @@
// ----------------------------------------------------------------------------
// Lookup
-InstanceKlass* SystemDictionary::find_class(int index, unsigned int hash,
+InstanceKlass* SystemDictionary::find_class(unsigned int hash,
Symbol* class_name,
Dictionary* dictionary) {
assert_locked_or_safepoint(SystemDictionary_lock);
+ int index = dictionary->hash_to_index(hash);
return dictionary->find_class(index, hash, class_name);
}
@@ -1856,8 +1852,7 @@
Dictionary* dictionary = loader_data->dictionary();
unsigned int d_hash = dictionary->compute_hash(class_name);
- int d_index = dictionary->hash_to_index(d_hash);
- return find_class(d_index, d_hash, class_name, dictionary);
+ return find_class(d_hash, class_name, dictionary);
}
@@ -2210,7 +2205,7 @@
// if defining is true, then LinkageError if already in dictionary
// if initiating loader, then ok if InstanceKlass matches existing entry
-void SystemDictionary::check_constraints(int d_index, unsigned int d_hash,
+void SystemDictionary::check_constraints(unsigned int d_hash,
InstanceKlass* k,
Handle class_loader, bool defining,
TRAPS) {
@@ -2222,7 +2217,7 @@
MutexLocker mu(SystemDictionary_lock, THREAD);
- InstanceKlass* check = find_class(d_index, d_hash, name, loader_data->dictionary());
+ InstanceKlass* check = find_class(d_hash, name, loader_data->dictionary());
if (check != NULL) {
// if different InstanceKlass - duplicate class definition,
// else - ok, class loaded by a different thread in parallel,
@@ -2270,7 +2265,7 @@
// Update class loader data dictionary - done after check_constraint and add_to_hierachy
// have been called.
-void SystemDictionary::update_dictionary(int d_index, unsigned int d_hash,
+void SystemDictionary::update_dictionary(unsigned int d_hash,
int p_index, unsigned int p_hash,
InstanceKlass* k,
Handle class_loader,
@@ -2305,13 +2300,13 @@
// Make a new dictionary entry.
Dictionary* dictionary = loader_data->dictionary();
- InstanceKlass* sd_check = find_class(d_index, d_hash, name, dictionary);
+ InstanceKlass* sd_check = find_class(d_hash, name, dictionary);
if (sd_check == NULL) {
- dictionary->add_klass(d_index, d_hash, name, k);
+ dictionary->add_klass(d_hash, name, k);
notice_modification();
}
#ifdef ASSERT
- sd_check = find_class(d_index, d_hash, name, dictionary);
+ sd_check = find_class(d_hash, name, dictionary);
assert (sd_check != NULL, "should have entry in dictionary");
// Note: there may be a placeholder entry: for circularity testing
// or for parallel defines
@@ -2388,16 +2383,14 @@
Dictionary* dictionary1 = loader_data1->dictionary();
unsigned int d_hash1 = dictionary1->compute_hash(constraint_name);
- int d_index1 = dictionary1->hash_to_index(d_hash1);
Dictionary* dictionary2 = loader_data2->dictionary();
unsigned int d_hash2 = dictionary2->compute_hash(constraint_name);
- int d_index2 = dictionary2->hash_to_index(d_hash2);
{
MutexLocker mu_s(SystemDictionary_lock, THREAD);
- InstanceKlass* klass1 = find_class(d_index1, d_hash1, constraint_name, dictionary1);
- InstanceKlass* klass2 = find_class(d_index2, d_hash2, constraint_name, dictionary2);
+ InstanceKlass* klass1 = find_class(d_hash1, constraint_name, dictionary1);
+ InstanceKlass* klass2 = find_class(d_hash2, constraint_name, dictionary2);
return constraints()->add_entry(constraint_name, klass1, class_loader1,
klass2, class_loader2);
}