src/share/vm/classfile/dictionary.cpp

@@ -175,10 +175,15 @@
           // The loader in this entry is alive. If the klass is dead,
           // (determined by checking the defining class loader)
           // the loader must be an initiating loader (rather than the
           // defining loader). Remove this entry.
           if (k_def_class_loader_data->is_unloading()) {
+            ResourceMark rm;
+            tty->print_cr("loader data %s loads class %s in loader data %s",
+                          loader_data->loader_name(),
+                          ik->name()->as_C_string(), k_def_class_loader_data->loader_name());
+            ShouldNotReachHere(); // isn't there a dependency created? or k_loader_data is parent of loader_data??
             // If we get here, the class_loader_data must not be the defining
             // loader, it must be an initiating one.
             assert(k_def_class_loader_data != loader_data,
                    "cannot have live defining loader and unreachable klass");
             // Loader is live, but class and its defining loader are dead.

@@ -264,27 +269,10 @@
   // Then iterate over the protection domain cache to apply the closure on the
   // previously marked ones.
   _pd_cache_table->always_strong_oops_do(blk);
 }
 
-
-void Dictionary::always_strong_classes_do(KlassClosure* closure) {
-  // Follow all system classes and temporary placeholders in dictionary
-  for (int index = 0; index < table_size(); index++) {
-    for (DictionaryEntry* probe = bucket(index);
-                          probe != NULL;
-                          probe = probe->next()) {
-      Klass* e = probe->klass();
-      ClassLoaderData* loader_data = probe->loader_data();
-      if (is_strongly_reachable(loader_data, e)) {
-        closure->do_klass(e);
-      }
-    }
-  }
-}
-
-
 //   Just the classes from defining class loaders
 void Dictionary::classes_do(void f(Klass*)) {
   for (int index = 0; index < table_size(); index++) {
     for (DictionaryEntry* probe = bucket(index);
                           probe != NULL;

@@ -329,24 +317,10 @@
   // Only the protection domain oops contain references into the heap. Iterate
   // over all of them.
   _pd_cache_table->oops_do(f);
 }
 
-void Dictionary::methods_do(void f(Method*)) {
-  for (int index = 0; index < table_size(); index++) {
-    for (DictionaryEntry* probe = bucket(index);
-                          probe != NULL;
-                          probe = probe->next()) {
-      Klass* k = probe->klass();
-      if (probe->loader_data() == k->class_loader_data()) {
-        // only take klass is we have the entry with the defining class loader
-        InstanceKlass::cast(k)->methods_do(f);
-      }
-    }
-  }
-}
-
 void Dictionary::unlink(BoolObjectClosure* is_alive) {
   // Only the protection domain cache table may contain references to the heap
   // that need to be unlinked.
   _pd_cache_table->unlink(is_alive);
 }

@@ -649,29 +623,10 @@
   ProtectionDomainCacheEntry* p = new_entry(hash, protection_domain);
   Hashtable<oop, mtClass>::add_entry(index, p);
   return p;
 }
 
-void ProtectionDomainCacheTable::free(ProtectionDomainCacheEntry* to_delete) {
-  unsigned int hash = compute_hash(Handle(Thread::current(), to_delete->protection_domain()));
-  int index = hash_to_index(hash);
-
-  ProtectionDomainCacheEntry** p = bucket_addr(index);
-  ProtectionDomainCacheEntry* entry = bucket(index);
-  while (true) {
-    assert(entry != NULL, "sanity");
-
-    if (entry == to_delete) {
-      *p = entry->next();
-      Hashtable<oop, mtClass>::free_entry(entry);
-      break;
-    } else {
-      p = entry->next_addr();
-      entry = *p;
-    }
-  }
-}
 
 SymbolPropertyTable::SymbolPropertyTable(int table_size)
   : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry))
 {
 }