Mercurial > hg > graal-compiler
comparison src/share/vm/oops/instanceKlassKlass.cpp @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | ba764ed4b6f2 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a61af66fc99e |
---|---|
1 /* | |
2 * Copyright 1997-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 # include "incls/_precompiled.incl" | |
26 # include "incls/_instanceKlassKlass.cpp.incl" | |
27 | |
28 klassOop instanceKlassKlass::create_klass(TRAPS) { | |
29 instanceKlassKlass o; | |
30 KlassHandle h_this_klass(THREAD, Universe::klassKlassObj()); | |
31 KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL); | |
32 // Make sure size calculation is right | |
33 assert(k()->size() == align_object_size(header_size()), "wrong size for object"); | |
34 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror | |
35 return k(); | |
36 } | |
37 | |
38 int instanceKlassKlass::oop_size(oop obj) const { | |
39 assert(obj->is_klass(), "must be klass"); | |
40 return instanceKlass::cast(klassOop(obj))->object_size(); | |
41 } | |
42 | |
43 bool instanceKlassKlass::oop_is_parsable(oop obj) const { | |
44 assert(obj->is_klass(), "must be klass"); | |
45 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
46 return (!ik->null_vtbl()) && ik->object_is_parsable(); | |
47 } | |
48 | |
49 void instanceKlassKlass::iterate_c_heap_oops(instanceKlass* ik, | |
50 OopClosure* closure) { | |
51 if (ik->oop_map_cache() != NULL) { | |
52 ik->oop_map_cache()->oop_iterate(closure); | |
53 } | |
54 | |
55 if (ik->jni_ids() != NULL) { | |
56 ik->jni_ids()->oops_do(closure); | |
57 } | |
58 } | |
59 | |
60 void instanceKlassKlass::oop_follow_contents(oop obj) { | |
61 assert(obj->is_klass(),"must be a klass"); | |
62 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); | |
63 | |
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 | |
182 int instanceKlassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, | |
183 MemRegion mr) { | |
184 assert(obj->is_klass(),"must be a klass"); | |
185 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); | |
186 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
187 // Get size before changing pointers. | |
188 // Don't call size() or oop_size() since that is a virtual call. | |
189 int size = ik->object_size(); | |
190 | |
191 ik->iterate_static_fields(blk, mr); | |
192 ik->vtable()->oop_oop_iterate_m(blk, mr); | |
193 ik->itable()->oop_oop_iterate_m(blk, mr); | |
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); | |
234 adr = ik->adr_methods_parameter_annotations(); | |
235 if (mr.contains(adr)) blk->do_oop(adr); | |
236 adr = ik->adr_methods_default_annotations(); | |
237 if (mr.contains(adr)) blk->do_oop(adr); | |
238 | |
239 klassKlass::oop_oop_iterate_m(obj, blk, mr); | |
240 | |
241 if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk, mr); | |
242 return size; | |
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(); | |
341 for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { | |
342 PSParallelCompact::adjust_pointer(cur_oop); | |
343 } | |
344 | |
345 OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); | |
346 iterate_c_heap_oops(ik, closure); | |
347 | |
348 klassKlass::oop_update_pointers(cm, obj); | |
349 return ik->object_size(); | |
350 } | |
351 | |
352 int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, | |
353 HeapWord* beg_addr, | |
354 HeapWord* end_addr) { | |
355 assert(obj->is_klass(),"must be a klass"); | |
356 assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), | |
357 "must be instance klass"); | |
358 | |
359 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
360 ik->update_static_fields(beg_addr, end_addr); | |
361 ik->vtable()->oop_update_pointers(cm, beg_addr, end_addr); | |
362 ik->itable()->oop_update_pointers(cm, beg_addr, end_addr); | |
363 | |
364 oop* const beg_oop = MAX2((oop*)beg_addr, ik->oop_block_beg()); | |
365 oop* const end_oop = MIN2((oop*)end_addr, ik->oop_block_end()); | |
366 for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { | |
367 PSParallelCompact::adjust_pointer(cur_oop); | |
368 } | |
369 | |
370 // The oop_map_cache, jni_ids and jni_id_map are allocated from the C heap, | |
371 // and so don't lie within any 'Chunk' boundaries. Update them when the | |
372 // lowest addressed oop in the instanceKlass 'oop_block' is updated. | |
373 if (beg_oop == ik->oop_block_beg()) { | |
374 OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); | |
375 iterate_c_heap_oops(ik, closure); | |
376 } | |
377 | |
378 klassKlass::oop_update_pointers(cm, obj, beg_addr, end_addr); | |
379 return ik->object_size(); | |
380 } | |
381 #endif // SERIALGC | |
382 | |
383 klassOop instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len, int static_field_size, | |
384 int nonstatic_oop_map_size, ReferenceType rt, TRAPS) { | |
385 | |
386 int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size); | |
387 | |
388 // Allocation | |
389 KlassHandle h_this_klass(THREAD, as_klassOop()); | |
390 KlassHandle k; | |
391 if (rt == REF_NONE) { | |
392 // regular klass | |
393 instanceKlass o; | |
394 k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL); | |
395 } else { | |
396 // reference klass | |
397 instanceRefKlass o; | |
398 k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL); | |
399 } | |
400 { | |
401 No_Safepoint_Verifier no_safepoint; // until k becomes parsable | |
402 instanceKlass* ik = (instanceKlass*) k()->klass_part(); | |
403 assert(!k()->is_parsable(), "not expecting parsability yet."); | |
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); | |
444 ik->set_methods_annotations(NULL); | |
445 ik->set_methods_parameter_annotations(NULL); | |
446 ik->set_methods_default_annotations(NULL); | |
447 ik->set_enclosing_method_indices(0, 0); | |
448 ik->set_jvmti_cached_class_field_map(NULL); | |
449 ik->set_initial_method_idnum(0); | |
450 assert(k()->is_parsable(), "should be parsable here."); | |
451 | |
452 // initialize the non-header words to zero | |
453 intptr_t* p = (intptr_t*)k(); | |
454 for (int index = instanceKlass::header_size(); index < size; index++) { | |
455 p[index] = NULL_WORD; | |
456 } | |
457 | |
458 // To get verify to work - must be set to partial loaded before first GC point. | |
459 k()->set_partially_loaded(); | |
460 } | |
461 | |
462 // GC can happen here | |
463 java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror | |
464 return k(); | |
465 } | |
466 | |
467 | |
468 | |
469 #ifndef PRODUCT | |
470 | |
471 // Printing | |
472 | |
473 static const char* state_names[] = { | |
474 "unparseable_by_gc", "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error" | |
475 }; | |
476 | |
477 | |
478 void instanceKlassKlass::oop_print_on(oop obj, outputStream* st) { | |
479 assert(obj->is_klass(), "must be klass"); | |
480 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
481 klassKlass::oop_print_on(obj, st); | |
482 | |
483 st->print(" - instance size: %d", ik->size_helper()); st->cr(); | |
484 st->print(" - klass size: %d", ik->object_size()); st->cr(); | |
485 st->print(" - access: "); ik->access_flags().print_on(st); st->cr(); | |
486 st->print(" - state: "); st->print_cr(state_names[ik->_init_state]); | |
487 st->print(" - name: "); ik->name()->print_value_on(st); st->cr(); | |
488 st->print(" - super: "); ik->super()->print_value_on(st); st->cr(); | |
489 st->print(" - sub: "); | |
490 Klass* sub = ik->subklass(); | |
491 int n; | |
492 for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) { | |
493 if (n < MaxSubklassPrintSize) { | |
494 sub->as_klassOop()->print_value_on(st); | |
495 st->print(" "); | |
496 } | |
497 } | |
498 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize); | |
499 st->cr(); | |
500 | |
501 if (ik->is_interface()) { | |
502 st->print_cr(" - nof implementors: %d", ik->nof_implementors()); | |
503 int print_impl = 0; | |
504 for (int i = 0; i < instanceKlass::implementors_limit; i++) { | |
505 if (ik->implementor(i) != NULL) { | |
506 if (++print_impl == 1) | |
507 st->print_cr(" - implementor: "); | |
508 st->print(" "); | |
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 { | |
549 PreviousVersionWalker pvw(ik); | |
550 for (PreviousVersionInfo * pv_info = pvw.next_previous_version(); | |
551 pv_info != NULL; pv_info = pvw.next_previous_version()) { | |
552 pv_info->prev_constant_pool_handle()()->print_value_on(st); | |
553 } | |
554 st->cr(); | |
555 } // pvw is cleaned up | |
556 } // rm is cleaned up | |
557 | |
558 if (ik->generic_signature() != NULL) { | |
559 st->print(" - generic signature: "); | |
560 ik->generic_signature()->print_value_on(st); | |
561 } | |
562 st->print(" - inner classes: "); ik->inner_classes()->print_value_on(st); st->cr(); | |
563 st->print(" - java mirror: "); ik->java_mirror()->print_value_on(st); st->cr(); | |
564 st->print(" - vtable length %d (start addr: " INTPTR_FORMAT ")", ik->vtable_length(), ik->start_of_vtable()); st->cr(); | |
565 st->print(" - itable length %d (start addr: " INTPTR_FORMAT ")", ik->itable_length(), ik->start_of_itable()); st->cr(); | |
566 st->print_cr(" - static fields:"); | |
567 FieldPrinter print_static_field(st); | |
568 ik->do_local_static_fields(&print_static_field); | |
569 st->print_cr(" - non-static fields:"); | |
570 FieldPrinter print_nonstatic_field(st, obj); | |
571 ik->do_nonstatic_fields(&print_nonstatic_field); | |
572 | |
573 st->print(" - static oop maps: "); | |
574 if (ik->static_oop_field_size() > 0) { | |
575 int first_offset = ik->offset_of_static_fields(); | |
576 st->print("%d-%d", first_offset, first_offset + ik->static_oop_field_size() - 1); | |
577 } | |
578 st->cr(); | |
579 | |
580 st->print(" - non-static oop maps: "); | |
581 OopMapBlock* map = ik->start_of_nonstatic_oop_maps(); | |
582 OopMapBlock* end_map = map + ik->nonstatic_oop_map_size(); | |
583 while (map < end_map) { | |
584 st->print("%d-%d ", map->offset(), map->offset() + oopSize*(map->length() - 1)); | |
585 map++; | |
586 } | |
587 st->cr(); | |
588 } | |
589 | |
590 | |
591 void instanceKlassKlass::oop_print_value_on(oop obj, outputStream* st) { | |
592 assert(obj->is_klass(), "must be klass"); | |
593 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
594 ik->name()->print_value_on(st); | |
595 } | |
596 | |
597 #endif // PRODUCT | |
598 | |
599 const char* instanceKlassKlass::internal_name() const { | |
600 return "{instance class}"; | |
601 } | |
602 | |
603 // Verification | |
604 | |
605 | |
606 class VerifyFieldClosure: public OopClosure { | |
607 public: | |
608 void do_oop(oop* p) { | |
609 guarantee(Universe::heap()->is_in(p), "should be in heap"); | |
610 guarantee((*p)->is_oop_or_null(), "should be in heap"); | |
611 } | |
612 }; | |
613 | |
614 | |
615 void instanceKlassKlass::oop_verify_on(oop obj, outputStream* st) { | |
616 klassKlass::oop_verify_on(obj, st); | |
617 if (!obj->partially_loaded()) { | |
618 Thread *thread = Thread::current(); | |
619 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
620 | |
621 #ifndef PRODUCT | |
622 // Avoid redundant verifies | |
623 if (ik->_verify_count == Universe::verify_count()) return; | |
624 ik->_verify_count = Universe::verify_count(); | |
625 #endif | |
626 // Verify that klass is present in SystemDictionary | |
627 if (ik->is_loaded()) { | |
628 symbolHandle h_name (thread, ik->name()); | |
629 Handle h_loader (thread, ik->class_loader()); | |
630 Handle h_obj(thread, obj); | |
631 SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader); | |
632 } | |
633 | |
634 // Verify static fields | |
635 VerifyFieldClosure blk; | |
636 ik->iterate_static_fields(&blk); | |
637 | |
638 // Verify vtables | |
639 if (ik->is_linked()) { | |
640 ResourceMark rm(thread); | |
641 // $$$ This used to be done only for m/s collections. Doing it | |
642 // always seemed a valid generalization. (DLD -- 6/00) | |
643 ik->vtable()->verify(st); | |
644 } | |
645 | |
646 // Verify oop map cache | |
647 if (ik->oop_map_cache() != NULL) { | |
648 ik->oop_map_cache()->verify(); | |
649 } | |
650 | |
651 // Verify first subklass | |
652 if (ik->subklass_oop() != NULL) { | |
653 guarantee(ik->subklass_oop()->is_perm(), "should be in permspace"); | |
654 guarantee(ik->subklass_oop()->is_klass(), "should be klass"); | |
655 } | |
656 | |
657 // Verify siblings | |
658 klassOop super = ik->super(); | |
659 Klass* sib = ik->next_sibling(); | |
660 int sib_count = 0; | |
661 while (sib != NULL) { | |
662 if (sib == ik) { | |
663 fatal1("subclass cycle of length %d", sib_count); | |
664 } | |
665 if (sib_count >= 100000) { | |
666 fatal1("suspiciously long subclass list %d", sib_count); | |
667 } | |
668 guarantee(sib->as_klassOop()->is_klass(), "should be klass"); | |
669 guarantee(sib->as_klassOop()->is_perm(), "should be in permspace"); | |
670 guarantee(sib->super() == super, "siblings should have same superklass"); | |
671 sib = sib->next_sibling(); | |
672 } | |
673 | |
674 // Verify implementor fields | |
675 bool saw_null_impl = false; | |
676 for (int i = 0; i < instanceKlass::implementors_limit; i++) { | |
677 klassOop im = ik->implementor(i); | |
678 if (im == NULL) { saw_null_impl = true; continue; } | |
679 guarantee(!saw_null_impl, "non-nulls must preceded all nulls"); | |
680 guarantee(ik->is_interface(), "only interfaces should have implementor set"); | |
681 guarantee(i < ik->nof_implementors(), "should only have one implementor"); | |
682 guarantee(im->is_perm(), "should be in permspace"); | |
683 guarantee(im->is_klass(), "should be klass"); | |
684 guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces"); | |
685 } | |
686 | |
687 // Verify local interfaces | |
688 objArrayOop local_interfaces = ik->local_interfaces(); | |
689 guarantee(local_interfaces->is_perm(), "should be in permspace"); | |
690 guarantee(local_interfaces->is_objArray(), "should be obj array"); | |
691 int j; | |
692 for (j = 0; j < local_interfaces->length(); j++) { | |
693 oop e = local_interfaces->obj_at(j); | |
694 guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid local interface"); | |
695 } | |
696 | |
697 // Verify transitive interfaces | |
698 objArrayOop transitive_interfaces = ik->transitive_interfaces(); | |
699 guarantee(transitive_interfaces->is_perm(), "should be in permspace"); | |
700 guarantee(transitive_interfaces->is_objArray(), "should be obj array"); | |
701 for (j = 0; j < transitive_interfaces->length(); j++) { | |
702 oop e = transitive_interfaces->obj_at(j); | |
703 guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid transitive interface"); | |
704 } | |
705 | |
706 // Verify methods | |
707 objArrayOop methods = ik->methods(); | |
708 guarantee(methods->is_perm(), "should be in permspace"); | |
709 guarantee(methods->is_objArray(), "should be obj array"); | |
710 for (j = 0; j < methods->length(); j++) { | |
711 guarantee(methods->obj_at(j)->is_method(), "non-method in methods array"); | |
712 } | |
713 for (j = 0; j < methods->length() - 1; j++) { | |
714 methodOop m1 = methodOop(methods->obj_at(j)); | |
715 methodOop m2 = methodOop(methods->obj_at(j + 1)); | |
716 guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); | |
717 } | |
718 | |
719 // Verify method ordering | |
720 typeArrayOop method_ordering = ik->method_ordering(); | |
721 guarantee(method_ordering->is_perm(), "should be in permspace"); | |
722 guarantee(method_ordering->is_typeArray(), "should be type array"); | |
723 int length = method_ordering->length(); | |
724 if (JvmtiExport::can_maintain_original_method_order()) { | |
725 guarantee(length == methods->length(), "invalid method ordering length"); | |
726 jlong sum = 0; | |
727 for (j = 0; j < length; j++) { | |
728 int original_index = method_ordering->int_at(j); | |
729 guarantee(original_index >= 0 && original_index < length, "invalid method ordering index"); | |
730 sum += original_index; | |
731 } | |
732 // Verify sum of indices 0,1,...,length-1 | |
733 guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum"); | |
734 } else { | |
735 guarantee(length == 0, "invalid method ordering length"); | |
736 } | |
737 | |
738 // Verify JNI static field identifiers | |
739 if (ik->jni_ids() != NULL) { | |
740 ik->jni_ids()->verify(ik->as_klassOop()); | |
741 } | |
742 | |
743 // Verify other fields | |
744 if (ik->array_klasses() != NULL) { | |
745 guarantee(ik->array_klasses()->is_perm(), "should be in permspace"); | |
746 guarantee(ik->array_klasses()->is_klass(), "should be klass"); | |
747 } | |
748 guarantee(ik->fields()->is_perm(), "should be in permspace"); | |
749 guarantee(ik->fields()->is_typeArray(), "should be type array"); | |
750 guarantee(ik->constants()->is_perm(), "should be in permspace"); | |
751 guarantee(ik->constants()->is_constantPool(), "should be constant pool"); | |
752 guarantee(ik->inner_classes()->is_perm(), "should be in permspace"); | |
753 guarantee(ik->inner_classes()->is_typeArray(), "should be type array"); | |
754 if (ik->source_file_name() != NULL) { | |
755 guarantee(ik->source_file_name()->is_perm(), "should be in permspace"); | |
756 guarantee(ik->source_file_name()->is_symbol(), "should be symbol"); | |
757 } | |
758 if (ik->source_debug_extension() != NULL) { | |
759 guarantee(ik->source_debug_extension()->is_perm(), "should be in permspace"); | |
760 guarantee(ik->source_debug_extension()->is_symbol(), "should be symbol"); | |
761 } | |
762 if (ik->protection_domain() != NULL) { | |
763 guarantee(ik->protection_domain()->is_oop(), "should be oop"); | |
764 } | |
765 if (ik->signers() != NULL) { | |
766 guarantee(ik->signers()->is_objArray(), "should be obj array"); | |
767 } | |
768 if (ik->generic_signature() != NULL) { | |
769 guarantee(ik->generic_signature()->is_perm(), "should be in permspace"); | |
770 guarantee(ik->generic_signature()->is_symbol(), "should be symbol"); | |
771 } | |
772 if (ik->class_annotations() != NULL) { | |
773 guarantee(ik->class_annotations()->is_typeArray(), "should be type array"); | |
774 } | |
775 if (ik->fields_annotations() != NULL) { | |
776 guarantee(ik->fields_annotations()->is_objArray(), "should be obj array"); | |
777 } | |
778 if (ik->methods_annotations() != NULL) { | |
779 guarantee(ik->methods_annotations()->is_objArray(), "should be obj array"); | |
780 } | |
781 if (ik->methods_parameter_annotations() != NULL) { | |
782 guarantee(ik->methods_parameter_annotations()->is_objArray(), "should be obj array"); | |
783 } | |
784 if (ik->methods_default_annotations() != NULL) { | |
785 guarantee(ik->methods_default_annotations()->is_objArray(), "should be obj array"); | |
786 } | |
787 } | |
788 } | |
789 | |
790 | |
791 bool instanceKlassKlass::oop_partially_loaded(oop obj) const { | |
792 assert(obj->is_klass(), "object must be klass"); | |
793 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
794 assert(ik->oop_is_instance(), "object must be instanceKlass"); | |
795 return ik->transitive_interfaces() == (objArrayOop) obj; // Check whether transitive_interfaces points to self | |
796 } | |
797 | |
798 | |
799 // The transitive_interfaces is the last field set when loading an object. | |
800 void instanceKlassKlass::oop_set_partially_loaded(oop obj) { | |
801 assert(obj->is_klass(), "object must be klass"); | |
802 instanceKlass* ik = instanceKlass::cast(klassOop(obj)); | |
803 // Set the layout helper to a place-holder value, until fuller initialization. | |
804 // (This allows asserts in oop_is_instance to succeed.) | |
805 ik->set_layout_helper(Klass::instance_layout_helper(0, true)); | |
806 assert(ik->oop_is_instance(), "object must be instanceKlass"); | |
807 assert(ik->transitive_interfaces() == NULL, "just checking"); | |
808 ik->set_transitive_interfaces((objArrayOop) obj); // Temporarily set transitive_interfaces to point to self | |
809 } |