< prev index next >
src/share/vm/classfile/loaderConstraints.cpp
Print this page
@@ -34,29 +34,29 @@
void LoaderConstraintEntry::set_loader(int i, oop p) {
set_loader_data(i, ClassLoaderData::class_loader_data(p));
}
LoaderConstraintTable::LoaderConstraintTable(int nof_buckets)
- : Hashtable<Klass*, mtClass>(nof_buckets, sizeof(LoaderConstraintEntry)) {};
+ : Hashtable<InstanceKlass*, mtClass>(nof_buckets, sizeof(LoaderConstraintEntry)) {};
LoaderConstraintEntry* LoaderConstraintTable::new_entry(
unsigned int hash, Symbol* name,
- Klass* klass, int num_loaders,
+ InstanceKlass* klass, int num_loaders,
int max_loaders) {
LoaderConstraintEntry* entry;
- entry = (LoaderConstraintEntry*)Hashtable<Klass*, mtClass>::new_entry(hash, klass);
+ entry = (LoaderConstraintEntry*)Hashtable<InstanceKlass*, mtClass>::new_entry(hash, klass);
entry->set_name(name);
entry->set_num_loaders(num_loaders);
entry->set_max_loaders(max_loaders);
return entry;
}
void LoaderConstraintTable::free_entry(LoaderConstraintEntry *entry) {
// decrement name refcount before freeing
entry->name()->decrement_refcount();
- Hashtable<Klass*, mtClass>::free_entry(entry);
+ Hashtable<InstanceKlass*, mtClass>::free_entry(entry);
}
// Enhanced Class Redefinition support
void LoaderConstraintTable::classes_do(KlassClosure* f) {
for (int index = 0; index < table_size(); index++) {
@@ -104,11 +104,11 @@
// Remove unloaded entries from constraint table
for (int index = 0; index < table_size(); index++) {
LoaderConstraintEntry** p = bucket_addr(index);
while(*p) {
LoaderConstraintEntry* probe = *p;
- Klass* klass = probe->klass();
+ InstanceKlass* klass = probe->klass();
// Remove klass that is no longer alive
if (klass != NULL &&
klass->class_loader_data()->is_unloading()) {
probe->set_klass(NULL);
if (log_is_enabled(Info, class, loader, constraints)) {
@@ -184,18 +184,18 @@
}
}
}
bool LoaderConstraintTable::add_entry(Symbol* class_name,
- Klass* klass1, Handle class_loader1,
- Klass* klass2, Handle class_loader2) {
+ InstanceKlass* klass1, Handle class_loader1,
+ InstanceKlass* klass2, Handle class_loader2) {
int failure_code = 0; // encode different reasons for failing
if (klass1 != NULL && klass2 != NULL && klass1 != klass2) {
failure_code = 1;
} else {
- Klass* klass = klass1 != NULL ? klass1 : klass2;
+ InstanceKlass* klass = klass1 != NULL ? klass1 : klass2;
LoaderConstraintEntry** pp1 = find_loader_constraint(class_name,
class_loader1);
if (*pp1 != NULL && (*pp1)->klass() != NULL) {
if (klass != NULL) {
@@ -293,15 +293,15 @@
}
// return true if the constraint was updated, false if the constraint is
// violated
-bool LoaderConstraintTable::check_or_update(instanceKlassHandle k,
+bool LoaderConstraintTable::check_or_update(InstanceKlass* k,
Handle loader,
Symbol* name) {
LoaderConstraintEntry* p = *(find_loader_constraint(name, loader));
- if (p && p->klass() != NULL && p->klass() != k()) {
+ if (p && p->klass() != NULL && p->klass() != k) {
if (log_is_enabled(Info, class, loader, constraints)) {
ResourceMark rm;
outputStream* out = Log(class, loader, constraints)::info_stream();
out->print_cr("constraint check failed for name %s, loader %s: "
"the presented class object differs from that stored",
@@ -309,11 +309,11 @@
SystemDictionary::loader_name(loader()));
}
return false;
} else {
if (p && p->klass() == NULL) {
- p->set_klass(k());
+ p->set_klass(k);
if (log_is_enabled(Info, class, loader, constraints)) {
ResourceMark rm;
outputStream* out = Log(class, loader, constraints)::info_stream();
out->print_cr("updating constraint for name %s, loader %s, "
"by setting class object",
@@ -323,15 +323,16 @@
}
return true;
}
}
-Klass* LoaderConstraintTable::find_constrained_klass(Symbol* name,
+InstanceKlass* LoaderConstraintTable::find_constrained_klass(Symbol* name,
Handle loader) {
LoaderConstraintEntry *p = *(find_loader_constraint(name, loader));
if (p != NULL && p->klass() != NULL) {
- if (p->klass()->is_instance_klass() && !InstanceKlass::cast(p->klass())->is_loaded()) {
+ assert(p->klass()->is_instance_klass(), "sanity");
+ if (p->klass()->is_loaded()) {
// Only return fully loaded classes. Classes found through the
// constraints might still be in the process of loading.
return NULL;
}
return p->klass();
@@ -355,11 +356,11 @@
}
void LoaderConstraintTable::extend_loader_constraint(LoaderConstraintEntry* p,
Handle loader,
- Klass* klass) {
+ InstanceKlass* klass) {
ensure_loader_constraint_capacity(p, 1);
int num = p->num_loaders();
p->set_loader(num, loader());
p->set_num_loaders(num + 1);
if (log_is_enabled(Info, class, loader, constraints)) {
@@ -381,11 +382,11 @@
void LoaderConstraintTable::merge_loader_constraints(
LoaderConstraintEntry** pp1,
LoaderConstraintEntry** pp2,
- Klass* klass) {
+ InstanceKlass* klass) {
// make sure *pp1 has higher capacity
if ((*pp1)->max_loaders() < (*pp2)->max_loaders()) {
LoaderConstraintEntry** tmp = pp2;
pp2 = pp1;
pp1 = tmp;
@@ -445,17 +446,17 @@
for (int cindex = 0; cindex < _loader_constraint_size; cindex++) {
for (LoaderConstraintEntry* probe = bucket(cindex);
probe != NULL;
probe = probe->next()) {
if (probe->klass() != NULL) {
- InstanceKlass* ik = InstanceKlass::cast(probe->klass());
+ InstanceKlass* ik = probe->klass();
guarantee(ik->name() == probe->name(), "name should match");
Symbol* name = ik->name();
ClassLoaderData* loader_data = ik->class_loader_data();
unsigned int d_hash = dictionary->compute_hash(name, loader_data);
int d_index = dictionary->hash_to_index(d_hash);
- Klass* k = dictionary->find_class(d_index, d_hash, name, loader_data);
+ InstanceKlass* k = dictionary->find_class(d_index, d_hash, name, loader_data);
if (k != NULL) {
// We found the class in the system dictionary, so we should
// make sure that the Klass* matches what we already have.
guarantee(k == probe->klass(), "klass should be in dictionary");
} else {
< prev index next >