       1 /*
       2  * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
       3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
       4  *
       5  * This code is free software; you can redistribute it and/or modify it
       6  * under the terms of the GNU General Public License version 2 only, as
       7  * published by the Free Software Foundation.
       8  *
       9  * This code is distributed in the hope that it will be useful, but WITHOUT
      10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      12  * version 2 for more details (a copy is included in the LICENSE file that
      13  * accompanied this code).
      14  *
      15  * You should have received a copy of the GNU General Public License version
      16  * 2 along with this work; if not, write to the Free Software Foundation,
      17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
      18  *
      19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
      20  * or visit www.oracle.com if you need additional information or have any
      21  * questions.
      22  *
      23  */
      24
      25 #include "precompiled.hpp"
      26 #include "classfile/dictionary.hpp"
      27 #include "classfile/systemDictionary.hpp"
      28 #include "memory/iterator.hpp"
      29 #include "oops/oop.inline.hpp"
      30 #include "prims/jvmtiRedefineClassesTrace.hpp"
      31 #include "runtime/orderAccess.inline.hpp"
      32 #include "utilities/hashtable.inline.hpp"
      33
      34 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
      35
      36 DictionaryEntry*  Dictionary::_current_class_entry = NULL;
      37 int               Dictionary::_current_class_index =    0;
      38
      39
      40 Dictionary::Dictionary(int table_size)
      41   : TwoOopHashtable<Klass*, mtClass>(table_size, sizeof(DictionaryEntry)) {
      42   _current_class_index = 0;
      43   _current_class_entry = NULL;
      44   _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
      45 };
      46
      47
      48 Dictionary::Dictionary(int table_size, HashtableBucket<mtClass>* t,
      49                        int number_of_entries)
      50   : TwoOopHashtable<Klass*, mtClass>(table_size, sizeof(DictionaryEntry), t, number_of_entries) {
      51   _current_class_index = 0;
      52   _current_class_entry = NULL;
      53   _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
      54 };
      55
      56 ProtectionDomainCacheEntry* Dictionary::cache_get(oop protection_domain) {
      57   return _pd_cache_table->get(protection_domain);
      58 }
      59
      60 DictionaryEntry* Dictionary::new_entry(unsigned int hash, Klass* klass,
      61                                        ClassLoaderData* loader_data) {
      62   DictionaryEntry* entry = (DictionaryEntry*)Hashtable<Klass*, mtClass>::new_entry(hash, klass);
      63   entry->set_loader_data(loader_data);
      64   entry->set_pd_set(NULL);
      65   assert(klass->oop_is_instance(), "Must be");
      66   return entry;
      67 }
      68
      69
      70 void Dictionary::free_entry(DictionaryEntry* entry) {
      71   // avoid recursion when deleting linked list
      72   while (entry->pd_set() != NULL) {
      73     ProtectionDomainEntry* to_delete = entry->pd_set();
      74     entry->set_pd_set(to_delete->next());
      75     delete to_delete;
      76   }
      77   Hashtable<Klass*, mtClass>::free_entry(entry);
      78 }
      79
      80
      81 bool DictionaryEntry::contains_protection_domain(oop protection_domain) const {
      82 #ifdef ASSERT
      83   if (protection_domain == InstanceKlass::cast(klass())->protection_domain()) {
      84     // Ensure this doesn't show up in the pd_set (invariant)
      85     bool in_pd_set = false;
      86     for (ProtectionDomainEntry* current = _pd_set;
      87                                 current != NULL;
      88                                 current = current->next()) {
      89       if (current->protection_domain() == protection_domain) {
      90         in_pd_set = true;
      91         break;
      92       }
      93     }
      94     if (in_pd_set) {
      95       assert(false, "A klass's protection domain should not show up "
      96                     "in its sys. dict. PD set");
      97     }
      98   }
      99 #endif /* ASSERT */
     100
     101   if (protection_domain == InstanceKlass::cast(klass())->protection_domain()) {
     102     // Succeeds trivially
     103     return true;
     104   }
     105
     106   for (ProtectionDomainEntry* current = _pd_set;
     107                               current != NULL;
     108                               current = current->next()) {
     109     if (current->protection_domain() == protection_domain) return true;
     110   }
     111   return false;
     112 }
     113
     114
     115 void DictionaryEntry::add_protection_domain(Dictionary* dict, oop protection_domain) {
     116   assert_locked_or_safepoint(SystemDictionary_lock);
     117   if (!contains_protection_domain(protection_domain)) {
     118     ProtectionDomainCacheEntry* entry = dict->cache_get(protection_domain);
     119     ProtectionDomainEntry* new_head =
     120                 new ProtectionDomainEntry(entry, _pd_set);
     121     // Warning: Preserve store ordering.  The SystemDictionary is read
     122     //          without locks.  The new ProtectionDomainEntry must be
     123     //          complete before other threads can be allowed to see it
     124     //          via a store to _pd_set.
     125     OrderAccess::release_store_ptr(&_pd_set, new_head);
     126   }
     127   if (TraceProtectionDomainVerification && WizardMode) {
     128     print();
     129   }
     130 }
     131
     132
     133 void Dictionary::do_unloading() {
     134   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
     135
     136   // Remove unloadable entries and classes from system dictionary
     137   // The placeholder array has been handled in always_strong_oops_do.
     138   DictionaryEntry* probe = NULL;
     139   for (int index = 0; index < table_size(); index++) {
     140     for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) {
     141       probe = *p;
     142       Klass* e = probe->klass();
     143       ClassLoaderData* loader_data = probe->loader_data();
     144
     145       InstanceKlass* ik = InstanceKlass::cast(e);
     146
     147       // Non-unloadable classes were handled in always_strong_oops_do
     148       if (!is_strongly_reachable(loader_data, e)) {
     149         // Entry was not visited in phase1 (negated test from phase1)
     150         assert(!loader_data->is_the_null_class_loader_data(), "unloading entry with null class loader");
     151         ClassLoaderData* k_def_class_loader_data = ik->class_loader_data();
     152
     153         // Do we need to delete this system dictionary entry?
     154         bool purge_entry = false;
     155
     156         // Do we need to delete this system dictionary entry?
     157         if (loader_data->is_unloading()) {
     158           // If the loader is not live this entry should always be
     159           // removed (will never be looked up again).
     160           purge_entry = true;
     161         } else {
     162           // The loader in this entry is alive. If the klass is dead,
     163           // (determined by checking the defining class loader)
     164           // the loader must be an initiating loader (rather than the
     165           // defining loader). Remove this entry.
     166           if (k_def_class_loader_data->is_unloading()) {
     167             // If we get here, the class_loader_data must not be the defining
     168             // loader, it must be an initiating one.
     169             assert(k_def_class_loader_data != loader_data,
     170                    "cannot have live defining loader and unreachable klass");
     171             // Loader is live, but class and its defining loader are dead.
     172             // Remove the entry. The class is going away.
     173             purge_entry = true;
     174           }
     175         }
     176
     177         if (purge_entry) {
     178           *p = probe->next();
     179           if (probe == _current_class_entry) {
     180             _current_class_entry = NULL;
     181           }
     182           free_entry(probe);
     183           continue;
     184         }
     185       }
     186       p = probe->next_addr();
     187     }
     188   }
     189 }
     190
     191 void Dictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
     192   // Skip the strong roots probe marking if the closures are the same.
     193   if (strong == weak) {
     194     oops_do(strong);
     195     return;
     196   }
     197
     198   for (int index = 0; index < table_size(); index++) {
     199     for (DictionaryEntry *probe = bucket(index);
     200                           probe != NULL;
     201                           probe = probe->next()) {
     202       Klass* e = probe->klass();
     203       ClassLoaderData* loader_data = probe->loader_data();
     204       if (is_strongly_reachable(loader_data, e)) {
     205         probe->set_strongly_reachable();
     206       }
     207     }
     208   }
     209   _pd_cache_table->roots_oops_do(strong, weak);
     210 }
     211
     212 void Dictionary::remove_classes_in_error_state() {
     213   assert(DumpSharedSpaces, "supported only when dumping");
     214   DictionaryEntry* probe = NULL;
     215   for (int index = 0; index < table_size(); index++) {
     216     for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) {
     217       probe = *p;
     218       InstanceKlass* ik = InstanceKlass::cast(probe->klass());
     219       if (ik->is_in_error_state()) { // purge this entry
     220         *p = probe->next();
     221         if (probe == _current_class_entry) {
     222           _current_class_entry = NULL;
     223         }
     224         free_entry(probe);
     225         ResourceMark rm;
     226         tty->print_cr("Preload Warning: Removed error class: %s", ik->external_name());
     227         continue;
     228       }
     229
     230       p = probe->next_addr();
     231     }
     232   }
     233 }
     234
     235 void Dictionary::always_strong_oops_do(OopClosure* blk) {
     236   // Follow all system classes and temporary placeholders in dictionary; only
     237   // protection domain oops contain references into the heap. In a first
     238   // pass over the system dictionary determine which need to be treated as
     239   // strongly reachable and mark them as such.
     240   for (int index = 0; index < table_size(); index++) {
     241     for (DictionaryEntry *probe = bucket(index);
     242                           probe != NULL;
     243                           probe = probe->next()) {
     244       Klass* e = probe->klass();
     245       ClassLoaderData* loader_data = probe->loader_data();
     246       if (is_strongly_reachable(loader_data, e)) {
     247         probe->set_strongly_reachable();
     248       }
     249     }
     250   }
     251   // Then iterate over the protection domain cache to apply the closure on the
     252   // previously marked ones.
     253   _pd_cache_table->always_strong_oops_do(blk);
     254 }
     255
     256
     257 void Dictionary::always_strong_classes_do(KlassClosure* closure) {
     258   // Follow all system classes and temporary placeholders in dictionary
     259   for (int index = 0; index < table_size(); index++) {
     260     for (DictionaryEntry* probe = bucket(index);
     261                           probe != NULL;
     262                           probe = probe->next()) {
     263       Klass* e = probe->klass();
     264       ClassLoaderData* loader_data = probe->loader_data();
     265       if (is_strongly_reachable(loader_data, e)) {
     266         closure->do_klass(e);
     267       }
     268     }
     269   }
     270 }
     271
     272
     273 //   Just the classes from defining class loaders
     274 void Dictionary::classes_do(void f(Klass*)) {
     275   for (int index = 0; index < table_size(); index++) {
     276     for (DictionaryEntry* probe = bucket(index);
     277                           probe != NULL;
     278                           probe = probe->next()) {
     279       Klass* k = probe->klass();
     280       if (probe->loader_data() == InstanceKlass::cast(k)->class_loader_data()) {
     281         f(k);
     282       }
     283     }
     284   }
     285 }
     286
     287 // Added for initialize_itable_for_klass to handle exceptions
     288 //   Just the classes from defining class loaders
     289 void Dictionary::classes_do(void f(Klass*, TRAPS), TRAPS) {
     290   for (int index = 0; index < table_size(); index++) {
     291     for (DictionaryEntry* probe = bucket(index);
     292                           probe != NULL;
     293                           probe = probe->next()) {
     294       Klass* k = probe->klass();
     295       if (probe->loader_data() == InstanceKlass::cast(k)->class_loader_data()) {
     296         f(k, CHECK);
     297       }
     298     }
     299   }
     300 }
     301
     302 //   All classes, and their class loaders
     303 // Don't iterate over placeholders
     304 void Dictionary::classes_do(void f(Klass*, ClassLoaderData*)) {
     305   for (int index = 0; index < table_size(); index++) {
     306     for (DictionaryEntry* probe = bucket(index);
     307                           probe != NULL;
     308                           probe = probe->next()) {
     309       Klass* k = probe->klass();
     310       f(k, probe->loader_data());
     311     }
     312   }
     313 }
     314
     315 void Dictionary::oops_do(OopClosure* f) {
     316   // Only the protection domain oops contain references into the heap. Iterate
     317   // over all of them.
     318   _pd_cache_table->oops_do(f);
     319 }
     320
     321 void Dictionary::methods_do(void f(Method*)) {
     322   for (int index = 0; index < table_size(); index++) {
     323     for (DictionaryEntry* probe = bucket(index);
     324                           probe != NULL;
     325                           probe = probe->next()) {
     326       Klass* k = probe->klass();
     327       if (probe->loader_data() == InstanceKlass::cast(k)->class_loader_data()) {
     328         // only take klass is we have the entry with the defining class loader
     329         InstanceKlass::cast(k)->methods_do(f);
     330       }
     331     }
     332   }
     333 }
     334
     335 void Dictionary::unlink(BoolObjectClosure* is_alive) {
     336   // Only the protection domain cache table may contain references to the heap
     337   // that need to be unlinked.
     338   _pd_cache_table->unlink(is_alive);
     339 }
     340
     341 Klass* Dictionary::try_get_next_class() {
     342   while (true) {
     343     if (_current_class_entry != NULL) {
     344       Klass* k = _current_class_entry->klass();
     345       _current_class_entry = _current_class_entry->next();
     346       return k;
     347     }
     348     _current_class_index = (_current_class_index + 1) % table_size();
     349     _current_class_entry = bucket(_current_class_index);
     350   }
     351   // never reached
     352 }
     353
     354 // Add a loaded class to the system dictionary.
     355 // Readers of the SystemDictionary aren't always locked, so _buckets
     356 // is volatile. The store of the next field in the constructor is
     357 // also cast to volatile;  we do this to ensure store order is maintained
     358 // by the compilers.
     359
     360 void Dictionary::add_klass(Symbol* class_name, ClassLoaderData* loader_data,
     361                            KlassHandle obj) {
     362   assert_locked_or_safepoint(SystemDictionary_lock);
     363   assert(obj() != NULL, "adding NULL obj");
     364   assert(obj()->name() == class_name, "sanity check on name");
     365   assert(loader_data != NULL, "Must be non-NULL");
     366
     367   unsigned int hash = compute_hash(class_name, loader_data);
     368   int index = hash_to_index(hash);
     369   DictionaryEntry* entry = new_entry(hash, obj(), loader_data);
     370   add_entry(index, entry);
     371 }
     372
     373
     374 // This routine does not lock the system dictionary.
     375 //
     376 // Since readers don't hold a lock, we must make sure that system
     377 // dictionary entries are only removed at a safepoint (when only one
     378 // thread is running), and are added to in a safe way (all links must
     379 // be updated in an MT-safe manner).
     380 //
     381 // Callers should be aware that an entry could be added just after
     382 // _buckets[index] is read here, so the caller will not see the new entry.
     383 DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash,
     384                                        Symbol* class_name,
     385                                        ClassLoaderData* loader_data) {
     386   debug_only(_lookup_count++);
     387   for (DictionaryEntry* entry = bucket(index);
     388                         entry != NULL;
     389                         entry = entry->next()) {
     390     if (entry->hash() == hash && entry->equals(class_name, loader_data)) {
     391       return entry;
     392     }
     393     debug_only(_lookup_length++);
     394   }
     395   return NULL;
     396 }
     397
     398
     399 Klass* Dictionary::find(int index, unsigned int hash, Symbol* name,
     400                           ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
     401   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     402   if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) {
     403     return entry->klass();
     404   } else {
     405     return NULL;
     406   }
     407 }
     408
     409
     410 Klass* Dictionary::find_class(int index, unsigned int hash,
     411                                 Symbol* name, ClassLoaderData* loader_data) {
     412   assert_locked_or_safepoint(SystemDictionary_lock);
     413   assert (index == index_for(name, loader_data), "incorrect index?");
     414
     415   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     416   return (entry != NULL) ? entry->klass() : (Klass*)NULL;
     417 }
     418
     419
     420 // Variant of find_class for shared classes.  No locking required, as
     421 // that table is static.
     422
     423 Klass* Dictionary::find_shared_class(int index, unsigned int hash,
     424                                        Symbol* name) {
     425   assert (index == index_for(name, NULL), "incorrect index?");
     426
     427   DictionaryEntry* entry = get_entry(index, hash, name, NULL);
     428   return (entry != NULL) ? entry->klass() : (Klass*)NULL;
     429 }
     430
     431
     432 void Dictionary::add_protection_domain(int index, unsigned int hash,
     433                                        instanceKlassHandle klass,
     434                                        ClassLoaderData* loader_data, Handle protection_domain,
     435                                        TRAPS) {
     436   Symbol*  klass_name = klass->name();
     437   DictionaryEntry* entry = get_entry(index, hash, klass_name, loader_data);
     438
     439   assert(entry != NULL,"entry must be present, we just created it");
     440   assert(protection_domain() != NULL,
     441          "real protection domain should be present");
     442
     443   entry->add_protection_domain(this, protection_domain());
     444
     445   assert(entry->contains_protection_domain(protection_domain()),
     446          "now protection domain should be present");
     447 }
     448
     449
     450 bool Dictionary::is_valid_protection_domain(int index, unsigned int hash,
     451                                             Symbol* name,
     452                                             ClassLoaderData* loader_data,
     453                                             Handle protection_domain) {
     454   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     455   return entry->is_valid_protection_domain(protection_domain);
     456 }
     457
     458
     459 void Dictionary::reorder_dictionary() {
     460
     461   // Copy all the dictionary entries into a single master list.
     462
     463   DictionaryEntry* master_list = NULL;
     464   for (int i = 0; i < table_size(); ++i) {
     465     DictionaryEntry* p = bucket(i);
     466     while (p != NULL) {
     467       DictionaryEntry* tmp;
     468       tmp = p->next();
     469       p->set_next(master_list);
     470       master_list = p;
     471       p = tmp;
     472     }
     473     set_entry(i, NULL);
     474   }
     475
     476   // Add the dictionary entries back to the list in the correct buckets.
     477   while (master_list != NULL) {
     478     DictionaryEntry* p = master_list;
     479     master_list = master_list->next();
     480     p->set_next(NULL);
     481     Symbol* class_name = InstanceKlass::cast((Klass*)(p->klass()))->name();
     482     // Since the null class loader data isn't copied to the CDS archive,
     483     // compute the hash with NULL for loader data.
     484     unsigned int hash = compute_hash(class_name, NULL);
     485     int index = hash_to_index(hash);
     486     p->set_hash(hash);
     487     p->set_loader_data(NULL);   // loader_data isn't copied to CDS
     488     p->set_next(bucket(index));
     489     set_entry(index, p);
     490   }
     491 }
     492
     493 ProtectionDomainCacheTable::ProtectionDomainCacheTable(int table_size)
     494   : Hashtable<oop, mtClass>(table_size, sizeof(ProtectionDomainCacheEntry))
     495 {
     496 }
     497
     498 void ProtectionDomainCacheTable::unlink(BoolObjectClosure* is_alive) {
     499   assert(SafepointSynchronize::is_at_safepoint(), "must be");
     500   for (int i = 0; i < table_size(); ++i) {
     501     ProtectionDomainCacheEntry** p = bucket_addr(i);
     502     ProtectionDomainCacheEntry* entry = bucket(i);
     503     while (entry != NULL) {
     504       if (is_alive->do_object_b(entry->literal())) {
     505         p = entry->next_addr();
     506       } else {
     507         *p = entry->next();
     508         free_entry(entry);
     509       }
     510       entry = *p;
     511     }
     512   }
     513 }
     514
     515 void ProtectionDomainCacheTable::oops_do(OopClosure* f) {
     516   for (int index = 0; index < table_size(); index++) {
     517     for (ProtectionDomainCacheEntry* probe = bucket(index);
     518                                      probe != NULL;
     519                                      probe = probe->next()) {
     520       probe->oops_do(f);
     521     }
     522   }
     523 }
     524
     525 void ProtectionDomainCacheTable::roots_oops_do(OopClosure* strong, OopClosure* weak) {
     526   for (int index = 0; index < table_size(); index++) {
     527     for (ProtectionDomainCacheEntry* probe = bucket(index);
     528                                      probe != NULL;
     529                                      probe = probe->next()) {
     530       if (probe->is_strongly_reachable()) {
     531         probe->reset_strongly_reachable();
     532         probe->oops_do(strong);
     533       } else {
     534         if (weak != NULL) {
     535           probe->oops_do(weak);
     536         }
     537       }
     538     }
     539   }
     540 }
     541
     542 uint ProtectionDomainCacheTable::bucket_size() {
     543   return sizeof(ProtectionDomainCacheEntry);
     544 }
     545
     546 #ifndef PRODUCT
     547 void ProtectionDomainCacheTable::print() {
     548   tty->print_cr("Protection domain cache table (table_size=%d, classes=%d)",
     549                 table_size(), number_of_entries());
     550   for (int index = 0; index < table_size(); index++) {
     551     for (ProtectionDomainCacheEntry* probe = bucket(index);
     552                                      probe != NULL;
     553                                      probe = probe->next()) {
     554       probe->print();
     555     }
     556   }
     557 }
     558
     559 void ProtectionDomainCacheEntry::print() {
     560   tty->print_cr("entry "PTR_FORMAT" value "PTR_FORMAT" strongly_reachable %d next "PTR_FORMAT,
     561                 this, (void*)literal(), _strongly_reachable, next());
     562 }
     563 #endif
     564
     565 void ProtectionDomainCacheTable::verify() {
     566   int element_count = 0;
     567   for (int index = 0; index < table_size(); index++) {
     568     for (ProtectionDomainCacheEntry* probe = bucket(index);
     569                                      probe != NULL;
     570                                      probe = probe->next()) {
     571       probe->verify();
     572       element_count++;
     573     }
     574   }
     575   guarantee(number_of_entries() == element_count,
     576             "Verify of protection domain cache table failed");
     577   debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
     578 }
     579
     580 void ProtectionDomainCacheEntry::verify() {
     581   guarantee(literal()->is_oop(), "must be an oop");
     582 }
     583
     584 void ProtectionDomainCacheTable::always_strong_oops_do(OopClosure* f) {
     585   // the caller marked the protection domain cache entries that we need to apply
     586   // the closure on. Only process them.
     587   for (int index = 0; index < table_size(); index++) {
     588     for (ProtectionDomainCacheEntry* probe = bucket(index);
     589                                      probe != NULL;
     590                                      probe = probe->next()) {
     591       if (probe->is_strongly_reachable()) {
     592         probe->reset_strongly_reachable();
     593         probe->oops_do(f);
     594       }
     595     }
     596   }
     597 }
     598
     599 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::get(oop protection_domain) {
     600   unsigned int hash = compute_hash(protection_domain);
     601   int index = hash_to_index(hash);
     602
     603   ProtectionDomainCacheEntry* entry = find_entry(index, protection_domain);
     604   if (entry == NULL) {
     605     entry = add_entry(index, hash, protection_domain);
     606   }
     607   return entry;
     608 }
     609
     610 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::find_entry(int index, oop protection_domain) {
     611   for (ProtectionDomainCacheEntry* e = bucket(index); e != NULL; e = e->next()) {
     612     if (e->protection_domain() == protection_domain) {
     613       return e;
     614     }
     615   }
     616
     617   return NULL;
     618 }
     619
     620 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::add_entry(int index, unsigned int hash, oop protection_domain) {
     621   assert_locked_or_safepoint(SystemDictionary_lock);
     622   assert(index == index_for(protection_domain), "incorrect index?");
     623   assert(find_entry(index, protection_domain) == NULL, "no double entry");
     624
     625   ProtectionDomainCacheEntry* p = new_entry(hash, protection_domain);
     626   Hashtable<oop, mtClass>::add_entry(index, p);
     627   return p;
     628 }
     629
     630 void ProtectionDomainCacheTable::free(ProtectionDomainCacheEntry* to_delete) {
     631   unsigned int hash = compute_hash(to_delete->protection_domain());
     632   int index = hash_to_index(hash);
     633
     634   ProtectionDomainCacheEntry** p = bucket_addr(index);
     635   ProtectionDomainCacheEntry* entry = bucket(index);
     636   while (true) {
     637     assert(entry != NULL, "sanity");
     638
     639     if (entry == to_delete) {
     640       *p = entry->next();
     641       Hashtable<oop, mtClass>::free_entry(entry);
     642       break;
     643     } else {
     644       p = entry->next_addr();
     645       entry = *p;
     646     }
     647   }
     648 }
     649
     650 SymbolPropertyTable::SymbolPropertyTable(int table_size)
     651   : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry))
     652 {
     653 }
     654 SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t,
     655                                          int number_of_entries)
     656   : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries)
     657 {
     658 }
     659
     660
     661 SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash,
     662                                                      Symbol* sym,
     663                                                      intptr_t sym_mode) {
     664   assert(index == index_for(sym, sym_mode), "incorrect index?");
     665   for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     666     if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) {
     667       return p;
     668     }
     669   }
     670   return NULL;
     671 }
     672
     673
     674 SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash,
     675                                                     Symbol* sym, intptr_t sym_mode) {
     676   assert_locked_or_safepoint(SystemDictionary_lock);
     677   assert(index == index_for(sym, sym_mode), "incorrect index?");
     678   assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry");
     679
     680   SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode);
     681   Hashtable<Symbol*, mtSymbol>::add_entry(index, p);
     682   return p;
     683 }
     684
     685 void SymbolPropertyTable::oops_do(OopClosure* f) {
     686   for (int index = 0; index < table_size(); index++) {
     687     for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     688       if (p->method_type() != NULL) {
     689         f->do_oop(p->method_type_addr());
     690       }
     691     }
     692   }
     693 }
     694
     695 void SymbolPropertyTable::methods_do(void f(Method*)) {
     696   for (int index = 0; index < table_size(); index++) {
     697     for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     698       Method* prop = p->method();
     699       if (prop != NULL) {
     700         f((Method*)prop);
     701       }
     702     }
     703   }
     704 }
     705
     706
     707 // ----------------------------------------------------------------------------
     708
     709 void Dictionary::print(bool details) {
     710   ResourceMark rm;
     711   HandleMark   hm;
     712
     713   if (details) {
     714     tty->print_cr("Java system dictionary (table_size=%d, classes=%d)",
     715                    table_size(), number_of_entries());
     716     tty->print_cr("^ indicates that initiating loader is different from "
     717                   "defining loader");
     718   }
     719
     720   for (int index = 0; index < table_size(); index++) {
     721     for (DictionaryEntry* probe = bucket(index);
     722                           probe != NULL;
     723                           probe = probe->next()) {
     724       if (Verbose) tty->print("%4d: ", index);
     725       Klass* e = probe->klass();
     726       ClassLoaderData* loader_data =  probe->loader_data();
     727       bool is_defining_class =
     728          (loader_data == InstanceKlass::cast(e)->class_loader_data());
     729       tty->print("%s%s", ((!details) || is_defining_class) ? " " : "^",
     730                    e->external_name());
     731
     732       if (details) {
     733         tty->print(", loader ");
     734         if (loader_data != NULL) {
     735           loader_data->print_value();
     736         } else {
     737           tty->print("NULL");
     738         }
     739       }
     740       tty->cr();
     741     }
     742   }
     743
     744   if (details) {
     745     tty->cr();
     746     _pd_cache_table->print();
     747   }
     748   tty->cr();
     749 }
     750
     751 void Dictionary::verify() {
     752   guarantee(number_of_entries() >= 0, "Verify of system dictionary failed");
     753
     754   int element_count = 0;
     755   for (int index = 0; index < table_size(); index++) {
     756     for (DictionaryEntry* probe = bucket(index);
     757                           probe != NULL;
     758                           probe = probe->next()) {
     759       Klass* e = probe->klass();
     760       ClassLoaderData* loader_data = probe->loader_data();
     761       guarantee(e->oop_is_instance(),
     762                               "Verify of system dictionary failed");
     763       // class loader must be present;  a null class loader is the
     764       // boostrap loader
     765       guarantee(loader_data != NULL || DumpSharedSpaces ||
     766                 loader_data->class_loader() == NULL ||
     767                 loader_data->class_loader()->is_instance(),
     768                 "checking type of class_loader");
     769       e->verify();
     770       probe->verify_protection_domain_set();
     771       element_count++;
     772     }
     773   }
     774   guarantee(number_of_entries() == element_count,
     775             "Verify of system dictionary failed");
     776   debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
     777
     778   _pd_cache_table->verify();
     779 }
     780