< 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 >