       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 #ifndef PRODUCT
     373 //#ifdef PRODUCT_TEST
     374   {
     375     _debug_all_insertion_count++;
     376     _debug_insertion_count++;
     377   }
     378 #endif
     379 }
     380
     381
     382 // This routine does not lock the system dictionary.
     383 //
     384 // Since readers don't hold a lock, we must make sure that system
     385 // dictionary entries are only removed at a safepoint (when only one
     386 // thread is running), and are added to in a safe way (all links must
     387 // be updated in an MT-safe manner).
     388 //
     389 // Callers should be aware that an entry could be added just after
     390 // _buckets[index] is read here, so the caller will not see the new entry.
     391 DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash,
     392                                        Symbol* class_name,
     393                                        ClassLoaderData* loader_data) {
     394   debug_only(_lookup_count++);
     395
     396 #ifndef PRODUCT
     397 //#ifdef PRODUCT_TEST
     398   jlong time = os::javaTimeNanos();
     399   _debug_all_lookup_count++;
     400   _debug_lookup_count++;
     401 #endif
     402
     403   unsigned int count = 0;
     404   for (DictionaryEntry* entry = bucket(index);
     405                         entry != NULL;
     406                         entry = entry->next()) {
     407     count++;
     408     if (entry->hash() == hash && entry->equals(class_name, loader_data)) {
     409
     410       entry->_debug_lookups++;
     411 #ifndef PRODUCT
     412 //#ifdef PRODUCT_TEST
     413       {
     414         unsigned int duration = os::javaTimeNanos()-time;
     415         _debug_lookup_found_count++;
     416         _debug_lookup_found_max_duration = (_debug_lookup_found_max_duration > duration) ? _debug_lookup_found_max_duration : duration;
     417         _debug_lookup_found_total_duration += duration;
     418         _debug_chain_found_maximum_length = (_debug_chain_found_maximum_length > count) ? _debug_chain_found_maximum_length : count;
     419         _debug_chain_found_total_length += count;
     420
     421         long thread_id = os::current_thread_id();
     422         for (int i=0; i<1024; i++) {
     423           if (_debug_table_threads[i] == thread_id) {
     424             break;
     425           } else if (_debug_table_threads[i] == 0) {
     426             _debug_table_threads[i] = thread_id;
     427             break;
     428           }
     429         }
     430       }
     431 #endif
     432
     433       return entry;
     434     }
     435     debug_only(_lookup_length++);
     436   }
     437
     438 #ifndef PRODUCT
     439 //#ifdef PRODUCT_TEST
     440   {
     441     unsigned int duration = os::javaTimeNanos()-time;
     442     _debug_lookup_failed_count++;
     443     _debug_lookup_failed_max_duration = (_debug_lookup_failed_max_duration > duration) ? _debug_lookup_failed_max_duration : duration;
     444     _debug_lookup_failed_total_duration += duration;
     445     _debug_chain_failed_maximum_length = (_debug_chain_failed_maximum_length > count) ? _debug_chain_failed_maximum_length : count;
     446     _debug_chain_failed_total_length += count;
     447   }
     448 #endif
     449
     450   return NULL;
     451 }
     452
     453
     454 Klass* Dictionary::find(unsigned int hash, Symbol* name,
     455                           ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
     456
     457   int index = this->hash_to_index(hash);
     458   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     459   if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) {
     460     return entry->klass();
     461   } else {
     462     return (Klass*)NULL;
     463   }
     464 }
     465
     466
     467 Klass* Dictionary::find_class(unsigned int hash,
     468                                 Symbol* name, ClassLoaderData* loader_data) {
     469   assert_locked_or_safepoint(SystemDictionary_lock);

     470
     471   int index = this->hash_to_index(hash);
     472   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     473   if (entry != NULL) {
     474     return entry->klass();
     475   } else {
     476     return (Klass*)NULL;
     477   }
     478 }
     479
     480
     481 // Variant of find_class for shared classes.  No locking required, as
     482 // that table is static.
     483
     484 Klass* Dictionary::find_shared_class(unsigned int hash,
     485                                        Symbol* name) {

     486
     487   int index = this->hash_to_index(hash);
     488   DictionaryEntry* entry = get_entry(index, hash, name, NULL);
     489   if (entry != NULL) {
     490     return entry->klass();
     491   } else {
     492     return (Klass*)NULL;
     493   }
     494 }
     495
     496
     497 void Dictionary::add_protection_domain(unsigned int hash,
     498                                        instanceKlassHandle klass,
     499                                        ClassLoaderData* loader_data, Handle protection_domain,
     500                                        TRAPS) {
     501   Symbol*  klass_name = klass->name();
     502   int index = this->hash_to_index(hash);
     503   DictionaryEntry* entry = get_entry(index, hash, klass_name, loader_data);
     504
     505   assert(entry != NULL,"entry must be present, we just created it");
     506   assert(protection_domain() != NULL,
     507          "real protection domain should be present");
     508
     509   entry->add_protection_domain(this, protection_domain());
     510
     511   assert(entry->contains_protection_domain(protection_domain()),
     512          "now protection domain should be present");
     513 }
     514
     515
     516 bool Dictionary::is_valid_protection_domain(unsigned int hash,
     517                                             Symbol* name,
     518                                             ClassLoaderData* loader_data,
     519                                             Handle protection_domain) {
     520   int index = this->hash_to_index(hash);
     521   DictionaryEntry* entry = get_entry(index, hash, name, loader_data);
     522
     523   assert(entry != NULL,"entry must be present");
     524
     525   return entry->is_valid_protection_domain(protection_domain);
     526 }
     527
     528
     529 void Dictionary::reorder_dictionary() {
     530
     531   // Copy all the dictionary entries into a single master list.
     532
     533   DictionaryEntry* master_list = NULL;
     534   for (int i = 0; i < table_size(); ++i) {
     535     DictionaryEntry* p = bucket(i);
     536     while (p != NULL) {
     537       DictionaryEntry* tmp;
     538       tmp = p->next();
     539       p->set_next(master_list);
     540       master_list = p;
     541       p = tmp;
     542     }
     543     set_entry(i, NULL);
     544   }
     545
     546   // Add the dictionary entries back to the list in the correct buckets.
     547   while (master_list != NULL) {
     548     DictionaryEntry* p = master_list;
     549     master_list = master_list->next();
     550     p->set_next(NULL);
     551     Symbol* class_name = InstanceKlass::cast((Klass*)(p->klass()))->name();
     552     // Since the null class loader data isn't copied to the CDS archive,
     553     // compute the hash with NULL for loader data.
     554     unsigned int hash = compute_hash(class_name, NULL);
     555     int index = hash_to_index(hash);
     556     p->set_hash(hash);
     557     p->set_loader_data(NULL);   // loader_data isn't copied to CDS
     558     p->set_next(bucket(index));
     559     set_entry(index, p);
     560   }
     561 }
     562
     563 ProtectionDomainCacheTable::ProtectionDomainCacheTable(int table_size)
     564   : Hashtable<oop, mtClass>(table_size, sizeof(ProtectionDomainCacheEntry))
     565 {
     566 }
     567
     568 void ProtectionDomainCacheTable::unlink(BoolObjectClosure* is_alive) {
     569   assert(SafepointSynchronize::is_at_safepoint(), "must be");
     570   for (int i = 0; i < table_size(); ++i) {
     571     ProtectionDomainCacheEntry** p = bucket_addr(i);
     572     ProtectionDomainCacheEntry* entry = bucket(i);
     573     while (entry != NULL) {
     574       if (is_alive->do_object_b(entry->literal())) {
     575         p = entry->next_addr();
     576       } else {
     577         *p = entry->next();
     578         free_entry(entry);
     579       }
     580       entry = *p;
     581     }
     582   }
     583 }
     584
     585 void ProtectionDomainCacheTable::oops_do(OopClosure* f) {
     586   for (int index = 0; index < table_size(); index++) {
     587     for (ProtectionDomainCacheEntry* probe = bucket(index);
     588                                      probe != NULL;
     589                                      probe = probe->next()) {
     590       probe->oops_do(f);
     591     }
     592   }
     593 }
     594
     595 void ProtectionDomainCacheTable::roots_oops_do(OopClosure* strong, OopClosure* weak) {
     596   for (int index = 0; index < table_size(); index++) {
     597     for (ProtectionDomainCacheEntry* probe = bucket(index);
     598                                      probe != NULL;
     599                                      probe = probe->next()) {
     600       if (probe->is_strongly_reachable()) {
     601         probe->reset_strongly_reachable();
     602         probe->oops_do(strong);
     603       } else {
     604         if (weak != NULL) {
     605           probe->oops_do(weak);
     606         }
     607       }
     608     }
     609   }
     610 }
     611
     612 uint ProtectionDomainCacheTable::bucket_size() {
     613   return sizeof(ProtectionDomainCacheEntry);
     614 }
     615
     616 #ifndef PRODUCT
     617 void ProtectionDomainCacheTable::print() {
     618   tty->print_cr("Protection domain cache table (table_size=%d, classes=%d)",
     619                 table_size(), number_of_entries());
     620   for (int index = 0; index < table_size(); index++) {
     621     for (ProtectionDomainCacheEntry* probe = bucket(index);
     622                                      probe != NULL;
     623                                      probe = probe->next()) {
     624       probe->print();
     625     }
     626   }
     627 }
     628
     629 void ProtectionDomainCacheEntry::print() {
     630   tty->print_cr("entry "PTR_FORMAT" value "PTR_FORMAT" strongly_reachable %d next "PTR_FORMAT,
     631                 this, (void*)literal(), _strongly_reachable, next());
     632 }
     633 #endif
     634
     635 void ProtectionDomainCacheTable::verify() {
     636   int element_count = 0;
     637   for (int index = 0; index < table_size(); index++) {
     638     for (ProtectionDomainCacheEntry* probe = bucket(index);
     639                                      probe != NULL;
     640                                      probe = probe->next()) {
     641       probe->verify();
     642       element_count++;
     643     }
     644   }
     645   guarantee(number_of_entries() == element_count,
     646             "Verify of protection domain cache table failed");
     647   debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
     648 }
     649
     650 void ProtectionDomainCacheEntry::verify() {
     651   guarantee(literal()->is_oop(), "must be an oop");
     652 }
     653
     654 void ProtectionDomainCacheTable::always_strong_oops_do(OopClosure* f) {
     655   // the caller marked the protection domain cache entries that we need to apply
     656   // the closure on. Only process them.
     657   for (int index = 0; index < table_size(); index++) {
     658     for (ProtectionDomainCacheEntry* probe = bucket(index);
     659                                      probe != NULL;
     660                                      probe = probe->next()) {
     661       if (probe->is_strongly_reachable()) {
     662         probe->reset_strongly_reachable();
     663         probe->oops_do(f);
     664       }
     665     }
     666   }
     667 }
     668
     669 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::get(oop protection_domain) {
     670   unsigned int hash = compute_hash(protection_domain);
     671   int index = hash_to_index(hash);
     672
     673   ProtectionDomainCacheEntry* entry = find_entry(index, protection_domain);
     674   if (entry == NULL) {
     675     entry = add_entry(index, hash, protection_domain);
     676   }
     677   return entry;
     678 }
     679
     680 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::find_entry(int index, oop protection_domain) {
     681   for (ProtectionDomainCacheEntry* e = bucket(index); e != NULL; e = e->next()) {
     682     if (e->protection_domain() == protection_domain) {
     683       return e;
     684     }
     685   }
     686
     687   return NULL;
     688 }
     689
     690 ProtectionDomainCacheEntry* ProtectionDomainCacheTable::add_entry(int index, unsigned int hash, oop protection_domain) {
     691   assert_locked_or_safepoint(SystemDictionary_lock);
     692   assert(index == index_for(protection_domain), "incorrect index?");
     693   assert(find_entry(index, protection_domain) == NULL, "no double entry");
     694
     695   ProtectionDomainCacheEntry* p = new_entry(hash, protection_domain);
     696   Hashtable<oop, mtClass>::add_entry(index, p);
     697   return p;
     698 }
     699
     700 void ProtectionDomainCacheTable::free(ProtectionDomainCacheEntry* to_delete) {
     701   unsigned int hash = compute_hash(to_delete->protection_domain());
     702   int index = hash_to_index(hash);
     703
     704   ProtectionDomainCacheEntry** p = bucket_addr(index);
     705   ProtectionDomainCacheEntry* entry = bucket(index);
     706   while (true) {
     707     assert(entry != NULL, "sanity");
     708
     709     if (entry == to_delete) {
     710       *p = entry->next();
     711       Hashtable<oop, mtClass>::free_entry(entry);
     712       break;
     713     } else {
     714       p = entry->next_addr();
     715       entry = *p;
     716     }
     717   }
     718 }
     719
     720 SymbolPropertyTable::SymbolPropertyTable(int table_size)
     721   : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry))
     722 {
     723 }
     724 SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t,
     725                                          int number_of_entries)
     726   : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries)
     727 {
     728 }
     729
     730
     731 SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash,
     732                                                      Symbol* sym,
     733                                                      intptr_t sym_mode) {
     734   assert(index == index_for(sym, sym_mode), "incorrect index?");
     735   for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     736     if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) {
     737       return p;
     738     }
     739   }
     740   return NULL;
     741 }
     742
     743
     744 SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash,
     745                                                     Symbol* sym, intptr_t sym_mode) {
     746   assert_locked_or_safepoint(SystemDictionary_lock);
     747   assert(index == index_for(sym, sym_mode), "incorrect index?");
     748   assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry");
     749
     750   SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode);
     751   Hashtable<Symbol*, mtSymbol>::add_entry(index, p);
     752   return p;
     753 }
     754
     755 void SymbolPropertyTable::oops_do(OopClosure* f) {
     756   for (int index = 0; index < table_size(); index++) {
     757     for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     758       if (p->method_type() != NULL) {
     759         f->do_oop(p->method_type_addr());
     760       }
     761     }
     762   }
     763 }
     764
     765 void SymbolPropertyTable::methods_do(void f(Method*)) {
     766   for (int index = 0; index < table_size(); index++) {
     767     for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
     768       Method* prop = p->method();
     769       if (prop != NULL) {
     770         f((Method*)prop);
     771       }
     772     }
     773   }
     774 }
     775
     776
     777 // ----------------------------------------------------------------------------
     778
     779 void Dictionary::print(bool details) {
     780   ResourceMark rm;
     781   HandleMark   hm;
     782
     783   dump_table(tty, "SystemDictionary");//gznote: here
     784   tty->cr();
     785
     786   if (details) {
     787     tty->print_cr("Java system dictionary (table_size=%d, classes=%d)",
     788                    table_size(), number_of_entries());
     789     tty->print_cr("^ indicates that initiating loader is different from "
     790                   "defining loader");
     791   }
     792
     793   for (int index = 0; index < table_size(); index++) {
     794     for (DictionaryEntry* probe = bucket(index);
     795                           probe != NULL;
     796                           probe = probe->next()) {
     797       if (Verbose) tty->print("%4d: ", index);
     798       Klass* e = probe->klass();
     799       ClassLoaderData* loader_data =  probe->loader_data();
     800       bool is_defining_class =
     801          (loader_data == InstanceKlass::cast(e)->class_loader_data());
     802       tty->print("%s%s", ((!details) || is_defining_class) ? " " : "^",
     803                    e->external_name());
     804
     805       if (details) {
     806         tty->print(", loader ");
     807         if (loader_data != NULL) {
     808           loader_data->print_value();
     809         } else {
     810           tty->print("NULL");
     811         }
     812       }
     813       tty->cr();
     814     }
     815   }
     816
     817   if (details) {
     818     tty->cr();
     819     _pd_cache_table->print();
     820   }
     821   tty->cr();
     822 }
     823
     824 void Dictionary::verify() {
     825   guarantee(number_of_entries() >= 0, "Verify of system dictionary failed");
     826
     827   MutexLocker mu(SystemDictionary_lock);
     828   int actual_count = 0;
     829
     830   int element_count = 0;
     831   for (int index = 0; index < table_size(); index++) {
     832     for (DictionaryEntry* probe = bucket(index);
     833                           probe != NULL;
     834                           probe = probe->next()) {
     835       Klass* e = probe->klass();
     836       ClassLoaderData* loader_data = probe->loader_data();
     837       guarantee(e->oop_is_instance(),
     838                               "Verify of system dictionary failed");
     839       // class loader must be present;  a null class loader is the
     840       // boostrap loader
     841       guarantee(loader_data != NULL || DumpSharedSpaces ||
     842                 loader_data->class_loader() == NULL ||
     843                 loader_data->class_loader()->is_instance(),
     844                 "checking type of class_loader");
     845       e->verify();
     846       probe->verify_protection_domain_set();
     847       actual_count++;
     848     }
     849   }
     850   guarantee(number_of_entries() == actual_count, "should be equal");

     851   debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
     852
     853   _pd_cache_table->verify();
     854 }
     855
    --- EOF ---