64 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
65 ik->follow_static_fields();
66 {
67 HandleMark hm;
68 ik->vtable()->oop_follow_contents();
69 ik->itable()->oop_follow_contents();
70 }
71
72 MarkSweep::mark_and_push(ik->adr_array_klasses());
73 MarkSweep::mark_and_push(ik->adr_methods());
74 MarkSweep::mark_and_push(ik->adr_method_ordering());
75 MarkSweep::mark_and_push(ik->adr_local_interfaces());
76 MarkSweep::mark_and_push(ik->adr_transitive_interfaces());
77 MarkSweep::mark_and_push(ik->adr_fields());
78 MarkSweep::mark_and_push(ik->adr_constants());
79 MarkSweep::mark_and_push(ik->adr_class_loader());
80 MarkSweep::mark_and_push(ik->adr_source_file_name());
81 MarkSweep::mark_and_push(ik->adr_source_debug_extension());
82 MarkSweep::mark_and_push(ik->adr_inner_classes());
83 MarkSweep::mark_and_push(ik->adr_protection_domain());
84 MarkSweep::mark_and_push(ik->adr_signers());
85 MarkSweep::mark_and_push(ik->adr_generic_signature());
86 MarkSweep::mark_and_push(ik->adr_class_annotations());
87 MarkSweep::mark_and_push(ik->adr_fields_annotations());
88 MarkSweep::mark_and_push(ik->adr_methods_annotations());
89 MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());
90 MarkSweep::mark_and_push(ik->adr_methods_default_annotations());
91
92 // We do not follow adr_implementors() here. It is followed later
93 // in instanceKlass::follow_weak_klass_links()
94
95 klassKlass::oop_follow_contents(obj);
96
97 iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);
98 }
99
100 #ifndef SERIALGC
101 void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm,
102 oop obj) {
103 assert(obj->is_klass(),"must be a klass");
104 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
105
106 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
107 ik->follow_static_fields(cm);
108 ik->vtable()->oop_follow_contents(cm);
109 ik->itable()->oop_follow_contents(cm);
110
111 PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
112 PSParallelCompact::mark_and_push(cm, ik->adr_methods());
113 PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering());
114 PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces());
115 PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces());
116 PSParallelCompact::mark_and_push(cm, ik->adr_fields());
117 PSParallelCompact::mark_and_push(cm, ik->adr_constants());
118 PSParallelCompact::mark_and_push(cm, ik->adr_class_loader());
119 PSParallelCompact::mark_and_push(cm, ik->adr_source_file_name());
120 PSParallelCompact::mark_and_push(cm, ik->adr_source_debug_extension());
121 PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes());
122 PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain());
123 PSParallelCompact::mark_and_push(cm, ik->adr_signers());
124 PSParallelCompact::mark_and_push(cm, ik->adr_generic_signature());
125 PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations());
126 PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations());
127 PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations());
128 PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations());
129 PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations());
130
131 // We do not follow adr_implementor() here. It is followed later
132 // in instanceKlass::follow_weak_klass_links()
133
134 klassKlass::oop_follow_contents(cm, obj);
135
136 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
137 iterate_c_heap_oops(ik, &mark_and_push_closure);
138 }
139 #endif // SERIALGC
140
141 int instanceKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
142 assert(obj->is_klass(),"must be a klass");
143 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
144 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
145 // Get size before changing pointers.
146 // Don't call size() or oop_size() since that is a virtual call.
147 int size = ik->object_size();
148
149 ik->iterate_static_fields(blk);
150 ik->vtable()->oop_oop_iterate(blk);
151 ik->itable()->oop_oop_iterate(blk);
152
153 blk->do_oop(ik->adr_array_klasses());
154 blk->do_oop(ik->adr_methods());
155 blk->do_oop(ik->adr_method_ordering());
156 blk->do_oop(ik->adr_local_interfaces());
157 blk->do_oop(ik->adr_transitive_interfaces());
158 blk->do_oop(ik->adr_fields());
159 blk->do_oop(ik->adr_constants());
160 blk->do_oop(ik->adr_class_loader());
161 blk->do_oop(ik->adr_protection_domain());
162 blk->do_oop(ik->adr_signers());
163 blk->do_oop(ik->adr_source_file_name());
164 blk->do_oop(ik->adr_source_debug_extension());
165 blk->do_oop(ik->adr_inner_classes());
166 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
167 blk->do_oop(&ik->adr_implementors()[i]);
168 }
169 blk->do_oop(ik->adr_generic_signature());
170 blk->do_oop(ik->adr_class_annotations());
171 blk->do_oop(ik->adr_fields_annotations());
172 blk->do_oop(ik->adr_methods_annotations());
173 blk->do_oop(ik->adr_methods_parameter_annotations());
174 blk->do_oop(ik->adr_methods_default_annotations());
175
176 klassKlass::oop_oop_iterate(obj, blk);
177
178 if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk);
179 return size;
180 }
181
194
195 oop* adr;
196 adr = ik->adr_array_klasses();
197 if (mr.contains(adr)) blk->do_oop(adr);
198 adr = ik->adr_methods();
199 if (mr.contains(adr)) blk->do_oop(adr);
200 adr = ik->adr_method_ordering();
201 if (mr.contains(adr)) blk->do_oop(adr);
202 adr = ik->adr_local_interfaces();
203 if (mr.contains(adr)) blk->do_oop(adr);
204 adr = ik->adr_transitive_interfaces();
205 if (mr.contains(adr)) blk->do_oop(adr);
206 adr = ik->adr_fields();
207 if (mr.contains(adr)) blk->do_oop(adr);
208 adr = ik->adr_constants();
209 if (mr.contains(adr)) blk->do_oop(adr);
210 adr = ik->adr_class_loader();
211 if (mr.contains(adr)) blk->do_oop(adr);
212 adr = ik->adr_protection_domain();
213 if (mr.contains(adr)) blk->do_oop(adr);
214 adr = ik->adr_signers();
215 if (mr.contains(adr)) blk->do_oop(adr);
216 adr = ik->adr_source_file_name();
217 if (mr.contains(adr)) blk->do_oop(adr);
218 adr = ik->adr_source_debug_extension();
219 if (mr.contains(adr)) blk->do_oop(adr);
220 adr = ik->adr_inner_classes();
221 if (mr.contains(adr)) blk->do_oop(adr);
222 adr = ik->adr_implementors();
223 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
224 if (mr.contains(&adr[i])) blk->do_oop(&adr[i]);
225 }
226 adr = ik->adr_generic_signature();
227 if (mr.contains(adr)) blk->do_oop(adr);
228 adr = ik->adr_class_annotations();
229 if (mr.contains(adr)) blk->do_oop(adr);
230 adr = ik->adr_fields_annotations();
231 if (mr.contains(adr)) blk->do_oop(adr);
232 adr = ik->adr_methods_annotations();
233 if (mr.contains(adr)) blk->do_oop(adr);
243 }
244
245 int instanceKlassKlass::oop_adjust_pointers(oop obj) {
246 assert(obj->is_klass(),"must be a klass");
247 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
248
249 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
250 ik->adjust_static_fields();
251 ik->vtable()->oop_adjust_pointers();
252 ik->itable()->oop_adjust_pointers();
253
254 MarkSweep::adjust_pointer(ik->adr_array_klasses());
255 MarkSweep::adjust_pointer(ik->adr_methods());
256 MarkSweep::adjust_pointer(ik->adr_method_ordering());
257 MarkSweep::adjust_pointer(ik->adr_local_interfaces());
258 MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());
259 MarkSweep::adjust_pointer(ik->adr_fields());
260 MarkSweep::adjust_pointer(ik->adr_constants());
261 MarkSweep::adjust_pointer(ik->adr_class_loader());
262 MarkSweep::adjust_pointer(ik->adr_protection_domain());
263 MarkSweep::adjust_pointer(ik->adr_signers());
264 MarkSweep::adjust_pointer(ik->adr_source_file_name());
265 MarkSweep::adjust_pointer(ik->adr_source_debug_extension());
266 MarkSweep::adjust_pointer(ik->adr_inner_classes());
267 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
268 MarkSweep::adjust_pointer(&ik->adr_implementors()[i]);
269 }
270 MarkSweep::adjust_pointer(ik->adr_generic_signature());
271 MarkSweep::adjust_pointer(ik->adr_class_annotations());
272 MarkSweep::adjust_pointer(ik->adr_fields_annotations());
273 MarkSweep::adjust_pointer(ik->adr_methods_annotations());
274 MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
275 MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());
276
277 iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);
278
279 return klassKlass::oop_adjust_pointers(obj);
280 }
281
282 #ifndef SERIALGC
283 void instanceKlassKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
284 assert(!pm->depth_first(), "invariant");
285 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
286 ik->copy_static_fields(pm);
287
288 oop* loader_addr = ik->adr_class_loader();
289 if (PSScavenge::should_scavenge(loader_addr)) {
290 pm->claim_or_forward_breadth(loader_addr);
291 }
292
293 oop* pd_addr = ik->adr_protection_domain();
294 if (PSScavenge::should_scavenge(pd_addr)) {
295 pm->claim_or_forward_breadth(pd_addr);
296 }
297
298 oop* sg_addr = ik->adr_signers();
299 if (PSScavenge::should_scavenge(sg_addr)) {
300 pm->claim_or_forward_breadth(sg_addr);
301 }
302
303 klassKlass::oop_copy_contents(pm, obj);
304 }
305
306 void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
307 assert(pm->depth_first(), "invariant");
308 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
309 ik->push_static_fields(pm);
310
311 oop* loader_addr = ik->adr_class_loader();
312 if (PSScavenge::should_scavenge(loader_addr)) {
313 pm->claim_or_forward_depth(loader_addr);
314 }
315
316 oop* pd_addr = ik->adr_protection_domain();
317 if (PSScavenge::should_scavenge(pd_addr)) {
318 pm->claim_or_forward_depth(pd_addr);
319 }
320
321 oop* sg_addr = ik->adr_signers();
322 if (PSScavenge::should_scavenge(sg_addr)) {
323 pm->claim_or_forward_depth(sg_addr);
324 }
325
326 klassKlass::oop_copy_contents(pm, obj);
327 }
328
329 int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
330 assert(obj->is_klass(),"must be a klass");
331 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
332 "must be instance klass");
333
334 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
335 ik->update_static_fields();
336 ik->vtable()->oop_update_pointers(cm);
337 ik->itable()->oop_update_pointers(cm);
338
339 oop* const beg_oop = ik->oop_block_beg();
340 oop* const end_oop = ik->oop_block_end();
404
405 // The sizes of these these three variables are used for determining the
406 // size of the instanceKlassOop. It is critical that these are set to the right
407 // sizes before the first GC, i.e., when we allocate the mirror.
408 ik->set_vtable_length(vtable_len);
409 ik->set_itable_length(itable_len);
410 ik->set_static_field_size(static_field_size);
411 ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);
412 assert(k()->size() == size, "wrong size for object");
413
414 ik->set_array_klasses(NULL);
415 ik->set_methods(NULL);
416 ik->set_method_ordering(NULL);
417 ik->set_local_interfaces(NULL);
418 ik->set_transitive_interfaces(NULL);
419 ik->init_implementor();
420 ik->set_fields(NULL);
421 ik->set_constants(NULL);
422 ik->set_class_loader(NULL);
423 ik->set_protection_domain(NULL);
424 ik->set_signers(NULL);
425 ik->set_source_file_name(NULL);
426 ik->set_source_debug_extension(NULL);
427 ik->set_inner_classes(NULL);
428 ik->set_static_oop_field_size(0);
429 ik->set_nonstatic_field_size(0);
430 ik->set_is_marked_dependent(false);
431 ik->set_init_state(instanceKlass::allocated);
432 ik->set_init_thread(NULL);
433 ik->set_reference_type(rt);
434 ik->set_oop_map_cache(NULL);
435 ik->set_jni_ids(NULL);
436 ik->set_osr_nmethods_head(NULL);
437 ik->set_breakpoints(NULL);
438 ik->init_previous_versions();
439 ik->set_generic_signature(NULL);
440 ik->release_set_methods_jmethod_ids(NULL);
441 ik->release_set_methods_cached_itable_indices(NULL);
442 ik->set_class_annotations(NULL);
443 ik->set_fields_annotations(NULL);
509 ik->implementor(i)->print_value_on(st);
510 }
511 }
512 if (print_impl > 0) st->cr();
513 }
514
515 st->print(" - arrays: "); ik->array_klasses()->print_value_on(st); st->cr();
516 st->print(" - methods: "); ik->methods()->print_value_on(st); st->cr();
517 if (Verbose) {
518 objArrayOop methods = ik->methods();
519 for(int i = 0; i < methods->length(); i++) {
520 tty->print("%d : ", i); methods->obj_at(i)->print_value(); tty->cr();
521 }
522 }
523 st->print(" - method ordering: "); ik->method_ordering()->print_value_on(st); st->cr();
524 st->print(" - local interfaces: "); ik->local_interfaces()->print_value_on(st); st->cr();
525 st->print(" - trans. interfaces: "); ik->transitive_interfaces()->print_value_on(st); st->cr();
526 st->print(" - constants: "); ik->constants()->print_value_on(st); st->cr();
527 st->print(" - class loader: "); ik->class_loader()->print_value_on(st); st->cr();
528 st->print(" - protection domain: "); ik->protection_domain()->print_value_on(st); st->cr();
529 st->print(" - signers: "); ik->signers()->print_value_on(st); st->cr();
530 if (ik->source_file_name() != NULL) {
531 st->print(" - source file: ");
532 ik->source_file_name()->print_value_on(st);
533 st->cr();
534 }
535 if (ik->source_debug_extension() != NULL) {
536 st->print(" - source debug extension: ");
537 ik->source_debug_extension()->print_value_on(st);
538 st->cr();
539 }
540
541 st->print_cr(" - previous version: ");
542 {
543 ResourceMark rm;
544 // PreviousVersionInfo objects returned via PreviousVersionWalker
545 // contain a GrowableArray of handles. We have to clean up the
546 // GrowableArray _after_ the PreviousVersionWalker destructor
547 // has destroyed the handles.
548 {
609 oop obj = oopDesc::load_decode_heap_oop(p);
610 guarantee(obj->is_oop_or_null(), "should be in heap");
611 }
612 public:
613 virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); }
614 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
615 };
616
617 void instanceKlassKlass::oop_verify_on(oop obj, outputStream* st) {
618 klassKlass::oop_verify_on(obj, st);
619 if (!obj->partially_loaded()) {
620 Thread *thread = Thread::current();
621 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
622
623 #ifndef PRODUCT
624 // Avoid redundant verifies
625 if (ik->_verify_count == Universe::verify_count()) return;
626 ik->_verify_count = Universe::verify_count();
627 #endif
628 // Verify that klass is present in SystemDictionary
629 if (ik->is_loaded()) {
630 symbolHandle h_name (thread, ik->name());
631 Handle h_loader (thread, ik->class_loader());
632 Handle h_obj(thread, obj);
633 SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
634 }
635
636 // Verify static fields
637 VerifyFieldClosure blk;
638 ik->iterate_static_fields(&blk);
639
640 // Verify vtables
641 if (ik->is_linked()) {
642 ResourceMark rm(thread);
643 // $$$ This used to be done only for m/s collections. Doing it
644 // always seemed a valid generalization. (DLD -- 6/00)
645 ik->vtable()->verify(st);
646 }
647
648 // Verify oop map cache
649 if (ik->oop_map_cache() != NULL) {
747 guarantee(ik->array_klasses()->is_perm(), "should be in permspace");
748 guarantee(ik->array_klasses()->is_klass(), "should be klass");
749 }
750 guarantee(ik->fields()->is_perm(), "should be in permspace");
751 guarantee(ik->fields()->is_typeArray(), "should be type array");
752 guarantee(ik->constants()->is_perm(), "should be in permspace");
753 guarantee(ik->constants()->is_constantPool(), "should be constant pool");
754 guarantee(ik->inner_classes()->is_perm(), "should be in permspace");
755 guarantee(ik->inner_classes()->is_typeArray(), "should be type array");
756 if (ik->source_file_name() != NULL) {
757 guarantee(ik->source_file_name()->is_perm(), "should be in permspace");
758 guarantee(ik->source_file_name()->is_symbol(), "should be symbol");
759 }
760 if (ik->source_debug_extension() != NULL) {
761 guarantee(ik->source_debug_extension()->is_perm(), "should be in permspace");
762 guarantee(ik->source_debug_extension()->is_symbol(), "should be symbol");
763 }
764 if (ik->protection_domain() != NULL) {
765 guarantee(ik->protection_domain()->is_oop(), "should be oop");
766 }
767 if (ik->signers() != NULL) {
768 guarantee(ik->signers()->is_objArray(), "should be obj array");
769 }
770 if (ik->generic_signature() != NULL) {
771 guarantee(ik->generic_signature()->is_perm(), "should be in permspace");
772 guarantee(ik->generic_signature()->is_symbol(), "should be symbol");
773 }
774 if (ik->class_annotations() != NULL) {
775 guarantee(ik->class_annotations()->is_typeArray(), "should be type array");
776 }
777 if (ik->fields_annotations() != NULL) {
778 guarantee(ik->fields_annotations()->is_objArray(), "should be obj array");
779 }
780 if (ik->methods_annotations() != NULL) {
781 guarantee(ik->methods_annotations()->is_objArray(), "should be obj array");
782 }
783 if (ik->methods_parameter_annotations() != NULL) {
784 guarantee(ik->methods_parameter_annotations()->is_objArray(), "should be obj array");
785 }
786 if (ik->methods_default_annotations() != NULL) {
|
64 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
65 ik->follow_static_fields();
66 {
67 HandleMark hm;
68 ik->vtable()->oop_follow_contents();
69 ik->itable()->oop_follow_contents();
70 }
71
72 MarkSweep::mark_and_push(ik->adr_array_klasses());
73 MarkSweep::mark_and_push(ik->adr_methods());
74 MarkSweep::mark_and_push(ik->adr_method_ordering());
75 MarkSweep::mark_and_push(ik->adr_local_interfaces());
76 MarkSweep::mark_and_push(ik->adr_transitive_interfaces());
77 MarkSweep::mark_and_push(ik->adr_fields());
78 MarkSweep::mark_and_push(ik->adr_constants());
79 MarkSweep::mark_and_push(ik->adr_class_loader());
80 MarkSweep::mark_and_push(ik->adr_source_file_name());
81 MarkSweep::mark_and_push(ik->adr_source_debug_extension());
82 MarkSweep::mark_and_push(ik->adr_inner_classes());
83 MarkSweep::mark_and_push(ik->adr_protection_domain());
84 MarkSweep::mark_and_push(ik->adr_host_klass());
85 MarkSweep::mark_and_push(ik->adr_signers());
86 MarkSweep::mark_and_push(ik->adr_generic_signature());
87 MarkSweep::mark_and_push(ik->adr_class_annotations());
88 MarkSweep::mark_and_push(ik->adr_fields_annotations());
89 MarkSweep::mark_and_push(ik->adr_methods_annotations());
90 MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations());
91 MarkSweep::mark_and_push(ik->adr_methods_default_annotations());
92
93 // We do not follow adr_implementors() here. It is followed later
94 // in instanceKlass::follow_weak_klass_links()
95
96 klassKlass::oop_follow_contents(obj);
97
98 iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure);
99 }
100
101 #ifndef SERIALGC
102 void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm,
103 oop obj) {
104 assert(obj->is_klass(),"must be a klass");
105 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
106
107 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
108 ik->follow_static_fields(cm);
109 ik->vtable()->oop_follow_contents(cm);
110 ik->itable()->oop_follow_contents(cm);
111
112 PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses());
113 PSParallelCompact::mark_and_push(cm, ik->adr_methods());
114 PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering());
115 PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces());
116 PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces());
117 PSParallelCompact::mark_and_push(cm, ik->adr_fields());
118 PSParallelCompact::mark_and_push(cm, ik->adr_constants());
119 PSParallelCompact::mark_and_push(cm, ik->adr_class_loader());
120 PSParallelCompact::mark_and_push(cm, ik->adr_source_file_name());
121 PSParallelCompact::mark_and_push(cm, ik->adr_source_debug_extension());
122 PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes());
123 PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain());
124 PSParallelCompact::mark_and_push(cm, ik->adr_host_klass());
125 PSParallelCompact::mark_and_push(cm, ik->adr_signers());
126 PSParallelCompact::mark_and_push(cm, ik->adr_generic_signature());
127 PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations());
128 PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations());
129 PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations());
130 PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations());
131 PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations());
132
133 // We do not follow adr_implementor() here. It is followed later
134 // in instanceKlass::follow_weak_klass_links()
135
136 klassKlass::oop_follow_contents(cm, obj);
137
138 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
139 iterate_c_heap_oops(ik, &mark_and_push_closure);
140 }
141 #endif // SERIALGC
142
143 int instanceKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) {
144 assert(obj->is_klass(),"must be a klass");
145 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
146 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
147 // Get size before changing pointers.
148 // Don't call size() or oop_size() since that is a virtual call.
149 int size = ik->object_size();
150
151 ik->iterate_static_fields(blk);
152 ik->vtable()->oop_oop_iterate(blk);
153 ik->itable()->oop_oop_iterate(blk);
154
155 blk->do_oop(ik->adr_array_klasses());
156 blk->do_oop(ik->adr_methods());
157 blk->do_oop(ik->adr_method_ordering());
158 blk->do_oop(ik->adr_local_interfaces());
159 blk->do_oop(ik->adr_transitive_interfaces());
160 blk->do_oop(ik->adr_fields());
161 blk->do_oop(ik->adr_constants());
162 blk->do_oop(ik->adr_class_loader());
163 blk->do_oop(ik->adr_protection_domain());
164 blk->do_oop(ik->adr_host_klass());
165 blk->do_oop(ik->adr_signers());
166 blk->do_oop(ik->adr_source_file_name());
167 blk->do_oop(ik->adr_source_debug_extension());
168 blk->do_oop(ik->adr_inner_classes());
169 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
170 blk->do_oop(&ik->adr_implementors()[i]);
171 }
172 blk->do_oop(ik->adr_generic_signature());
173 blk->do_oop(ik->adr_class_annotations());
174 blk->do_oop(ik->adr_fields_annotations());
175 blk->do_oop(ik->adr_methods_annotations());
176 blk->do_oop(ik->adr_methods_parameter_annotations());
177 blk->do_oop(ik->adr_methods_default_annotations());
178
179 klassKlass::oop_oop_iterate(obj, blk);
180
181 if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk);
182 return size;
183 }
184
197
198 oop* adr;
199 adr = ik->adr_array_klasses();
200 if (mr.contains(adr)) blk->do_oop(adr);
201 adr = ik->adr_methods();
202 if (mr.contains(adr)) blk->do_oop(adr);
203 adr = ik->adr_method_ordering();
204 if (mr.contains(adr)) blk->do_oop(adr);
205 adr = ik->adr_local_interfaces();
206 if (mr.contains(adr)) blk->do_oop(adr);
207 adr = ik->adr_transitive_interfaces();
208 if (mr.contains(adr)) blk->do_oop(adr);
209 adr = ik->adr_fields();
210 if (mr.contains(adr)) blk->do_oop(adr);
211 adr = ik->adr_constants();
212 if (mr.contains(adr)) blk->do_oop(adr);
213 adr = ik->adr_class_loader();
214 if (mr.contains(adr)) blk->do_oop(adr);
215 adr = ik->adr_protection_domain();
216 if (mr.contains(adr)) blk->do_oop(adr);
217 adr = ik->adr_host_klass();
218 if (mr.contains(adr)) blk->do_oop(adr);
219 adr = ik->adr_signers();
220 if (mr.contains(adr)) blk->do_oop(adr);
221 adr = ik->adr_source_file_name();
222 if (mr.contains(adr)) blk->do_oop(adr);
223 adr = ik->adr_source_debug_extension();
224 if (mr.contains(adr)) blk->do_oop(adr);
225 adr = ik->adr_inner_classes();
226 if (mr.contains(adr)) blk->do_oop(adr);
227 adr = ik->adr_implementors();
228 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
229 if (mr.contains(&adr[i])) blk->do_oop(&adr[i]);
230 }
231 adr = ik->adr_generic_signature();
232 if (mr.contains(adr)) blk->do_oop(adr);
233 adr = ik->adr_class_annotations();
234 if (mr.contains(adr)) blk->do_oop(adr);
235 adr = ik->adr_fields_annotations();
236 if (mr.contains(adr)) blk->do_oop(adr);
237 adr = ik->adr_methods_annotations();
238 if (mr.contains(adr)) blk->do_oop(adr);
248 }
249
250 int instanceKlassKlass::oop_adjust_pointers(oop obj) {
251 assert(obj->is_klass(),"must be a klass");
252 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass");
253
254 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
255 ik->adjust_static_fields();
256 ik->vtable()->oop_adjust_pointers();
257 ik->itable()->oop_adjust_pointers();
258
259 MarkSweep::adjust_pointer(ik->adr_array_klasses());
260 MarkSweep::adjust_pointer(ik->adr_methods());
261 MarkSweep::adjust_pointer(ik->adr_method_ordering());
262 MarkSweep::adjust_pointer(ik->adr_local_interfaces());
263 MarkSweep::adjust_pointer(ik->adr_transitive_interfaces());
264 MarkSweep::adjust_pointer(ik->adr_fields());
265 MarkSweep::adjust_pointer(ik->adr_constants());
266 MarkSweep::adjust_pointer(ik->adr_class_loader());
267 MarkSweep::adjust_pointer(ik->adr_protection_domain());
268 MarkSweep::adjust_pointer(ik->adr_host_klass());
269 MarkSweep::adjust_pointer(ik->adr_signers());
270 MarkSweep::adjust_pointer(ik->adr_source_file_name());
271 MarkSweep::adjust_pointer(ik->adr_source_debug_extension());
272 MarkSweep::adjust_pointer(ik->adr_inner_classes());
273 for (int i = 0; i < instanceKlass::implementors_limit; i++) {
274 MarkSweep::adjust_pointer(&ik->adr_implementors()[i]);
275 }
276 MarkSweep::adjust_pointer(ik->adr_generic_signature());
277 MarkSweep::adjust_pointer(ik->adr_class_annotations());
278 MarkSweep::adjust_pointer(ik->adr_fields_annotations());
279 MarkSweep::adjust_pointer(ik->adr_methods_annotations());
280 MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations());
281 MarkSweep::adjust_pointer(ik->adr_methods_default_annotations());
282
283 iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure);
284
285 return klassKlass::oop_adjust_pointers(obj);
286 }
287
288 #ifndef SERIALGC
289 void instanceKlassKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
290 assert(!pm->depth_first(), "invariant");
291 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
292 ik->copy_static_fields(pm);
293
294 oop* loader_addr = ik->adr_class_loader();
295 if (PSScavenge::should_scavenge(loader_addr)) {
296 pm->claim_or_forward_breadth(loader_addr);
297 }
298
299 oop* pd_addr = ik->adr_protection_domain();
300 if (PSScavenge::should_scavenge(pd_addr)) {
301 pm->claim_or_forward_breadth(pd_addr);
302 }
303
304 oop* hk_addr = ik->adr_host_klass();
305 if (PSScavenge::should_scavenge(hk_addr)) {
306 pm->claim_or_forward_breadth(hk_addr);
307 }
308
309 oop* sg_addr = ik->adr_signers();
310 if (PSScavenge::should_scavenge(sg_addr)) {
311 pm->claim_or_forward_breadth(sg_addr);
312 }
313
314 klassKlass::oop_copy_contents(pm, obj);
315 }
316
317 void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
318 assert(pm->depth_first(), "invariant");
319 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
320 ik->push_static_fields(pm);
321
322 oop* loader_addr = ik->adr_class_loader();
323 if (PSScavenge::should_scavenge(loader_addr)) {
324 pm->claim_or_forward_depth(loader_addr);
325 }
326
327 oop* pd_addr = ik->adr_protection_domain();
328 if (PSScavenge::should_scavenge(pd_addr)) {
329 pm->claim_or_forward_depth(pd_addr);
330 }
331
332 oop* hk_addr = ik->adr_host_klass();
333 if (PSScavenge::should_scavenge(hk_addr)) {
334 pm->claim_or_forward_depth(hk_addr);
335 }
336
337 oop* sg_addr = ik->adr_signers();
338 if (PSScavenge::should_scavenge(sg_addr)) {
339 pm->claim_or_forward_depth(sg_addr);
340 }
341
342 klassKlass::oop_copy_contents(pm, obj);
343 }
344
345 int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
346 assert(obj->is_klass(),"must be a klass");
347 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(),
348 "must be instance klass");
349
350 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
351 ik->update_static_fields();
352 ik->vtable()->oop_update_pointers(cm);
353 ik->itable()->oop_update_pointers(cm);
354
355 oop* const beg_oop = ik->oop_block_beg();
356 oop* const end_oop = ik->oop_block_end();
420
421 // The sizes of these these three variables are used for determining the
422 // size of the instanceKlassOop. It is critical that these are set to the right
423 // sizes before the first GC, i.e., when we allocate the mirror.
424 ik->set_vtable_length(vtable_len);
425 ik->set_itable_length(itable_len);
426 ik->set_static_field_size(static_field_size);
427 ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size);
428 assert(k()->size() == size, "wrong size for object");
429
430 ik->set_array_klasses(NULL);
431 ik->set_methods(NULL);
432 ik->set_method_ordering(NULL);
433 ik->set_local_interfaces(NULL);
434 ik->set_transitive_interfaces(NULL);
435 ik->init_implementor();
436 ik->set_fields(NULL);
437 ik->set_constants(NULL);
438 ik->set_class_loader(NULL);
439 ik->set_protection_domain(NULL);
440 ik->set_host_klass(NULL);
441 ik->set_signers(NULL);
442 ik->set_source_file_name(NULL);
443 ik->set_source_debug_extension(NULL);
444 ik->set_inner_classes(NULL);
445 ik->set_static_oop_field_size(0);
446 ik->set_nonstatic_field_size(0);
447 ik->set_is_marked_dependent(false);
448 ik->set_init_state(instanceKlass::allocated);
449 ik->set_init_thread(NULL);
450 ik->set_reference_type(rt);
451 ik->set_oop_map_cache(NULL);
452 ik->set_jni_ids(NULL);
453 ik->set_osr_nmethods_head(NULL);
454 ik->set_breakpoints(NULL);
455 ik->init_previous_versions();
456 ik->set_generic_signature(NULL);
457 ik->release_set_methods_jmethod_ids(NULL);
458 ik->release_set_methods_cached_itable_indices(NULL);
459 ik->set_class_annotations(NULL);
460 ik->set_fields_annotations(NULL);
526 ik->implementor(i)->print_value_on(st);
527 }
528 }
529 if (print_impl > 0) st->cr();
530 }
531
532 st->print(" - arrays: "); ik->array_klasses()->print_value_on(st); st->cr();
533 st->print(" - methods: "); ik->methods()->print_value_on(st); st->cr();
534 if (Verbose) {
535 objArrayOop methods = ik->methods();
536 for(int i = 0; i < methods->length(); i++) {
537 tty->print("%d : ", i); methods->obj_at(i)->print_value(); tty->cr();
538 }
539 }
540 st->print(" - method ordering: "); ik->method_ordering()->print_value_on(st); st->cr();
541 st->print(" - local interfaces: "); ik->local_interfaces()->print_value_on(st); st->cr();
542 st->print(" - trans. interfaces: "); ik->transitive_interfaces()->print_value_on(st); st->cr();
543 st->print(" - constants: "); ik->constants()->print_value_on(st); st->cr();
544 st->print(" - class loader: "); ik->class_loader()->print_value_on(st); st->cr();
545 st->print(" - protection domain: "); ik->protection_domain()->print_value_on(st); st->cr();
546 st->print(" - host class: "); ik->host_klass()->print_value_on(st); st->cr();
547 st->print(" - signers: "); ik->signers()->print_value_on(st); st->cr();
548 if (ik->source_file_name() != NULL) {
549 st->print(" - source file: ");
550 ik->source_file_name()->print_value_on(st);
551 st->cr();
552 }
553 if (ik->source_debug_extension() != NULL) {
554 st->print(" - source debug extension: ");
555 ik->source_debug_extension()->print_value_on(st);
556 st->cr();
557 }
558
559 st->print_cr(" - previous version: ");
560 {
561 ResourceMark rm;
562 // PreviousVersionInfo objects returned via PreviousVersionWalker
563 // contain a GrowableArray of handles. We have to clean up the
564 // GrowableArray _after_ the PreviousVersionWalker destructor
565 // has destroyed the handles.
566 {
627 oop obj = oopDesc::load_decode_heap_oop(p);
628 guarantee(obj->is_oop_or_null(), "should be in heap");
629 }
630 public:
631 virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); }
632 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
633 };
634
635 void instanceKlassKlass::oop_verify_on(oop obj, outputStream* st) {
636 klassKlass::oop_verify_on(obj, st);
637 if (!obj->partially_loaded()) {
638 Thread *thread = Thread::current();
639 instanceKlass* ik = instanceKlass::cast(klassOop(obj));
640
641 #ifndef PRODUCT
642 // Avoid redundant verifies
643 if (ik->_verify_count == Universe::verify_count()) return;
644 ik->_verify_count = Universe::verify_count();
645 #endif
646 // Verify that klass is present in SystemDictionary
647 if (ik->is_loaded() && !ik->is_anonymous()) {
648 symbolHandle h_name (thread, ik->name());
649 Handle h_loader (thread, ik->class_loader());
650 Handle h_obj(thread, obj);
651 SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader);
652 }
653
654 // Verify static fields
655 VerifyFieldClosure blk;
656 ik->iterate_static_fields(&blk);
657
658 // Verify vtables
659 if (ik->is_linked()) {
660 ResourceMark rm(thread);
661 // $$$ This used to be done only for m/s collections. Doing it
662 // always seemed a valid generalization. (DLD -- 6/00)
663 ik->vtable()->verify(st);
664 }
665
666 // Verify oop map cache
667 if (ik->oop_map_cache() != NULL) {
765 guarantee(ik->array_klasses()->is_perm(), "should be in permspace");
766 guarantee(ik->array_klasses()->is_klass(), "should be klass");
767 }
768 guarantee(ik->fields()->is_perm(), "should be in permspace");
769 guarantee(ik->fields()->is_typeArray(), "should be type array");
770 guarantee(ik->constants()->is_perm(), "should be in permspace");
771 guarantee(ik->constants()->is_constantPool(), "should be constant pool");
772 guarantee(ik->inner_classes()->is_perm(), "should be in permspace");
773 guarantee(ik->inner_classes()->is_typeArray(), "should be type array");
774 if (ik->source_file_name() != NULL) {
775 guarantee(ik->source_file_name()->is_perm(), "should be in permspace");
776 guarantee(ik->source_file_name()->is_symbol(), "should be symbol");
777 }
778 if (ik->source_debug_extension() != NULL) {
779 guarantee(ik->source_debug_extension()->is_perm(), "should be in permspace");
780 guarantee(ik->source_debug_extension()->is_symbol(), "should be symbol");
781 }
782 if (ik->protection_domain() != NULL) {
783 guarantee(ik->protection_domain()->is_oop(), "should be oop");
784 }
785 if (ik->host_klass() != NULL) {
786 guarantee(ik->host_klass()->is_oop(), "should be oop");
787 }
788 if (ik->signers() != NULL) {
789 guarantee(ik->signers()->is_objArray(), "should be obj array");
790 }
791 if (ik->generic_signature() != NULL) {
792 guarantee(ik->generic_signature()->is_perm(), "should be in permspace");
793 guarantee(ik->generic_signature()->is_symbol(), "should be symbol");
794 }
795 if (ik->class_annotations() != NULL) {
796 guarantee(ik->class_annotations()->is_typeArray(), "should be type array");
797 }
798 if (ik->fields_annotations() != NULL) {
799 guarantee(ik->fields_annotations()->is_objArray(), "should be obj array");
800 }
801 if (ik->methods_annotations() != NULL) {
802 guarantee(ik->methods_annotations()->is_objArray(), "should be obj array");
803 }
804 if (ik->methods_parameter_annotations() != NULL) {
805 guarantee(ik->methods_parameter_annotations()->is_objArray(), "should be obj array");
806 }
807 if (ik->methods_default_annotations() != NULL) {
|