archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 15:24:43 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8264126: Remove TRAPS/THREAD parameter for class loading functions

Browse source 
Reviewed-by: ccheung, iklam, dholmes
This commit is contained in:
Coleen Phillimore 2021-03-26 13:11:34 +00:00
parent f3eed05236
commit 507b690f88
11 changed files with 54 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/hotspot/share/ci/ciEnv.cpp
View file

@ -405,7 +405,7 @@ ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
ciSymbol* name, ciSymbol* name,
bool require_local) { bool require_local) {
ASSERT_IN_VM; ASSERT_IN_VM;
EXCEPTION_CONTEXT; Thread* current = Thread::current();
// Now we need to check the SystemDictionary // Now we need to check the SystemDictionary
Symbol* sym = name->get_symbol(); Symbol* sym = name->get_symbol();
@ -425,11 +425,11 @@ ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
return unloaded_klass; return unloaded_klass;
} }
Handle loader(THREAD, (oop)NULL); Handle loader;
Handle domain(THREAD, (oop)NULL); Handle domain;
if (accessing_klass != NULL) { if (accessing_klass != NULL) {
loader = Handle(THREAD, accessing_klass->loader()); loader = Handle(current, accessing_klass->loader());
domain = Handle(THREAD, accessing_klass->protection_domain()); domain = Handle(current, accessing_klass->protection_domain());
} }
// setup up the proper type to return on OOM // setup up the proper type to return on OOM
@ -442,10 +442,10 @@ ciKlass* ciEnv::get_klass_by_name_impl(ciKlass* accessing_klass,
Klass* found_klass; Klass* found_klass;
{ {
ttyUnlocker ttyul; // release tty lock to avoid ordering problems ttyUnlocker ttyul; // release tty lock to avoid ordering problems
MutexLocker ml(Compile_lock); MutexLocker ml(current, Compile_lock);
Klass* kls; Klass* kls;
if (!require_local) { if (!require_local) {
kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader, THREAD); kls = SystemDictionary::find_constrained_instance_or_array_klass(current, sym, loader);
} else { } else {
kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain); kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain);
} }

4
src/hotspot/share/classfile/loaderConstraints.hpp
View file

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2003, 2021, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -63,7 +63,7 @@ public:
// SystemDictionary::check_signature_loaders(Symbol* signature, // SystemDictionary::check_signature_loaders(Symbol* signature,
// Klass* klass_being_linked, // Klass* klass_being_linked,
// Handle loader1, Handle loader2, // Handle loader1, Handle loader2,
// bool is_method, TRAPS) // bool is_method)
InstanceKlass* find_constrained_klass(Symbol* name, Handle loader); InstanceKlass* find_constrained_klass(Symbol* name, Handle loader);

29
src/hotspot/share/classfile/systemDictionary.cpp
View file

@ -1049,7 +1049,7 @@ InstanceKlass* SystemDictionary::load_shared_boot_class(Symbol* class_name,
bool SystemDictionary::is_shared_class_visible(Symbol* class_name, bool SystemDictionary::is_shared_class_visible(Symbol* class_name,
InstanceKlass* ik, InstanceKlass* ik,
PackageEntry* pkg_entry, PackageEntry* pkg_entry,
Handle class_loader, TRAPS) { Handle class_loader) {
assert(!ModuleEntryTable::javabase_moduleEntry()->is_patched(), assert(!ModuleEntryTable::javabase_moduleEntry()->is_patched(),
"Cannot use sharing if java.base is patched"); "Cannot use sharing if java.base is patched");
@ -1081,17 +1081,17 @@ bool SystemDictionary::is_shared_class_visible(Symbol* class_name,
if (MetaspaceShared::use_optimized_module_handling()) { if (MetaspaceShared::use_optimized_module_handling()) {
// Class visibility has not changed between dump time and run time, so a class // Class visibility has not changed between dump time and run time, so a class
// that was visible (and thus archived) during dump time is always visible during runtime. // that was visible (and thus archived) during dump time is always visible during runtime.
assert(SystemDictionary::is_shared_class_visible_impl(class_name, ik, pkg_entry, class_loader, THREAD), assert(SystemDictionary::is_shared_class_visible_impl(class_name, ik, pkg_entry, class_loader),
"visibility cannot change between dump time and runtime"); "visibility cannot change between dump time and runtime");
return true; return true;
} }
return is_shared_class_visible_impl(class_name, ik, pkg_entry, class_loader, THREAD); return is_shared_class_visible_impl(class_name, ik, pkg_entry, class_loader);
} }
bool SystemDictionary::is_shared_class_visible_impl(Symbol* class_name, bool SystemDictionary::is_shared_class_visible_impl(Symbol* class_name,
InstanceKlass* ik, InstanceKlass* ik,
PackageEntry* pkg_entry, PackageEntry* pkg_entry,
Handle class_loader, TRAPS) { Handle class_loader) {
int scp_index = ik->shared_classpath_index(); int scp_index = ik->shared_classpath_index();
assert(!ik->is_shared_unregistered_class(), "this function should be called for built-in classes only"); assert(!ik->is_shared_unregistered_class(), "this function should be called for built-in classes only");
assert(scp_index >= 0, "must be"); assert(scp_index >= 0, "must be");
@ -1231,9 +1231,7 @@ InstanceKlass* SystemDictionary::load_shared_class(InstanceKlass* ik,
assert(!ik->is_unshareable_info_restored(), "shared class can be loaded only once"); assert(!ik->is_unshareable_info_restored(), "shared class can be loaded only once");
Symbol* class_name = ik->name(); Symbol* class_name = ik->name();
bool visible = is_shared_class_visible( if (!is_shared_class_visible(class_name, ik, pkg_entry, class_loader)) {
class_name, ik, pkg_entry, class_loader, CHECK_NULL);
if (!visible) {
return NULL; return NULL;
} }
@ -1818,7 +1816,7 @@ void SystemDictionary::update_dictionary(unsigned int hash,
// loader constraints might know about a class that isn't fully loaded // loader constraints might know about a class that isn't fully loaded
// yet and these will be ignored. // yet and these will be ignored.
Klass* SystemDictionary::find_constrained_instance_or_array_klass( Klass* SystemDictionary::find_constrained_instance_or_array_klass(
Symbol* class_name, Handle class_loader, Thread* THREAD) { Thread* current, Symbol* class_name, Handle class_loader) {
// First see if it has been loaded directly. // First see if it has been loaded directly.
// Force the protection domain to be null. (This removes protection checks.) // Force the protection domain to be null. (This removes protection checks.)
@ -1840,7 +1838,7 @@ Klass* SystemDictionary::find_constrained_instance_or_array_klass(
if (t != T_OBJECT) { if (t != T_OBJECT) {
klass = Universe::typeArrayKlassObj(t); klass = Universe::typeArrayKlassObj(t);
} else { } else {
MutexLocker mu(THREAD, SystemDictionary_lock); MutexLocker mu(current, SystemDictionary_lock);
klass = constraints()->find_constrained_klass(ss.as_symbol(), class_loader); klass = constraints()->find_constrained_klass(ss.as_symbol(), class_loader);
} }
// If element class already loaded, allocate array klass // If element class already loaded, allocate array klass
@ -1848,7 +1846,7 @@ Klass* SystemDictionary::find_constrained_instance_or_array_klass(
klass = klass->array_klass_or_null(ndims); klass = klass->array_klass_or_null(ndims);
} }
} else { } else {
MutexLocker mu(THREAD, SystemDictionary_lock); MutexLocker mu(current, SystemDictionary_lock);
// Non-array classes are easy: simply check the constraint table. // Non-array classes are easy: simply check the constraint table.
klass = constraints()->find_constrained_klass(class_name, class_loader); klass = constraints()->find_constrained_klass(class_name, class_loader);
} }
@ -1859,8 +1857,7 @@ Klass* SystemDictionary::find_constrained_instance_or_array_klass(
bool SystemDictionary::add_loader_constraint(Symbol* class_name, bool SystemDictionary::add_loader_constraint(Symbol* class_name,
Klass* klass_being_linked, Klass* klass_being_linked,
Handle class_loader1, Handle class_loader1,
Handle class_loader2, Handle class_loader2) {
Thread* THREAD) {
ClassLoaderData* loader_data1 = class_loader_data(class_loader1); ClassLoaderData* loader_data1 = class_loader_data(class_loader1);
ClassLoaderData* loader_data2 = class_loader_data(class_loader2); ClassLoaderData* loader_data2 = class_loader_data(class_loader2);
@ -1890,7 +1887,7 @@ bool SystemDictionary::add_loader_constraint(Symbol* class_name,
unsigned int name_hash2 = dictionary2->compute_hash(constraint_name); unsigned int name_hash2 = dictionary2->compute_hash(constraint_name);
{ {
MutexLocker mu_s(THREAD, SystemDictionary_lock); MutexLocker mu_s(SystemDictionary_lock);
InstanceKlass* klass1 = dictionary1->find_class(name_hash1, constraint_name); InstanceKlass* klass1 = dictionary1->find_class(name_hash1, constraint_name);
InstanceKlass* klass2 = dictionary2->find_class(name_hash2, constraint_name); InstanceKlass* klass2 = dictionary2->find_class(name_hash2, constraint_name);
bool result = constraints()->add_entry(constraint_name, klass1, class_loader1, bool result = constraints()->add_entry(constraint_name, klass1, class_loader1,
@ -1900,7 +1897,7 @@ bool SystemDictionary::add_loader_constraint(Symbol* class_name,
!klass_being_linked->is_shared()) { !klass_being_linked->is_shared()) {
SystemDictionaryShared::record_linking_constraint(constraint_name, SystemDictionaryShared::record_linking_constraint(constraint_name,
InstanceKlass::cast(klass_being_linked), InstanceKlass::cast(klass_being_linked),
class_loader1, class_loader2, THREAD); class_loader1, class_loader2);
} }
#endif // INCLUDE_CDS #endif // INCLUDE_CDS
if (Signature::is_array(class_name)) { if (Signature::is_array(class_name)) {
@ -2040,7 +2037,7 @@ const char* SystemDictionary::find_nest_host_error(const constantPoolHandle& poo
Symbol* SystemDictionary::check_signature_loaders(Symbol* signature, Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
Klass* klass_being_linked, Klass* klass_being_linked,
Handle loader1, Handle loader2, Handle loader1, Handle loader2,
bool is_method, TRAPS) { bool is_method) {
// Nothing to do if loaders are the same. // Nothing to do if loaders are the same.
if (loader1() == loader2()) { if (loader1() == loader2()) {
return NULL; return NULL;
@ -2052,7 +2049,7 @@ Symbol* SystemDictionary::check_signature_loaders(Symbol* signature,
// Note: In the future, if template-like types can take // Note: In the future, if template-like types can take
// arguments, we will want to recognize them and dig out class // arguments, we will want to recognize them and dig out class
// names hiding inside the argument lists. // names hiding inside the argument lists.
if (!add_loader_constraint(sig, klass_being_linked, loader1, loader2, THREAD)) { if (!add_loader_constraint(sig, klass_being_linked, loader1, loader2)) {
return sig; return sig;
} }
} }

14
src/hotspot/share/classfile/systemDictionary.hpp
View file

@ -169,9 +169,9 @@ class SystemDictionary : AllStatic {
// satisfied, and it is safe for classes in the given class loader // satisfied, and it is safe for classes in the given class loader
// to manipulate strongly-typed values of the found class, subject // to manipulate strongly-typed values of the found class, subject
// to local linkage and access checks. // to local linkage and access checks.
static Klass* find_constrained_instance_or_array_klass(Symbol* class_name, static Klass* find_constrained_instance_or_array_klass(Thread* current,
Handle class_loader, Symbol* class_name,
Thread* THREAD); Handle class_loader);
static void classes_do(MetaspaceClosure* it); static void classes_do(MetaspaceClosure* it);
// Iterate over all methods in all klasses // Iterate over all methods in all klasses
@ -218,7 +218,7 @@ public:
public: public:
static Symbol* check_signature_loaders(Symbol* signature, Klass* klass_being_linked, static Symbol* check_signature_loaders(Symbol* signature, Klass* klass_being_linked,
Handle loader1, Handle loader2, bool is_method, TRAPS); Handle loader1, Handle loader2, bool is_method);
// JSR 292 // JSR 292
// find a java.lang.invoke.MethodHandle.invoke* method for a given signature // find a java.lang.invoke.MethodHandle.invoke* method for a given signature
@ -350,11 +350,11 @@ private:
static bool is_shared_class_visible(Symbol* class_name, InstanceKlass* ik, static bool is_shared_class_visible(Symbol* class_name, InstanceKlass* ik,
PackageEntry* pkg_entry, PackageEntry* pkg_entry,
Handle class_loader, TRAPS); Handle class_loader);
static bool is_shared_class_visible_impl(Symbol* class_name, static bool is_shared_class_visible_impl(Symbol* class_name,
InstanceKlass* ik, InstanceKlass* ik,
PackageEntry* pkg_entry, PackageEntry* pkg_entry,
Handle class_loader, TRAPS); Handle class_loader);
static bool check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super, static bool check_shared_class_super_type(InstanceKlass* klass, InstanceKlass* super,
Handle class_loader, Handle protection_domain, Handle class_loader, Handle protection_domain,
bool is_superclass, TRAPS); bool is_superclass, TRAPS);
@ -366,7 +366,7 @@ protected:
// Used by SystemDictionaryShared // Used by SystemDictionaryShared
static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked, Handle loader1, static bool add_loader_constraint(Symbol* name, Klass* klass_being_linked, Handle loader1,
Handle loader2, TRAPS); Handle loader2);
static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld); static void post_class_load_event(EventClassLoad* event, const InstanceKlass* k, const ClassLoaderData* init_cld);
static InstanceKlass* load_shared_lambda_proxy_class(InstanceKlass* ik, static InstanceKlass* load_shared_lambda_proxy_class(InstanceKlass* ik,
Handle class_loader, Handle class_loader,

21
src/hotspot/share/classfile/systemDictionaryShared.cpp
View file

@ -1823,7 +1823,7 @@ void SystemDictionaryShared::check_verification_constraints(InstanceKlass* klass
// InstanceKlass::link_class(), so that these can be checked quickly // InstanceKlass::link_class(), so that these can be checked quickly
// at runtime without laying out the vtable/itables. // at runtime without laying out the vtable/itables.
void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKlass* klass, void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKlass* klass,
Handle loader1, Handle loader2, TRAPS) { Handle loader1, Handle loader2) {
// A linking constraint check is executed when: // A linking constraint check is executed when:
// - klass extends or implements type S // - klass extends or implements type S
// - klass overrides method S.M(...) with X.M // - klass overrides method S.M(...) with X.M
@ -1861,13 +1861,14 @@ void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKla
return; return;
} }
if (THREAD->is_VM_thread()) { if (DynamicDumpSharedSpaces && Thread::current()->is_VM_thread()) {
assert(DynamicDumpSharedSpaces, "must be");
// We are re-laying out the vtable/itables of the *copy* of // We are re-laying out the vtable/itables of the *copy* of
// a class during the final stage of dynamic dumping. The // a class during the final stage of dynamic dumping. The
// linking constraints for this class has already been recorded. // linking constraints for this class has already been recorded.
return; return;
} }
assert(!Thread::current()->is_VM_thread(), "must be");
Arguments::assert_is_dumping_archive(); Arguments::assert_is_dumping_archive();
DumpTimeSharedClassInfo* info = find_or_allocate_info_for(klass); DumpTimeSharedClassInfo* info = find_or_allocate_info_for(klass);
if (info != NULL) { if (info != NULL) {
@ -1877,7 +1878,7 @@ void SystemDictionaryShared::record_linking_constraint(Symbol* name, InstanceKla
// returns true IFF there's no need to re-initialize the i/v-tables for klass for // returns true IFF there's no need to re-initialize the i/v-tables for klass for
// the purpose of checking class loader constraints. // the purpose of checking class loader constraints.
bool SystemDictionaryShared::check_linking_constraints(InstanceKlass* klass, TRAPS) { bool SystemDictionaryShared::check_linking_constraints(Thread* current, InstanceKlass* klass) {
assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only"); assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only");
LogTarget(Info, class, loader, constraints) log; LogTarget(Info, class, loader, constraints) log;
if (klass->is_shared_boot_class()) { if (klass->is_shared_boot_class()) {
@ -1888,20 +1889,20 @@ bool SystemDictionaryShared::check_linking_constraints(InstanceKlass* klass, TRA
RunTimeSharedClassInfo* info = RunTimeSharedClassInfo::get_for(klass); RunTimeSharedClassInfo* info = RunTimeSharedClassInfo::get_for(klass);
assert(info != NULL, "Sanity"); assert(info != NULL, "Sanity");
if (info->_num_loader_constraints > 0) { if (info->_num_loader_constraints > 0) {
HandleMark hm(THREAD); HandleMark hm(current);
for (int i = 0; i < info->_num_loader_constraints; i++) { for (int i = 0; i < info->_num_loader_constraints; i++) {
RunTimeSharedClassInfo::RTLoaderConstraint* lc = info->loader_constraint_at(i); RunTimeSharedClassInfo::RTLoaderConstraint* lc = info->loader_constraint_at(i);
Symbol* name = lc->constraint_name(); Symbol* name = lc->constraint_name();
Handle loader1(THREAD, get_class_loader_by(lc->_loader_type1)); Handle loader1(current, get_class_loader_by(lc->_loader_type1));
Handle loader2(THREAD, get_class_loader_by(lc->_loader_type2)); Handle loader2(current, get_class_loader_by(lc->_loader_type2));
if (log.is_enabled()) { if (log.is_enabled()) {
ResourceMark rm(THREAD); ResourceMark rm(current);
log.print("[CDS add loader constraint for class %s symbol %s loader[0] %s loader[1] %s", log.print("[CDS add loader constraint for class %s symbol %s loader[0] %s loader[1] %s",
klass->external_name(), name->as_C_string(), klass->external_name(), name->as_C_string(),
ClassLoaderData::class_loader_data(loader1())->loader_name_and_id(), ClassLoaderData::class_loader_data(loader1())->loader_name_and_id(),
ClassLoaderData::class_loader_data(loader2())->loader_name_and_id()); ClassLoaderData::class_loader_data(loader2())->loader_name_and_id());
} }
if (!SystemDictionary::add_loader_constraint(name, klass, loader1, loader2, THREAD)) { if (!SystemDictionary::add_loader_constraint(name, klass, loader1, loader2)) {
// Loader constraint violation has been found. The caller // Loader constraint violation has been found. The caller
// will re-layout the vtable/itables to produce the correct // will re-layout the vtable/itables to produce the correct
// exception. // exception.
@ -1918,7 +1919,7 @@ bool SystemDictionaryShared::check_linking_constraints(InstanceKlass* klass, TRA
} }
} }
if (log.is_enabled()) { if (log.is_enabled()) {
ResourceMark rm(THREAD); ResourceMark rm(current);
log.print("[CDS has not recorded loader constraint for class %s]", klass->external_name()); log.print("[CDS has not recorded loader constraint for class %s]", klass->external_name());
} }
return false; return false;

4
src/hotspot/share/classfile/systemDictionaryShared.hpp
View file

@ -297,9 +297,9 @@ public:
static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(NULL); static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(NULL);
static InstanceKlass* prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik, static InstanceKlass* prepare_shared_lambda_proxy_class(InstanceKlass* lambda_ik,
InstanceKlass* caller_ik, TRAPS) NOT_CDS_RETURN_(NULL); InstanceKlass* caller_ik, TRAPS) NOT_CDS_RETURN_(NULL);
static bool check_linking_constraints(InstanceKlass* klass, TRAPS) NOT_CDS_RETURN_(false); static bool check_linking_constraints(Thread* current, InstanceKlass* klass) NOT_CDS_RETURN_(false);
static void record_linking_constraint(Symbol* name, InstanceKlass* klass, static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
Handle loader1, Handle loader2, TRAPS) NOT_CDS_RETURN; Handle loader1, Handle loader2) NOT_CDS_RETURN;
static bool is_builtin(InstanceKlass* k) { static bool is_builtin(InstanceKlass* k) {
return (k->shared_classpath_index() != UNREGISTERED_INDEX); return (k->shared_classpath_index() != UNREGISTERED_INDEX);
} }

5
src/hotspot/share/interpreter/linkResolver.cpp
View file

@ -675,7 +675,7 @@ void LinkResolver::check_method_loader_constraints(const LinkInfo& link_info,
SystemDictionary::check_signature_loaders(link_info.signature(), SystemDictionary::check_signature_loaders(link_info.signature(),
/*klass_being_linked*/ NULL, // We are not linking class /*klass_being_linked*/ NULL, // We are not linking class
current_loader, current_loader,
resolved_loader, true, CHECK); resolved_loader, true);
if (failed_type_symbol != NULL) { if (failed_type_symbol != NULL) {
Klass* current_class = link_info.current_klass(); Klass* current_class = link_info.current_klass();
ClassLoaderData* current_loader_data = current_class->class_loader_data(); ClassLoaderData* current_loader_data = current_class->class_loader_data();
@ -712,8 +712,7 @@ void LinkResolver::check_field_loader_constraints(Symbol* field, Symbol* sig,
SystemDictionary::check_signature_loaders(sig, SystemDictionary::check_signature_loaders(sig,
/*klass_being_linked*/ NULL, // We are not linking class /*klass_being_linked*/ NULL, // We are not linking class
ref_loader, sel_loader, ref_loader, sel_loader,
false, false);
CHECK);
if (failed_type_symbol != NULL) { if (failed_type_symbol != NULL) {
stringStream ss; stringStream ss;
const char* failed_type_name = failed_type_symbol->as_klass_external_name(); const char* failed_type_name = failed_type_symbol->as_klass_external_name();

8
src/hotspot/share/jvmci/jvmciRuntime.cpp
View file

@ -1255,8 +1255,8 @@ Klass* JVMCIRuntime::get_klass_by_name_impl(Klass*& accessing_klass,
return get_klass_by_name_impl(accessing_klass, cpool, strippedsym, require_local); return get_klass_by_name_impl(accessing_klass, cpool, strippedsym, require_local);
} }
Handle loader(THREAD, (oop)NULL); Handle loader;
Handle domain(THREAD, (oop)NULL); Handle domain;
if (accessing_klass != NULL) { if (accessing_klass != NULL) {
loader = Handle(THREAD, accessing_klass->class_loader()); loader = Handle(THREAD, accessing_klass->class_loader());
domain = Handle(THREAD, accessing_klass->protection_domain()); domain = Handle(THREAD, accessing_klass->protection_domain());
@ -1265,9 +1265,9 @@ Klass* JVMCIRuntime::get_klass_by_name_impl(Klass*& accessing_klass,
Klass* found_klass; Klass* found_klass;
{ {
ttyUnlocker ttyul; // release tty lock to avoid ordering problems ttyUnlocker ttyul; // release tty lock to avoid ordering problems
MutexLocker ml(Compile_lock); MutexLocker ml(THREAD, Compile_lock);
if (!require_local) { if (!require_local) {
found_klass = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader, THREAD); found_klass = SystemDictionary::find_constrained_instance_or_array_klass(THREAD, sym, loader);
} else { } else {
found_klass = SystemDictionary::find_instance_or_array_klass(sym, loader, domain); found_klass = SystemDictionary::find_instance_or_array_klass(sym, loader, domain);
} }

2
src/hotspot/share/oops/instanceKlass.cpp
View file

@ -984,7 +984,7 @@ bool InstanceKlass::link_class_impl(TRAPS) {
// 1) the class is loaded by custom class loader or // 1) the class is loaded by custom class loader or
// 2) the class is loaded by built-in class loader but failed to add archived loader constraints // 2) the class is loaded by built-in class loader but failed to add archived loader constraints
bool need_init_table = true; bool need_init_table = true;
if (is_shared() && SystemDictionaryShared::check_linking_constraints(this, THREAD)) { if (is_shared() && SystemDictionaryShared::check_linking_constraints(THREAD, this)) {
need_init_table = false; need_init_table = false;
} }
if (need_init_table) { if (need_init_table) {

4
src/hotspot/share/oops/klassVtable.cpp
View file

@ -525,7 +525,7 @@ bool klassVtable::update_inherited_vtable(const methodHandle& target_method,
Symbol* failed_type_symbol = Symbol* failed_type_symbol =
SystemDictionary::check_signature_loaders(signature, _klass, SystemDictionary::check_signature_loaders(signature, _klass,
target_loader, super_loader, target_loader, super_loader,
true, CHECK_(false)); true);
if (failed_type_symbol != NULL) { if (failed_type_symbol != NULL) {
stringStream ss; stringStream ss;
ss.print("loader constraint violation for class %s: when selecting " ss.print("loader constraint violation for class %s: when selecting "
@ -1269,7 +1269,7 @@ void klassItable::initialize_itable_for_interface(int method_table_offset, Insta
_klass, _klass,
method_holder_loader, method_holder_loader,
interface_loader, interface_loader,
true, CHECK); true);
if (failed_type_symbol != NULL) { if (failed_type_symbol != NULL) {
stringStream ss; stringStream ss;
ss.print("loader constraint violation in interface itable" ss.print("loader constraint violation in interface itable"

3
src/hotspot/share/oops/objArrayKlass.cpp
View file

@ -320,8 +320,7 @@ Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
if (higher_dimension_acquire() == NULL) { if (higher_dimension_acquire() == NULL) {
if (or_null) return NULL; if (or_null) return NULL;
ResourceMark rm; ResourceMark rm(THREAD);
JavaThread *jt = THREAD->as_Java_thread();
{ {
// Ensure atomic creation of higher dimensions // Ensure atomic creation of higher dimensions
MutexLocker mu(THREAD, MultiArray_lock); MutexLocker mu(THREAD, MultiArray_lock);