Wed, 06 Jan 2010 22:21:39 -0800
Merge
duke@435 | 1 | /* |
jrose@1100 | 2 | * Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
duke@435 | 19 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
duke@435 | 20 | * CA 95054 USA or visit www.sun.com if you need additional information or |
duke@435 | 21 | * have any questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
duke@435 | 25 | # include "incls/_precompiled.incl" |
duke@435 | 26 | # include "incls/_instanceKlassKlass.cpp.incl" |
duke@435 | 27 | |
duke@435 | 28 | klassOop instanceKlassKlass::create_klass(TRAPS) { |
duke@435 | 29 | instanceKlassKlass o; |
duke@435 | 30 | KlassHandle h_this_klass(THREAD, Universe::klassKlassObj()); |
duke@435 | 31 | KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL); |
duke@435 | 32 | // Make sure size calculation is right |
duke@435 | 33 | assert(k()->size() == align_object_size(header_size()), "wrong size for object"); |
duke@435 | 34 | java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror |
duke@435 | 35 | return k(); |
duke@435 | 36 | } |
duke@435 | 37 | |
duke@435 | 38 | int instanceKlassKlass::oop_size(oop obj) const { |
duke@435 | 39 | assert(obj->is_klass(), "must be klass"); |
duke@435 | 40 | return instanceKlass::cast(klassOop(obj))->object_size(); |
duke@435 | 41 | } |
duke@435 | 42 | |
duke@435 | 43 | bool instanceKlassKlass::oop_is_parsable(oop obj) const { |
duke@435 | 44 | assert(obj->is_klass(), "must be klass"); |
duke@435 | 45 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 46 | return (!ik->null_vtbl()) && ik->object_is_parsable(); |
duke@435 | 47 | } |
duke@435 | 48 | |
duke@435 | 49 | void instanceKlassKlass::iterate_c_heap_oops(instanceKlass* ik, |
duke@435 | 50 | OopClosure* closure) { |
duke@435 | 51 | if (ik->oop_map_cache() != NULL) { |
duke@435 | 52 | ik->oop_map_cache()->oop_iterate(closure); |
duke@435 | 53 | } |
duke@435 | 54 | |
duke@435 | 55 | if (ik->jni_ids() != NULL) { |
duke@435 | 56 | ik->jni_ids()->oops_do(closure); |
duke@435 | 57 | } |
duke@435 | 58 | } |
duke@435 | 59 | |
duke@435 | 60 | void instanceKlassKlass::oop_follow_contents(oop obj) { |
duke@435 | 61 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 62 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); |
duke@435 | 63 | |
duke@435 | 64 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 65 | ik->follow_static_fields(); |
duke@435 | 66 | { |
duke@435 | 67 | HandleMark hm; |
duke@435 | 68 | ik->vtable()->oop_follow_contents(); |
duke@435 | 69 | ik->itable()->oop_follow_contents(); |
duke@435 | 70 | } |
duke@435 | 71 | |
duke@435 | 72 | MarkSweep::mark_and_push(ik->adr_array_klasses()); |
duke@435 | 73 | MarkSweep::mark_and_push(ik->adr_methods()); |
duke@435 | 74 | MarkSweep::mark_and_push(ik->adr_method_ordering()); |
duke@435 | 75 | MarkSweep::mark_and_push(ik->adr_local_interfaces()); |
duke@435 | 76 | MarkSweep::mark_and_push(ik->adr_transitive_interfaces()); |
duke@435 | 77 | MarkSweep::mark_and_push(ik->adr_fields()); |
duke@435 | 78 | MarkSweep::mark_and_push(ik->adr_constants()); |
duke@435 | 79 | MarkSweep::mark_and_push(ik->adr_class_loader()); |
duke@435 | 80 | MarkSweep::mark_and_push(ik->adr_source_file_name()); |
duke@435 | 81 | MarkSweep::mark_and_push(ik->adr_source_debug_extension()); |
duke@435 | 82 | MarkSweep::mark_and_push(ik->adr_inner_classes()); |
duke@435 | 83 | MarkSweep::mark_and_push(ik->adr_protection_domain()); |
jrose@866 | 84 | MarkSweep::mark_and_push(ik->adr_host_klass()); |
duke@435 | 85 | MarkSweep::mark_and_push(ik->adr_signers()); |
duke@435 | 86 | MarkSweep::mark_and_push(ik->adr_generic_signature()); |
jrose@1161 | 87 | MarkSweep::mark_and_push(ik->adr_bootstrap_method()); |
duke@435 | 88 | MarkSweep::mark_and_push(ik->adr_class_annotations()); |
duke@435 | 89 | MarkSweep::mark_and_push(ik->adr_fields_annotations()); |
duke@435 | 90 | MarkSweep::mark_and_push(ik->adr_methods_annotations()); |
duke@435 | 91 | MarkSweep::mark_and_push(ik->adr_methods_parameter_annotations()); |
duke@435 | 92 | MarkSweep::mark_and_push(ik->adr_methods_default_annotations()); |
duke@435 | 93 | |
duke@435 | 94 | // We do not follow adr_implementors() here. It is followed later |
duke@435 | 95 | // in instanceKlass::follow_weak_klass_links() |
duke@435 | 96 | |
duke@435 | 97 | klassKlass::oop_follow_contents(obj); |
duke@435 | 98 | |
duke@435 | 99 | iterate_c_heap_oops(ik, &MarkSweep::mark_and_push_closure); |
duke@435 | 100 | } |
duke@435 | 101 | |
duke@435 | 102 | #ifndef SERIALGC |
duke@435 | 103 | void instanceKlassKlass::oop_follow_contents(ParCompactionManager* cm, |
duke@435 | 104 | oop obj) { |
duke@435 | 105 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 106 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); |
duke@435 | 107 | |
duke@435 | 108 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 109 | ik->follow_static_fields(cm); |
duke@435 | 110 | ik->vtable()->oop_follow_contents(cm); |
duke@435 | 111 | ik->itable()->oop_follow_contents(cm); |
duke@435 | 112 | |
duke@435 | 113 | PSParallelCompact::mark_and_push(cm, ik->adr_array_klasses()); |
duke@435 | 114 | PSParallelCompact::mark_and_push(cm, ik->adr_methods()); |
duke@435 | 115 | PSParallelCompact::mark_and_push(cm, ik->adr_method_ordering()); |
duke@435 | 116 | PSParallelCompact::mark_and_push(cm, ik->adr_local_interfaces()); |
duke@435 | 117 | PSParallelCompact::mark_and_push(cm, ik->adr_transitive_interfaces()); |
duke@435 | 118 | PSParallelCompact::mark_and_push(cm, ik->adr_fields()); |
duke@435 | 119 | PSParallelCompact::mark_and_push(cm, ik->adr_constants()); |
duke@435 | 120 | PSParallelCompact::mark_and_push(cm, ik->adr_class_loader()); |
duke@435 | 121 | PSParallelCompact::mark_and_push(cm, ik->adr_source_file_name()); |
duke@435 | 122 | PSParallelCompact::mark_and_push(cm, ik->adr_source_debug_extension()); |
duke@435 | 123 | PSParallelCompact::mark_and_push(cm, ik->adr_inner_classes()); |
duke@435 | 124 | PSParallelCompact::mark_and_push(cm, ik->adr_protection_domain()); |
jrose@866 | 125 | PSParallelCompact::mark_and_push(cm, ik->adr_host_klass()); |
duke@435 | 126 | PSParallelCompact::mark_and_push(cm, ik->adr_signers()); |
duke@435 | 127 | PSParallelCompact::mark_and_push(cm, ik->adr_generic_signature()); |
jrose@1161 | 128 | PSParallelCompact::mark_and_push(cm, ik->adr_bootstrap_method()); |
duke@435 | 129 | PSParallelCompact::mark_and_push(cm, ik->adr_class_annotations()); |
duke@435 | 130 | PSParallelCompact::mark_and_push(cm, ik->adr_fields_annotations()); |
duke@435 | 131 | PSParallelCompact::mark_and_push(cm, ik->adr_methods_annotations()); |
duke@435 | 132 | PSParallelCompact::mark_and_push(cm, ik->adr_methods_parameter_annotations()); |
duke@435 | 133 | PSParallelCompact::mark_and_push(cm, ik->adr_methods_default_annotations()); |
duke@435 | 134 | |
duke@435 | 135 | // We do not follow adr_implementor() here. It is followed later |
duke@435 | 136 | // in instanceKlass::follow_weak_klass_links() |
duke@435 | 137 | |
duke@435 | 138 | klassKlass::oop_follow_contents(cm, obj); |
duke@435 | 139 | |
duke@435 | 140 | PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm); |
duke@435 | 141 | iterate_c_heap_oops(ik, &mark_and_push_closure); |
duke@435 | 142 | } |
duke@435 | 143 | #endif // SERIALGC |
duke@435 | 144 | |
duke@435 | 145 | int instanceKlassKlass::oop_oop_iterate(oop obj, OopClosure* blk) { |
duke@435 | 146 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 147 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); |
duke@435 | 148 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 149 | // Get size before changing pointers. |
duke@435 | 150 | // Don't call size() or oop_size() since that is a virtual call. |
duke@435 | 151 | int size = ik->object_size(); |
duke@435 | 152 | |
duke@435 | 153 | ik->iterate_static_fields(blk); |
duke@435 | 154 | ik->vtable()->oop_oop_iterate(blk); |
duke@435 | 155 | ik->itable()->oop_oop_iterate(blk); |
duke@435 | 156 | |
duke@435 | 157 | blk->do_oop(ik->adr_array_klasses()); |
duke@435 | 158 | blk->do_oop(ik->adr_methods()); |
duke@435 | 159 | blk->do_oop(ik->adr_method_ordering()); |
duke@435 | 160 | blk->do_oop(ik->adr_local_interfaces()); |
duke@435 | 161 | blk->do_oop(ik->adr_transitive_interfaces()); |
duke@435 | 162 | blk->do_oop(ik->adr_fields()); |
duke@435 | 163 | blk->do_oop(ik->adr_constants()); |
duke@435 | 164 | blk->do_oop(ik->adr_class_loader()); |
duke@435 | 165 | blk->do_oop(ik->adr_protection_domain()); |
jrose@866 | 166 | blk->do_oop(ik->adr_host_klass()); |
duke@435 | 167 | blk->do_oop(ik->adr_signers()); |
duke@435 | 168 | blk->do_oop(ik->adr_source_file_name()); |
duke@435 | 169 | blk->do_oop(ik->adr_source_debug_extension()); |
duke@435 | 170 | blk->do_oop(ik->adr_inner_classes()); |
duke@435 | 171 | for (int i = 0; i < instanceKlass::implementors_limit; i++) { |
duke@435 | 172 | blk->do_oop(&ik->adr_implementors()[i]); |
duke@435 | 173 | } |
duke@435 | 174 | blk->do_oop(ik->adr_generic_signature()); |
jrose@1161 | 175 | blk->do_oop(ik->adr_bootstrap_method()); |
duke@435 | 176 | blk->do_oop(ik->adr_class_annotations()); |
duke@435 | 177 | blk->do_oop(ik->adr_fields_annotations()); |
duke@435 | 178 | blk->do_oop(ik->adr_methods_annotations()); |
duke@435 | 179 | blk->do_oop(ik->adr_methods_parameter_annotations()); |
duke@435 | 180 | blk->do_oop(ik->adr_methods_default_annotations()); |
duke@435 | 181 | |
duke@435 | 182 | klassKlass::oop_oop_iterate(obj, blk); |
duke@435 | 183 | |
duke@435 | 184 | if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk); |
duke@435 | 185 | return size; |
duke@435 | 186 | } |
duke@435 | 187 | |
duke@435 | 188 | int instanceKlassKlass::oop_oop_iterate_m(oop obj, OopClosure* blk, |
duke@435 | 189 | MemRegion mr) { |
duke@435 | 190 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 191 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); |
duke@435 | 192 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 193 | // Get size before changing pointers. |
duke@435 | 194 | // Don't call size() or oop_size() since that is a virtual call. |
duke@435 | 195 | int size = ik->object_size(); |
duke@435 | 196 | |
duke@435 | 197 | ik->iterate_static_fields(blk, mr); |
duke@435 | 198 | ik->vtable()->oop_oop_iterate_m(blk, mr); |
duke@435 | 199 | ik->itable()->oop_oop_iterate_m(blk, mr); |
duke@435 | 200 | |
duke@435 | 201 | oop* adr; |
duke@435 | 202 | adr = ik->adr_array_klasses(); |
duke@435 | 203 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 204 | adr = ik->adr_methods(); |
duke@435 | 205 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 206 | adr = ik->adr_method_ordering(); |
duke@435 | 207 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 208 | adr = ik->adr_local_interfaces(); |
duke@435 | 209 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 210 | adr = ik->adr_transitive_interfaces(); |
duke@435 | 211 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 212 | adr = ik->adr_fields(); |
duke@435 | 213 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 214 | adr = ik->adr_constants(); |
duke@435 | 215 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 216 | adr = ik->adr_class_loader(); |
duke@435 | 217 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 218 | adr = ik->adr_protection_domain(); |
duke@435 | 219 | if (mr.contains(adr)) blk->do_oop(adr); |
jrose@866 | 220 | adr = ik->adr_host_klass(); |
jrose@866 | 221 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 222 | adr = ik->adr_signers(); |
duke@435 | 223 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 224 | adr = ik->adr_source_file_name(); |
duke@435 | 225 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 226 | adr = ik->adr_source_debug_extension(); |
duke@435 | 227 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 228 | adr = ik->adr_inner_classes(); |
duke@435 | 229 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 230 | adr = ik->adr_implementors(); |
duke@435 | 231 | for (int i = 0; i < instanceKlass::implementors_limit; i++) { |
duke@435 | 232 | if (mr.contains(&adr[i])) blk->do_oop(&adr[i]); |
duke@435 | 233 | } |
duke@435 | 234 | adr = ik->adr_generic_signature(); |
duke@435 | 235 | if (mr.contains(adr)) blk->do_oop(adr); |
jrose@1161 | 236 | adr = ik->adr_bootstrap_method(); |
jrose@1161 | 237 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 238 | adr = ik->adr_class_annotations(); |
duke@435 | 239 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 240 | adr = ik->adr_fields_annotations(); |
duke@435 | 241 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 242 | adr = ik->adr_methods_annotations(); |
duke@435 | 243 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 244 | adr = ik->adr_methods_parameter_annotations(); |
duke@435 | 245 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 246 | adr = ik->adr_methods_default_annotations(); |
duke@435 | 247 | if (mr.contains(adr)) blk->do_oop(adr); |
duke@435 | 248 | |
duke@435 | 249 | klassKlass::oop_oop_iterate_m(obj, blk, mr); |
duke@435 | 250 | |
duke@435 | 251 | if(ik->oop_map_cache() != NULL) ik->oop_map_cache()->oop_iterate(blk, mr); |
duke@435 | 252 | return size; |
duke@435 | 253 | } |
duke@435 | 254 | |
duke@435 | 255 | int instanceKlassKlass::oop_adjust_pointers(oop obj) { |
duke@435 | 256 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 257 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), "must be instance klass"); |
duke@435 | 258 | |
duke@435 | 259 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 260 | ik->adjust_static_fields(); |
duke@435 | 261 | ik->vtable()->oop_adjust_pointers(); |
duke@435 | 262 | ik->itable()->oop_adjust_pointers(); |
duke@435 | 263 | |
duke@435 | 264 | MarkSweep::adjust_pointer(ik->adr_array_klasses()); |
duke@435 | 265 | MarkSweep::adjust_pointer(ik->adr_methods()); |
duke@435 | 266 | MarkSweep::adjust_pointer(ik->adr_method_ordering()); |
duke@435 | 267 | MarkSweep::adjust_pointer(ik->adr_local_interfaces()); |
duke@435 | 268 | MarkSweep::adjust_pointer(ik->adr_transitive_interfaces()); |
duke@435 | 269 | MarkSweep::adjust_pointer(ik->adr_fields()); |
duke@435 | 270 | MarkSweep::adjust_pointer(ik->adr_constants()); |
duke@435 | 271 | MarkSweep::adjust_pointer(ik->adr_class_loader()); |
duke@435 | 272 | MarkSweep::adjust_pointer(ik->adr_protection_domain()); |
jrose@866 | 273 | MarkSweep::adjust_pointer(ik->adr_host_klass()); |
duke@435 | 274 | MarkSweep::adjust_pointer(ik->adr_signers()); |
duke@435 | 275 | MarkSweep::adjust_pointer(ik->adr_source_file_name()); |
duke@435 | 276 | MarkSweep::adjust_pointer(ik->adr_source_debug_extension()); |
duke@435 | 277 | MarkSweep::adjust_pointer(ik->adr_inner_classes()); |
duke@435 | 278 | for (int i = 0; i < instanceKlass::implementors_limit; i++) { |
duke@435 | 279 | MarkSweep::adjust_pointer(&ik->adr_implementors()[i]); |
duke@435 | 280 | } |
duke@435 | 281 | MarkSweep::adjust_pointer(ik->adr_generic_signature()); |
jrose@1161 | 282 | MarkSweep::adjust_pointer(ik->adr_bootstrap_method()); |
duke@435 | 283 | MarkSweep::adjust_pointer(ik->adr_class_annotations()); |
duke@435 | 284 | MarkSweep::adjust_pointer(ik->adr_fields_annotations()); |
duke@435 | 285 | MarkSweep::adjust_pointer(ik->adr_methods_annotations()); |
duke@435 | 286 | MarkSweep::adjust_pointer(ik->adr_methods_parameter_annotations()); |
duke@435 | 287 | MarkSweep::adjust_pointer(ik->adr_methods_default_annotations()); |
duke@435 | 288 | |
duke@435 | 289 | iterate_c_heap_oops(ik, &MarkSweep::adjust_root_pointer_closure); |
duke@435 | 290 | |
duke@435 | 291 | return klassKlass::oop_adjust_pointers(obj); |
duke@435 | 292 | } |
duke@435 | 293 | |
duke@435 | 294 | #ifndef SERIALGC |
duke@435 | 295 | void instanceKlassKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) { |
duke@435 | 296 | assert(!pm->depth_first(), "invariant"); |
duke@435 | 297 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 298 | ik->copy_static_fields(pm); |
duke@435 | 299 | |
duke@435 | 300 | oop* loader_addr = ik->adr_class_loader(); |
coleenp@548 | 301 | if (PSScavenge::should_scavenge(loader_addr)) { |
duke@435 | 302 | pm->claim_or_forward_breadth(loader_addr); |
duke@435 | 303 | } |
duke@435 | 304 | |
duke@435 | 305 | oop* pd_addr = ik->adr_protection_domain(); |
coleenp@548 | 306 | if (PSScavenge::should_scavenge(pd_addr)) { |
duke@435 | 307 | pm->claim_or_forward_breadth(pd_addr); |
duke@435 | 308 | } |
duke@435 | 309 | |
jrose@866 | 310 | oop* hk_addr = ik->adr_host_klass(); |
jrose@866 | 311 | if (PSScavenge::should_scavenge(hk_addr)) { |
jrose@866 | 312 | pm->claim_or_forward_breadth(hk_addr); |
jrose@866 | 313 | } |
jrose@866 | 314 | |
duke@435 | 315 | oop* sg_addr = ik->adr_signers(); |
coleenp@548 | 316 | if (PSScavenge::should_scavenge(sg_addr)) { |
duke@435 | 317 | pm->claim_or_forward_breadth(sg_addr); |
duke@435 | 318 | } |
duke@435 | 319 | |
jrose@1494 | 320 | oop* bsm_addr = ik->adr_bootstrap_method(); |
jrose@1494 | 321 | if (PSScavenge::should_scavenge(bsm_addr)) { |
jrose@1494 | 322 | pm->claim_or_forward_breadth(bsm_addr); |
jrose@1494 | 323 | } |
jrose@1494 | 324 | |
duke@435 | 325 | klassKlass::oop_copy_contents(pm, obj); |
duke@435 | 326 | } |
duke@435 | 327 | |
duke@435 | 328 | void instanceKlassKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { |
duke@435 | 329 | assert(pm->depth_first(), "invariant"); |
duke@435 | 330 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 331 | ik->push_static_fields(pm); |
duke@435 | 332 | |
duke@435 | 333 | oop* loader_addr = ik->adr_class_loader(); |
coleenp@548 | 334 | if (PSScavenge::should_scavenge(loader_addr)) { |
duke@435 | 335 | pm->claim_or_forward_depth(loader_addr); |
duke@435 | 336 | } |
duke@435 | 337 | |
duke@435 | 338 | oop* pd_addr = ik->adr_protection_domain(); |
coleenp@548 | 339 | if (PSScavenge::should_scavenge(pd_addr)) { |
duke@435 | 340 | pm->claim_or_forward_depth(pd_addr); |
duke@435 | 341 | } |
duke@435 | 342 | |
jrose@866 | 343 | oop* hk_addr = ik->adr_host_klass(); |
jrose@866 | 344 | if (PSScavenge::should_scavenge(hk_addr)) { |
jrose@866 | 345 | pm->claim_or_forward_depth(hk_addr); |
jrose@866 | 346 | } |
jrose@866 | 347 | |
duke@435 | 348 | oop* sg_addr = ik->adr_signers(); |
coleenp@548 | 349 | if (PSScavenge::should_scavenge(sg_addr)) { |
duke@435 | 350 | pm->claim_or_forward_depth(sg_addr); |
duke@435 | 351 | } |
duke@435 | 352 | |
jrose@1494 | 353 | oop* bsm_addr = ik->adr_bootstrap_method(); |
jrose@1494 | 354 | if (PSScavenge::should_scavenge(bsm_addr)) { |
jrose@1494 | 355 | pm->claim_or_forward_depth(bsm_addr); |
jrose@1494 | 356 | } |
jrose@1494 | 357 | |
duke@435 | 358 | klassKlass::oop_copy_contents(pm, obj); |
duke@435 | 359 | } |
duke@435 | 360 | |
duke@435 | 361 | int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { |
duke@435 | 362 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 363 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), |
duke@435 | 364 | "must be instance klass"); |
duke@435 | 365 | |
duke@435 | 366 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 367 | ik->update_static_fields(); |
duke@435 | 368 | ik->vtable()->oop_update_pointers(cm); |
duke@435 | 369 | ik->itable()->oop_update_pointers(cm); |
duke@435 | 370 | |
duke@435 | 371 | oop* const beg_oop = ik->oop_block_beg(); |
duke@435 | 372 | oop* const end_oop = ik->oop_block_end(); |
duke@435 | 373 | for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { |
duke@435 | 374 | PSParallelCompact::adjust_pointer(cur_oop); |
duke@435 | 375 | } |
duke@435 | 376 | |
duke@435 | 377 | OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); |
duke@435 | 378 | iterate_c_heap_oops(ik, closure); |
duke@435 | 379 | |
duke@435 | 380 | klassKlass::oop_update_pointers(cm, obj); |
duke@435 | 381 | return ik->object_size(); |
duke@435 | 382 | } |
duke@435 | 383 | |
duke@435 | 384 | int instanceKlassKlass::oop_update_pointers(ParCompactionManager* cm, oop obj, |
duke@435 | 385 | HeapWord* beg_addr, |
duke@435 | 386 | HeapWord* end_addr) { |
duke@435 | 387 | assert(obj->is_klass(),"must be a klass"); |
duke@435 | 388 | assert(klassOop(obj)->klass_part()->oop_is_instance_slow(), |
duke@435 | 389 | "must be instance klass"); |
duke@435 | 390 | |
duke@435 | 391 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 392 | ik->update_static_fields(beg_addr, end_addr); |
duke@435 | 393 | ik->vtable()->oop_update_pointers(cm, beg_addr, end_addr); |
duke@435 | 394 | ik->itable()->oop_update_pointers(cm, beg_addr, end_addr); |
duke@435 | 395 | |
duke@435 | 396 | oop* const beg_oop = MAX2((oop*)beg_addr, ik->oop_block_beg()); |
duke@435 | 397 | oop* const end_oop = MIN2((oop*)end_addr, ik->oop_block_end()); |
duke@435 | 398 | for (oop* cur_oop = beg_oop; cur_oop < end_oop; ++cur_oop) { |
duke@435 | 399 | PSParallelCompact::adjust_pointer(cur_oop); |
duke@435 | 400 | } |
duke@435 | 401 | |
duke@435 | 402 | // The oop_map_cache, jni_ids and jni_id_map are allocated from the C heap, |
duke@435 | 403 | // and so don't lie within any 'Chunk' boundaries. Update them when the |
duke@435 | 404 | // lowest addressed oop in the instanceKlass 'oop_block' is updated. |
duke@435 | 405 | if (beg_oop == ik->oop_block_beg()) { |
duke@435 | 406 | OopClosure* closure = PSParallelCompact::adjust_root_pointer_closure(); |
duke@435 | 407 | iterate_c_heap_oops(ik, closure); |
duke@435 | 408 | } |
duke@435 | 409 | |
duke@435 | 410 | klassKlass::oop_update_pointers(cm, obj, beg_addr, end_addr); |
duke@435 | 411 | return ik->object_size(); |
duke@435 | 412 | } |
duke@435 | 413 | #endif // SERIALGC |
duke@435 | 414 | |
jcoomes@1373 | 415 | klassOop |
jcoomes@1373 | 416 | instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len, |
jcoomes@1373 | 417 | int static_field_size, |
jcoomes@1374 | 418 | unsigned nonstatic_oop_map_count, |
jcoomes@1373 | 419 | ReferenceType rt, TRAPS) { |
duke@435 | 420 | |
jcoomes@1373 | 421 | const int nonstatic_oop_map_size = |
jcoomes@1373 | 422 | instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count); |
duke@435 | 423 | int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size); |
duke@435 | 424 | |
duke@435 | 425 | // Allocation |
duke@435 | 426 | KlassHandle h_this_klass(THREAD, as_klassOop()); |
duke@435 | 427 | KlassHandle k; |
duke@435 | 428 | if (rt == REF_NONE) { |
duke@435 | 429 | // regular klass |
duke@435 | 430 | instanceKlass o; |
duke@435 | 431 | k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL); |
duke@435 | 432 | } else { |
duke@435 | 433 | // reference klass |
duke@435 | 434 | instanceRefKlass o; |
duke@435 | 435 | k = base_create_klass(h_this_klass, size, o.vtbl_value(), CHECK_NULL); |
duke@435 | 436 | } |
duke@435 | 437 | { |
duke@435 | 438 | No_Safepoint_Verifier no_safepoint; // until k becomes parsable |
duke@435 | 439 | instanceKlass* ik = (instanceKlass*) k()->klass_part(); |
duke@435 | 440 | assert(!k()->is_parsable(), "not expecting parsability yet."); |
duke@435 | 441 | |
duke@435 | 442 | // The sizes of these these three variables are used for determining the |
duke@435 | 443 | // size of the instanceKlassOop. It is critical that these are set to the right |
duke@435 | 444 | // sizes before the first GC, i.e., when we allocate the mirror. |
duke@435 | 445 | ik->set_vtable_length(vtable_len); |
duke@435 | 446 | ik->set_itable_length(itable_len); |
duke@435 | 447 | ik->set_static_field_size(static_field_size); |
duke@435 | 448 | ik->set_nonstatic_oop_map_size(nonstatic_oop_map_size); |
duke@435 | 449 | assert(k()->size() == size, "wrong size for object"); |
duke@435 | 450 | |
duke@435 | 451 | ik->set_array_klasses(NULL); |
duke@435 | 452 | ik->set_methods(NULL); |
duke@435 | 453 | ik->set_method_ordering(NULL); |
duke@435 | 454 | ik->set_local_interfaces(NULL); |
duke@435 | 455 | ik->set_transitive_interfaces(NULL); |
duke@435 | 456 | ik->init_implementor(); |
duke@435 | 457 | ik->set_fields(NULL); |
duke@435 | 458 | ik->set_constants(NULL); |
duke@435 | 459 | ik->set_class_loader(NULL); |
duke@435 | 460 | ik->set_protection_domain(NULL); |
jrose@866 | 461 | ik->set_host_klass(NULL); |
duke@435 | 462 | ik->set_signers(NULL); |
duke@435 | 463 | ik->set_source_file_name(NULL); |
duke@435 | 464 | ik->set_source_debug_extension(NULL); |
duke@435 | 465 | ik->set_inner_classes(NULL); |
duke@435 | 466 | ik->set_static_oop_field_size(0); |
duke@435 | 467 | ik->set_nonstatic_field_size(0); |
acorn@1410 | 468 | ik->set_is_marked_dependent(false); |
duke@435 | 469 | ik->set_init_state(instanceKlass::allocated); |
duke@435 | 470 | ik->set_init_thread(NULL); |
duke@435 | 471 | ik->set_reference_type(rt); |
duke@435 | 472 | ik->set_oop_map_cache(NULL); |
duke@435 | 473 | ik->set_jni_ids(NULL); |
duke@435 | 474 | ik->set_osr_nmethods_head(NULL); |
duke@435 | 475 | ik->set_breakpoints(NULL); |
duke@435 | 476 | ik->init_previous_versions(); |
duke@435 | 477 | ik->set_generic_signature(NULL); |
jrose@1161 | 478 | ik->set_bootstrap_method(NULL); |
duke@435 | 479 | ik->release_set_methods_jmethod_ids(NULL); |
duke@435 | 480 | ik->release_set_methods_cached_itable_indices(NULL); |
duke@435 | 481 | ik->set_class_annotations(NULL); |
duke@435 | 482 | ik->set_fields_annotations(NULL); |
duke@435 | 483 | ik->set_methods_annotations(NULL); |
duke@435 | 484 | ik->set_methods_parameter_annotations(NULL); |
duke@435 | 485 | ik->set_methods_default_annotations(NULL); |
duke@435 | 486 | ik->set_enclosing_method_indices(0, 0); |
duke@435 | 487 | ik->set_jvmti_cached_class_field_map(NULL); |
duke@435 | 488 | ik->set_initial_method_idnum(0); |
duke@435 | 489 | assert(k()->is_parsable(), "should be parsable here."); |
duke@435 | 490 | |
duke@435 | 491 | // initialize the non-header words to zero |
duke@435 | 492 | intptr_t* p = (intptr_t*)k(); |
duke@435 | 493 | for (int index = instanceKlass::header_size(); index < size; index++) { |
duke@435 | 494 | p[index] = NULL_WORD; |
duke@435 | 495 | } |
duke@435 | 496 | |
duke@435 | 497 | // To get verify to work - must be set to partial loaded before first GC point. |
duke@435 | 498 | k()->set_partially_loaded(); |
duke@435 | 499 | } |
duke@435 | 500 | |
duke@435 | 501 | // GC can happen here |
duke@435 | 502 | java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror |
duke@435 | 503 | return k(); |
duke@435 | 504 | } |
duke@435 | 505 | |
duke@435 | 506 | |
duke@435 | 507 | |
duke@435 | 508 | #ifndef PRODUCT |
duke@435 | 509 | |
duke@435 | 510 | // Printing |
duke@435 | 511 | |
jrose@1100 | 512 | #define BULLET " - " |
jrose@1100 | 513 | |
duke@435 | 514 | static const char* state_names[] = { |
duke@435 | 515 | "unparseable_by_gc", "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error" |
duke@435 | 516 | }; |
duke@435 | 517 | |
duke@435 | 518 | |
duke@435 | 519 | void instanceKlassKlass::oop_print_on(oop obj, outputStream* st) { |
duke@435 | 520 | assert(obj->is_klass(), "must be klass"); |
duke@435 | 521 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 522 | klassKlass::oop_print_on(obj, st); |
duke@435 | 523 | |
jrose@1100 | 524 | st->print(BULLET"instance size: %d", ik->size_helper()); st->cr(); |
jrose@1100 | 525 | st->print(BULLET"klass size: %d", ik->object_size()); st->cr(); |
jrose@1100 | 526 | st->print(BULLET"access: "); ik->access_flags().print_on(st); st->cr(); |
jrose@1100 | 527 | st->print(BULLET"state: "); st->print_cr(state_names[ik->_init_state]); |
jrose@1100 | 528 | st->print(BULLET"name: "); ik->name()->print_value_on(st); st->cr(); |
jrose@1100 | 529 | st->print(BULLET"super: "); ik->super()->print_value_on(st); st->cr(); |
jrose@1100 | 530 | st->print(BULLET"sub: "); |
duke@435 | 531 | Klass* sub = ik->subklass(); |
duke@435 | 532 | int n; |
duke@435 | 533 | for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) { |
duke@435 | 534 | if (n < MaxSubklassPrintSize) { |
duke@435 | 535 | sub->as_klassOop()->print_value_on(st); |
duke@435 | 536 | st->print(" "); |
duke@435 | 537 | } |
duke@435 | 538 | } |
duke@435 | 539 | if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize); |
duke@435 | 540 | st->cr(); |
duke@435 | 541 | |
duke@435 | 542 | if (ik->is_interface()) { |
jrose@1100 | 543 | st->print_cr(BULLET"nof implementors: %d", ik->nof_implementors()); |
duke@435 | 544 | int print_impl = 0; |
duke@435 | 545 | for (int i = 0; i < instanceKlass::implementors_limit; i++) { |
duke@435 | 546 | if (ik->implementor(i) != NULL) { |
duke@435 | 547 | if (++print_impl == 1) |
jrose@1100 | 548 | st->print_cr(BULLET"implementor: "); |
duke@435 | 549 | st->print(" "); |
duke@435 | 550 | ik->implementor(i)->print_value_on(st); |
duke@435 | 551 | } |
duke@435 | 552 | } |
duke@435 | 553 | if (print_impl > 0) st->cr(); |
duke@435 | 554 | } |
duke@435 | 555 | |
jrose@1100 | 556 | st->print(BULLET"arrays: "); ik->array_klasses()->print_value_on(st); st->cr(); |
jrose@1100 | 557 | st->print(BULLET"methods: "); ik->methods()->print_value_on(st); st->cr(); |
duke@435 | 558 | if (Verbose) { |
duke@435 | 559 | objArrayOop methods = ik->methods(); |
duke@435 | 560 | for(int i = 0; i < methods->length(); i++) { |
duke@435 | 561 | tty->print("%d : ", i); methods->obj_at(i)->print_value(); tty->cr(); |
duke@435 | 562 | } |
duke@435 | 563 | } |
jrose@1100 | 564 | st->print(BULLET"method ordering: "); ik->method_ordering()->print_value_on(st); st->cr(); |
jrose@1100 | 565 | st->print(BULLET"local interfaces: "); ik->local_interfaces()->print_value_on(st); st->cr(); |
jrose@1100 | 566 | st->print(BULLET"trans. interfaces: "); ik->transitive_interfaces()->print_value_on(st); st->cr(); |
jrose@1100 | 567 | st->print(BULLET"constants: "); ik->constants()->print_value_on(st); st->cr(); |
jrose@1100 | 568 | st->print(BULLET"class loader: "); ik->class_loader()->print_value_on(st); st->cr(); |
jrose@1100 | 569 | st->print(BULLET"protection domain: "); ik->protection_domain()->print_value_on(st); st->cr(); |
jrose@1100 | 570 | st->print(BULLET"host class: "); ik->host_klass()->print_value_on(st); st->cr(); |
jrose@1100 | 571 | st->print(BULLET"signers: "); ik->signers()->print_value_on(st); st->cr(); |
duke@435 | 572 | if (ik->source_file_name() != NULL) { |
jrose@1100 | 573 | st->print(BULLET"source file: "); |
duke@435 | 574 | ik->source_file_name()->print_value_on(st); |
duke@435 | 575 | st->cr(); |
duke@435 | 576 | } |
duke@435 | 577 | if (ik->source_debug_extension() != NULL) { |
jrose@1100 | 578 | st->print(BULLET"source debug extension: "); |
duke@435 | 579 | ik->source_debug_extension()->print_value_on(st); |
duke@435 | 580 | st->cr(); |
duke@435 | 581 | } |
duke@435 | 582 | |
duke@435 | 583 | { |
duke@435 | 584 | ResourceMark rm; |
duke@435 | 585 | // PreviousVersionInfo objects returned via PreviousVersionWalker |
duke@435 | 586 | // contain a GrowableArray of handles. We have to clean up the |
duke@435 | 587 | // GrowableArray _after_ the PreviousVersionWalker destructor |
duke@435 | 588 | // has destroyed the handles. |
duke@435 | 589 | { |
jrose@1100 | 590 | bool have_pv = false; |
duke@435 | 591 | PreviousVersionWalker pvw(ik); |
duke@435 | 592 | for (PreviousVersionInfo * pv_info = pvw.next_previous_version(); |
duke@435 | 593 | pv_info != NULL; pv_info = pvw.next_previous_version()) { |
jrose@1100 | 594 | if (!have_pv) |
jrose@1100 | 595 | st->print(BULLET"previous version: "); |
jrose@1100 | 596 | have_pv = true; |
duke@435 | 597 | pv_info->prev_constant_pool_handle()()->print_value_on(st); |
duke@435 | 598 | } |
jrose@1100 | 599 | if (have_pv) st->cr(); |
duke@435 | 600 | } // pvw is cleaned up |
duke@435 | 601 | } // rm is cleaned up |
duke@435 | 602 | |
jrose@1161 | 603 | if (ik->bootstrap_method() != NULL) { |
jrose@1161 | 604 | st->print(BULLET"bootstrap method: "); |
jrose@1161 | 605 | ik->bootstrap_method()->print_value_on(st); |
jrose@1161 | 606 | st->cr(); |
jrose@1161 | 607 | } |
duke@435 | 608 | if (ik->generic_signature() != NULL) { |
jrose@1100 | 609 | st->print(BULLET"generic signature: "); |
duke@435 | 610 | ik->generic_signature()->print_value_on(st); |
jrose@1100 | 611 | st->cr(); |
duke@435 | 612 | } |
jrose@1100 | 613 | st->print(BULLET"inner classes: "); ik->inner_classes()->print_value_on(st); st->cr(); |
jrose@1100 | 614 | st->print(BULLET"java mirror: "); ik->java_mirror()->print_value_on(st); st->cr(); |
jrose@1100 | 615 | st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", ik->vtable_length(), ik->start_of_vtable()); st->cr(); |
jrose@1100 | 616 | st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", ik->itable_length(), ik->start_of_itable()); st->cr(); |
jrose@1100 | 617 | st->print_cr(BULLET"---- static fields (%d words):", ik->static_field_size()); |
duke@435 | 618 | FieldPrinter print_static_field(st); |
duke@435 | 619 | ik->do_local_static_fields(&print_static_field); |
jrose@1100 | 620 | st->print_cr(BULLET"---- non-static fields (%d words):", ik->nonstatic_field_size()); |
jrose@1100 | 621 | FieldPrinter print_nonstatic_field(st); |
duke@435 | 622 | ik->do_nonstatic_fields(&print_nonstatic_field); |
duke@435 | 623 | |
jrose@1100 | 624 | st->print(BULLET"static oop maps: "); |
duke@435 | 625 | if (ik->static_oop_field_size() > 0) { |
duke@435 | 626 | int first_offset = ik->offset_of_static_fields(); |
duke@435 | 627 | st->print("%d-%d", first_offset, first_offset + ik->static_oop_field_size() - 1); |
duke@435 | 628 | } |
duke@435 | 629 | st->cr(); |
duke@435 | 630 | |
jrose@1100 | 631 | st->print(BULLET"non-static oop maps: "); |
duke@435 | 632 | OopMapBlock* map = ik->start_of_nonstatic_oop_maps(); |
jcoomes@1373 | 633 | OopMapBlock* end_map = map + ik->nonstatic_oop_map_count(); |
duke@435 | 634 | while (map < end_map) { |
jcoomes@1373 | 635 | st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1)); |
duke@435 | 636 | map++; |
duke@435 | 637 | } |
duke@435 | 638 | st->cr(); |
duke@435 | 639 | } |
duke@435 | 640 | |
duke@435 | 641 | |
duke@435 | 642 | void instanceKlassKlass::oop_print_value_on(oop obj, outputStream* st) { |
duke@435 | 643 | assert(obj->is_klass(), "must be klass"); |
duke@435 | 644 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 645 | ik->name()->print_value_on(st); |
duke@435 | 646 | } |
duke@435 | 647 | |
duke@435 | 648 | #endif // PRODUCT |
duke@435 | 649 | |
duke@435 | 650 | const char* instanceKlassKlass::internal_name() const { |
duke@435 | 651 | return "{instance class}"; |
duke@435 | 652 | } |
duke@435 | 653 | |
duke@435 | 654 | // Verification |
duke@435 | 655 | |
duke@435 | 656 | class VerifyFieldClosure: public OopClosure { |
coleenp@548 | 657 | protected: |
coleenp@548 | 658 | template <class T> void do_oop_work(T* p) { |
coleenp@548 | 659 | guarantee(Universe::heap()->is_in(p), "should be in heap"); |
coleenp@548 | 660 | oop obj = oopDesc::load_decode_heap_oop(p); |
coleenp@548 | 661 | guarantee(obj->is_oop_or_null(), "should be in heap"); |
coleenp@548 | 662 | } |
duke@435 | 663 | public: |
coleenp@548 | 664 | virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); } |
coleenp@548 | 665 | virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); } |
duke@435 | 666 | }; |
duke@435 | 667 | |
duke@435 | 668 | void instanceKlassKlass::oop_verify_on(oop obj, outputStream* st) { |
duke@435 | 669 | klassKlass::oop_verify_on(obj, st); |
duke@435 | 670 | if (!obj->partially_loaded()) { |
duke@435 | 671 | Thread *thread = Thread::current(); |
duke@435 | 672 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 673 | |
duke@435 | 674 | #ifndef PRODUCT |
duke@435 | 675 | // Avoid redundant verifies |
duke@435 | 676 | if (ik->_verify_count == Universe::verify_count()) return; |
duke@435 | 677 | ik->_verify_count = Universe::verify_count(); |
duke@435 | 678 | #endif |
duke@435 | 679 | // Verify that klass is present in SystemDictionary |
jrose@866 | 680 | if (ik->is_loaded() && !ik->is_anonymous()) { |
duke@435 | 681 | symbolHandle h_name (thread, ik->name()); |
duke@435 | 682 | Handle h_loader (thread, ik->class_loader()); |
duke@435 | 683 | Handle h_obj(thread, obj); |
duke@435 | 684 | SystemDictionary::verify_obj_klass_present(h_obj, h_name, h_loader); |
duke@435 | 685 | } |
duke@435 | 686 | |
duke@435 | 687 | // Verify static fields |
duke@435 | 688 | VerifyFieldClosure blk; |
duke@435 | 689 | ik->iterate_static_fields(&blk); |
duke@435 | 690 | |
duke@435 | 691 | // Verify vtables |
duke@435 | 692 | if (ik->is_linked()) { |
duke@435 | 693 | ResourceMark rm(thread); |
duke@435 | 694 | // $$$ This used to be done only for m/s collections. Doing it |
duke@435 | 695 | // always seemed a valid generalization. (DLD -- 6/00) |
duke@435 | 696 | ik->vtable()->verify(st); |
duke@435 | 697 | } |
duke@435 | 698 | |
duke@435 | 699 | // Verify oop map cache |
duke@435 | 700 | if (ik->oop_map_cache() != NULL) { |
duke@435 | 701 | ik->oop_map_cache()->verify(); |
duke@435 | 702 | } |
duke@435 | 703 | |
duke@435 | 704 | // Verify first subklass |
duke@435 | 705 | if (ik->subklass_oop() != NULL) { |
duke@435 | 706 | guarantee(ik->subklass_oop()->is_perm(), "should be in permspace"); |
duke@435 | 707 | guarantee(ik->subklass_oop()->is_klass(), "should be klass"); |
duke@435 | 708 | } |
duke@435 | 709 | |
duke@435 | 710 | // Verify siblings |
duke@435 | 711 | klassOop super = ik->super(); |
duke@435 | 712 | Klass* sib = ik->next_sibling(); |
duke@435 | 713 | int sib_count = 0; |
duke@435 | 714 | while (sib != NULL) { |
duke@435 | 715 | if (sib == ik) { |
duke@435 | 716 | fatal1("subclass cycle of length %d", sib_count); |
duke@435 | 717 | } |
duke@435 | 718 | if (sib_count >= 100000) { |
duke@435 | 719 | fatal1("suspiciously long subclass list %d", sib_count); |
duke@435 | 720 | } |
duke@435 | 721 | guarantee(sib->as_klassOop()->is_klass(), "should be klass"); |
duke@435 | 722 | guarantee(sib->as_klassOop()->is_perm(), "should be in permspace"); |
duke@435 | 723 | guarantee(sib->super() == super, "siblings should have same superklass"); |
duke@435 | 724 | sib = sib->next_sibling(); |
duke@435 | 725 | } |
duke@435 | 726 | |
duke@435 | 727 | // Verify implementor fields |
duke@435 | 728 | bool saw_null_impl = false; |
duke@435 | 729 | for (int i = 0; i < instanceKlass::implementors_limit; i++) { |
duke@435 | 730 | klassOop im = ik->implementor(i); |
duke@435 | 731 | if (im == NULL) { saw_null_impl = true; continue; } |
duke@435 | 732 | guarantee(!saw_null_impl, "non-nulls must preceded all nulls"); |
duke@435 | 733 | guarantee(ik->is_interface(), "only interfaces should have implementor set"); |
duke@435 | 734 | guarantee(i < ik->nof_implementors(), "should only have one implementor"); |
duke@435 | 735 | guarantee(im->is_perm(), "should be in permspace"); |
duke@435 | 736 | guarantee(im->is_klass(), "should be klass"); |
duke@435 | 737 | guarantee(!Klass::cast(klassOop(im))->is_interface(), "implementors cannot be interfaces"); |
duke@435 | 738 | } |
duke@435 | 739 | |
duke@435 | 740 | // Verify local interfaces |
duke@435 | 741 | objArrayOop local_interfaces = ik->local_interfaces(); |
duke@435 | 742 | guarantee(local_interfaces->is_perm(), "should be in permspace"); |
duke@435 | 743 | guarantee(local_interfaces->is_objArray(), "should be obj array"); |
duke@435 | 744 | int j; |
duke@435 | 745 | for (j = 0; j < local_interfaces->length(); j++) { |
duke@435 | 746 | oop e = local_interfaces->obj_at(j); |
duke@435 | 747 | guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid local interface"); |
duke@435 | 748 | } |
duke@435 | 749 | |
duke@435 | 750 | // Verify transitive interfaces |
duke@435 | 751 | objArrayOop transitive_interfaces = ik->transitive_interfaces(); |
duke@435 | 752 | guarantee(transitive_interfaces->is_perm(), "should be in permspace"); |
duke@435 | 753 | guarantee(transitive_interfaces->is_objArray(), "should be obj array"); |
duke@435 | 754 | for (j = 0; j < transitive_interfaces->length(); j++) { |
duke@435 | 755 | oop e = transitive_interfaces->obj_at(j); |
duke@435 | 756 | guarantee(e->is_klass() && Klass::cast(klassOop(e))->is_interface(), "invalid transitive interface"); |
duke@435 | 757 | } |
duke@435 | 758 | |
duke@435 | 759 | // Verify methods |
duke@435 | 760 | objArrayOop methods = ik->methods(); |
duke@435 | 761 | guarantee(methods->is_perm(), "should be in permspace"); |
duke@435 | 762 | guarantee(methods->is_objArray(), "should be obj array"); |
duke@435 | 763 | for (j = 0; j < methods->length(); j++) { |
duke@435 | 764 | guarantee(methods->obj_at(j)->is_method(), "non-method in methods array"); |
duke@435 | 765 | } |
duke@435 | 766 | for (j = 0; j < methods->length() - 1; j++) { |
duke@435 | 767 | methodOop m1 = methodOop(methods->obj_at(j)); |
duke@435 | 768 | methodOop m2 = methodOop(methods->obj_at(j + 1)); |
duke@435 | 769 | guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
duke@435 | 770 | } |
duke@435 | 771 | |
duke@435 | 772 | // Verify method ordering |
duke@435 | 773 | typeArrayOop method_ordering = ik->method_ordering(); |
duke@435 | 774 | guarantee(method_ordering->is_perm(), "should be in permspace"); |
duke@435 | 775 | guarantee(method_ordering->is_typeArray(), "should be type array"); |
duke@435 | 776 | int length = method_ordering->length(); |
duke@435 | 777 | if (JvmtiExport::can_maintain_original_method_order()) { |
duke@435 | 778 | guarantee(length == methods->length(), "invalid method ordering length"); |
duke@435 | 779 | jlong sum = 0; |
duke@435 | 780 | for (j = 0; j < length; j++) { |
duke@435 | 781 | int original_index = method_ordering->int_at(j); |
duke@435 | 782 | guarantee(original_index >= 0 && original_index < length, "invalid method ordering index"); |
duke@435 | 783 | sum += original_index; |
duke@435 | 784 | } |
duke@435 | 785 | // Verify sum of indices 0,1,...,length-1 |
duke@435 | 786 | guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum"); |
duke@435 | 787 | } else { |
duke@435 | 788 | guarantee(length == 0, "invalid method ordering length"); |
duke@435 | 789 | } |
duke@435 | 790 | |
duke@435 | 791 | // Verify JNI static field identifiers |
duke@435 | 792 | if (ik->jni_ids() != NULL) { |
duke@435 | 793 | ik->jni_ids()->verify(ik->as_klassOop()); |
duke@435 | 794 | } |
duke@435 | 795 | |
duke@435 | 796 | // Verify other fields |
duke@435 | 797 | if (ik->array_klasses() != NULL) { |
duke@435 | 798 | guarantee(ik->array_klasses()->is_perm(), "should be in permspace"); |
duke@435 | 799 | guarantee(ik->array_klasses()->is_klass(), "should be klass"); |
duke@435 | 800 | } |
duke@435 | 801 | guarantee(ik->fields()->is_perm(), "should be in permspace"); |
duke@435 | 802 | guarantee(ik->fields()->is_typeArray(), "should be type array"); |
duke@435 | 803 | guarantee(ik->constants()->is_perm(), "should be in permspace"); |
duke@435 | 804 | guarantee(ik->constants()->is_constantPool(), "should be constant pool"); |
duke@435 | 805 | guarantee(ik->inner_classes()->is_perm(), "should be in permspace"); |
duke@435 | 806 | guarantee(ik->inner_classes()->is_typeArray(), "should be type array"); |
duke@435 | 807 | if (ik->source_file_name() != NULL) { |
duke@435 | 808 | guarantee(ik->source_file_name()->is_perm(), "should be in permspace"); |
duke@435 | 809 | guarantee(ik->source_file_name()->is_symbol(), "should be symbol"); |
duke@435 | 810 | } |
duke@435 | 811 | if (ik->source_debug_extension() != NULL) { |
duke@435 | 812 | guarantee(ik->source_debug_extension()->is_perm(), "should be in permspace"); |
duke@435 | 813 | guarantee(ik->source_debug_extension()->is_symbol(), "should be symbol"); |
duke@435 | 814 | } |
duke@435 | 815 | if (ik->protection_domain() != NULL) { |
duke@435 | 816 | guarantee(ik->protection_domain()->is_oop(), "should be oop"); |
duke@435 | 817 | } |
jrose@866 | 818 | if (ik->host_klass() != NULL) { |
jrose@866 | 819 | guarantee(ik->host_klass()->is_oop(), "should be oop"); |
jrose@866 | 820 | } |
duke@435 | 821 | if (ik->signers() != NULL) { |
duke@435 | 822 | guarantee(ik->signers()->is_objArray(), "should be obj array"); |
duke@435 | 823 | } |
duke@435 | 824 | if (ik->generic_signature() != NULL) { |
duke@435 | 825 | guarantee(ik->generic_signature()->is_perm(), "should be in permspace"); |
duke@435 | 826 | guarantee(ik->generic_signature()->is_symbol(), "should be symbol"); |
duke@435 | 827 | } |
duke@435 | 828 | if (ik->class_annotations() != NULL) { |
duke@435 | 829 | guarantee(ik->class_annotations()->is_typeArray(), "should be type array"); |
duke@435 | 830 | } |
duke@435 | 831 | if (ik->fields_annotations() != NULL) { |
duke@435 | 832 | guarantee(ik->fields_annotations()->is_objArray(), "should be obj array"); |
duke@435 | 833 | } |
duke@435 | 834 | if (ik->methods_annotations() != NULL) { |
duke@435 | 835 | guarantee(ik->methods_annotations()->is_objArray(), "should be obj array"); |
duke@435 | 836 | } |
duke@435 | 837 | if (ik->methods_parameter_annotations() != NULL) { |
duke@435 | 838 | guarantee(ik->methods_parameter_annotations()->is_objArray(), "should be obj array"); |
duke@435 | 839 | } |
duke@435 | 840 | if (ik->methods_default_annotations() != NULL) { |
duke@435 | 841 | guarantee(ik->methods_default_annotations()->is_objArray(), "should be obj array"); |
duke@435 | 842 | } |
duke@435 | 843 | } |
duke@435 | 844 | } |
duke@435 | 845 | |
duke@435 | 846 | |
duke@435 | 847 | bool instanceKlassKlass::oop_partially_loaded(oop obj) const { |
duke@435 | 848 | assert(obj->is_klass(), "object must be klass"); |
duke@435 | 849 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 850 | assert(ik->oop_is_instance(), "object must be instanceKlass"); |
duke@435 | 851 | return ik->transitive_interfaces() == (objArrayOop) obj; // Check whether transitive_interfaces points to self |
duke@435 | 852 | } |
duke@435 | 853 | |
duke@435 | 854 | |
duke@435 | 855 | // The transitive_interfaces is the last field set when loading an object. |
duke@435 | 856 | void instanceKlassKlass::oop_set_partially_loaded(oop obj) { |
duke@435 | 857 | assert(obj->is_klass(), "object must be klass"); |
duke@435 | 858 | instanceKlass* ik = instanceKlass::cast(klassOop(obj)); |
duke@435 | 859 | // Set the layout helper to a place-holder value, until fuller initialization. |
duke@435 | 860 | // (This allows asserts in oop_is_instance to succeed.) |
duke@435 | 861 | ik->set_layout_helper(Klass::instance_layout_helper(0, true)); |
duke@435 | 862 | assert(ik->oop_is_instance(), "object must be instanceKlass"); |
duke@435 | 863 | assert(ik->transitive_interfaces() == NULL, "just checking"); |
duke@435 | 864 | ik->set_transitive_interfaces((objArrayOop) obj); // Temporarily set transitive_interfaces to point to self |
duke@435 | 865 | } |