--- old/src/hotspot/share/classfile/systemDictionary.cpp 2017-11-01 11:21:39.000000000 -0500 +++ new/src/hotspot/share/classfile/systemDictionary.cpp 2017-11-01 11:21:39.000000000 -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); }