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