Thu, 07 Apr 2011 09:53:20 -0700
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
Summary: A referent object that is only weakly reachable at the start of concurrent marking but is re-attached to the strongly reachable object graph during marking may not be marked as live. This can cause the reference object to be processed prematurely and leave dangling pointers to the referent object. Implement a read barrier for the java.lang.ref.Reference::referent field by intrinsifying the Reference.get() method, and intercepting accesses though JNI, reflection, and Unsafe, so that when a non-null referent object is read it is also logged in an SATB buffer.
Reviewed-by: kvn, iveresov, never, tonyp, dholmes
1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "gc_implementation/shared/markSweep.inline.hpp"
29 #include "memory/gcLocker.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "memory/universe.inline.hpp"
32 #include "oops/instanceKlass.hpp"
33 #include "oops/klassOop.hpp"
34 #include "oops/klassVtable.hpp"
35 #include "oops/methodOop.hpp"
36 #include "oops/objArrayOop.hpp"
37 #include "oops/oop.inline.hpp"
38 #include "prims/jvmtiRedefineClassesTrace.hpp"
39 #include "runtime/arguments.hpp"
40 #include "runtime/handles.inline.hpp"
41 #include "utilities/copy.hpp"
43 inline instanceKlass* klassVtable::ik() const {
44 Klass* k = _klass()->klass_part();
45 assert(k->oop_is_instance(), "not an instanceKlass");
46 return (instanceKlass*)k;
47 }
50 // this function computes the vtable size (including the size needed for miranda
51 // methods) and the number of miranda methods in this class
52 // Note on Miranda methods: Let's say there is a class C that implements
53 // interface I. Let's say there is a method m in I that neither C nor any
54 // of its super classes implement (i.e there is no method of any access, with
55 // the same name and signature as m), then m is a Miranda method which is
56 // entered as a public abstract method in C's vtable. From then on it should
57 // treated as any other public method in C for method over-ride purposes.
58 void klassVtable::compute_vtable_size_and_num_mirandas(int &vtable_length,
59 int &num_miranda_methods,
60 klassOop super,
61 objArrayOop methods,
62 AccessFlags class_flags,
63 Handle classloader,
64 Symbol* classname,
65 objArrayOop local_interfaces,
66 TRAPS
67 ) {
69 No_Safepoint_Verifier nsv;
71 // set up default result values
72 vtable_length = 0;
73 num_miranda_methods = 0;
75 // start off with super's vtable length
76 instanceKlass* sk = (instanceKlass*)super->klass_part();
77 vtable_length = super == NULL ? 0 : sk->vtable_length();
79 // go thru each method in the methods table to see if it needs a new entry
80 int len = methods->length();
81 for (int i = 0; i < len; i++) {
82 assert(methods->obj_at(i)->is_method(), "must be a methodOop");
83 methodHandle mh(THREAD, methodOop(methods->obj_at(i)));
85 if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, THREAD)) {
86 vtable_length += vtableEntry::size(); // we need a new entry
87 }
88 }
90 // compute the number of mirandas methods that must be added to the end
91 num_miranda_methods = get_num_mirandas(super, methods, local_interfaces);
92 vtable_length += (num_miranda_methods * vtableEntry::size());
94 if (Universe::is_bootstrapping() && vtable_length == 0) {
95 // array classes don't have their superclass set correctly during
96 // bootstrapping
97 vtable_length = Universe::base_vtable_size();
98 }
100 if (super == NULL && !Universe::is_bootstrapping() &&
101 vtable_length != Universe::base_vtable_size()) {
102 // Someone is attempting to redefine java.lang.Object incorrectly. The
103 // only way this should happen is from
104 // SystemDictionary::resolve_from_stream(), which will detect this later
105 // and throw a security exception. So don't assert here to let
106 // the exception occur.
107 vtable_length = Universe::base_vtable_size();
108 }
109 assert(super != NULL || vtable_length == Universe::base_vtable_size(),
110 "bad vtable size for class Object");
111 assert(vtable_length % vtableEntry::size() == 0, "bad vtable length");
112 assert(vtable_length >= Universe::base_vtable_size(), "vtable too small");
113 }
115 int klassVtable::index_of(methodOop m, int len) const {
116 assert(m->vtable_index() >= 0, "do not ask this of non-vtable methods");
117 return m->vtable_index();
118 }
120 int klassVtable::initialize_from_super(KlassHandle super) {
121 if (super.is_null()) {
122 return 0;
123 } else {
124 // copy methods from superKlass
125 // can't inherit from array class, so must be instanceKlass
126 assert(super->oop_is_instance(), "must be instance klass");
127 instanceKlass* sk = (instanceKlass*)super()->klass_part();
128 klassVtable* superVtable = sk->vtable();
129 assert(superVtable->length() <= _length, "vtable too short");
130 #ifdef ASSERT
131 superVtable->verify(tty, true);
132 #endif
133 superVtable->copy_vtable_to(table());
134 #ifndef PRODUCT
135 if (PrintVtables && Verbose) {
136 ResourceMark rm;
137 tty->print_cr("copy vtable from %s to %s size %d", sk->internal_name(), klass()->internal_name(), _length);
138 }
139 #endif
140 return superVtable->length();
141 }
142 }
144 // Revised lookup semantics introduced 1.3 (Kestral beta)
145 void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) {
147 // Note: Arrays can have intermediate array supers. Use java_super to skip them.
148 KlassHandle super (THREAD, klass()->java_super());
149 int nofNewEntries = 0;
152 if (PrintVtables && !klass()->oop_is_array()) {
153 ResourceMark rm(THREAD);
154 tty->print_cr("Initializing: %s", _klass->name()->as_C_string());
155 }
157 #ifdef ASSERT
158 oop* end_of_obj = (oop*)_klass() + _klass()->size();
159 oop* end_of_vtable = (oop*)&table()[_length];
160 assert(end_of_vtable <= end_of_obj, "vtable extends beyond end");
161 #endif
163 if (Universe::is_bootstrapping()) {
164 // just clear everything
165 for (int i = 0; i < _length; i++) table()[i].clear();
166 return;
167 }
169 int super_vtable_len = initialize_from_super(super);
170 if (klass()->oop_is_array()) {
171 assert(super_vtable_len == _length, "arrays shouldn't introduce new methods");
172 } else {
173 assert(_klass->oop_is_instance(), "must be instanceKlass");
175 objArrayHandle methods(THREAD, ik()->methods());
176 int len = methods()->length();
177 int initialized = super_vtable_len;
179 // update_inherited_vtable can stop for gc - ensure using handles
180 for (int i = 0; i < len; i++) {
181 HandleMark hm(THREAD);
182 assert(methods()->obj_at(i)->is_method(), "must be a methodOop");
183 methodHandle mh(THREAD, (methodOop)methods()->obj_at(i));
185 bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, checkconstraints, CHECK);
187 if (needs_new_entry) {
188 put_method_at(mh(), initialized);
189 mh()->set_vtable_index(initialized); // set primary vtable index
190 initialized++;
191 }
192 }
194 // add miranda methods; it will also update the value of initialized
195 fill_in_mirandas(initialized);
197 // In class hierarchies where the accessibility is not increasing (i.e., going from private ->
198 // package_private -> publicprotected), the vtable might actually be smaller than our initial
199 // calculation.
200 assert(initialized <= _length, "vtable initialization failed");
201 for(;initialized < _length; initialized++) {
202 put_method_at(NULL, initialized);
203 }
204 NOT_PRODUCT(verify(tty, true));
205 }
206 }
208 // Called for cases where a method does not override its superclass' vtable entry
209 // For bytecodes not produced by javac together it is possible that a method does not override
210 // the superclass's method, but might indirectly override a super-super class's vtable entry
211 // If none found, return a null superk, else return the superk of the method this does override
212 instanceKlass* klassVtable::find_transitive_override(instanceKlass* initialsuper, methodHandle target_method,
213 int vtable_index, Handle target_loader, Symbol* target_classname, Thread * THREAD) {
214 instanceKlass* superk = initialsuper;
215 while (superk != NULL && superk->super() != NULL) {
216 instanceKlass* supersuperklass = instanceKlass::cast(superk->super());
217 klassVtable* ssVtable = supersuperklass->vtable();
218 if (vtable_index < ssVtable->length()) {
219 methodOop super_method = ssVtable->method_at(vtable_index);
220 #ifndef PRODUCT
221 Symbol* name= target_method()->name();
222 Symbol* signature = target_method()->signature();
223 assert(super_method->name() == name && super_method->signature() == signature, "vtable entry name/sig mismatch");
224 #endif
225 if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {
226 #ifndef PRODUCT
227 if (PrintVtables && Verbose) {
228 ResourceMark rm(THREAD);
229 tty->print("transitive overriding superclass %s with %s::%s index %d, original flags: ",
230 supersuperklass->internal_name(),
231 _klass->internal_name(), (target_method() != NULL) ?
232 target_method()->name()->as_C_string() : "<NULL>", vtable_index);
233 super_method->access_flags().print_on(tty);
234 tty->print("overriders flags: ");
235 target_method->access_flags().print_on(tty);
236 tty->cr();
237 }
238 #endif /*PRODUCT*/
239 break; // return found superk
240 }
241 } else {
242 // super class has no vtable entry here, stop transitive search
243 superk = (instanceKlass*)NULL;
244 break;
245 }
246 // if no override found yet, continue to search up
247 superk = instanceKlass::cast(superk->super());
248 }
250 return superk;
251 }
254 // Update child's copy of super vtable for overrides
255 // OR return true if a new vtable entry is required
256 // Only called for instanceKlass's, i.e. not for arrays
257 // If that changed, could not use _klass as handle for klass
258 bool klassVtable::update_inherited_vtable(instanceKlass* klass, methodHandle target_method, int super_vtable_len,
259 bool checkconstraints, TRAPS) {
260 ResourceMark rm;
261 bool allocate_new = true;
262 assert(klass->oop_is_instance(), "must be instanceKlass");
264 // Initialize the method's vtable index to "nonvirtual".
265 // If we allocate a vtable entry, we will update it to a non-negative number.
266 target_method()->set_vtable_index(methodOopDesc::nonvirtual_vtable_index);
268 // Static and <init> methods are never in
269 if (target_method()->is_static() || target_method()->name() == vmSymbols::object_initializer_name()) {
270 return false;
271 }
273 if (klass->is_final() || target_method()->is_final()) {
274 // a final method never needs a new entry; final methods can be statically
275 // resolved and they have to be present in the vtable only if they override
276 // a super's method, in which case they re-use its entry
277 allocate_new = false;
278 }
280 // we need a new entry if there is no superclass
281 if (klass->super() == NULL) {
282 return allocate_new;
283 }
285 // private methods always have a new entry in the vtable
286 // specification interpretation since classic has
287 // private methods not overriding
288 if (target_method()->is_private()) {
289 return allocate_new;
290 }
292 // search through the vtable and update overridden entries
293 // Since check_signature_loaders acquires SystemDictionary_lock
294 // which can block for gc, once we are in this loop, use handles
295 // For classfiles built with >= jdk7, we now look for transitive overrides
297 Symbol* name = target_method()->name();
298 Symbol* signature = target_method()->signature();
299 Handle target_loader(THREAD, _klass->class_loader());
300 Symbol* target_classname = _klass->name();
301 for(int i = 0; i < super_vtable_len; i++) {
302 methodOop super_method = method_at(i);
303 // Check if method name matches
304 if (super_method->name() == name && super_method->signature() == signature) {
306 // get super_klass for method_holder for the found method
307 instanceKlass* super_klass = instanceKlass::cast(super_method->method_holder());
309 if ((super_klass->is_override(super_method, target_loader, target_classname, THREAD)) ||
310 ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
311 && ((super_klass = find_transitive_override(super_klass, target_method, i, target_loader,
312 target_classname, THREAD)) != (instanceKlass*)NULL))) {
313 // overriding, so no new entry
314 allocate_new = false;
316 if (checkconstraints) {
317 // Override vtable entry if passes loader constraint check
318 // if loader constraint checking requested
319 // No need to visit his super, since he and his super
320 // have already made any needed loader constraints.
321 // Since loader constraints are transitive, it is enough
322 // to link to the first super, and we get all the others.
323 Handle super_loader(THREAD, super_klass->class_loader());
325 if (target_loader() != super_loader()) {
326 ResourceMark rm(THREAD);
327 char* failed_type_name =
328 SystemDictionary::check_signature_loaders(signature, target_loader,
329 super_loader, true,
330 CHECK_(false));
331 if (failed_type_name != NULL) {
332 const char* msg = "loader constraint violation: when resolving "
333 "overridden method \"%s\" the class loader (instance"
334 " of %s) of the current class, %s, and its superclass loader "
335 "(instance of %s), have different Class objects for the type "
336 "%s used in the signature";
337 char* sig = target_method()->name_and_sig_as_C_string();
338 const char* loader1 = SystemDictionary::loader_name(target_loader());
339 char* current = _klass->name()->as_C_string();
340 const char* loader2 = SystemDictionary::loader_name(super_loader());
341 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
342 strlen(current) + strlen(loader2) + strlen(failed_type_name);
343 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
344 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
345 failed_type_name);
346 THROW_MSG_(vmSymbols::java_lang_LinkageError(), buf, false);
347 }
348 }
349 }
351 put_method_at(target_method(), i);
352 target_method()->set_vtable_index(i);
353 #ifndef PRODUCT
354 if (PrintVtables && Verbose) {
355 tty->print("overriding with %s::%s index %d, original flags: ",
356 _klass->internal_name(), (target_method() != NULL) ?
357 target_method()->name()->as_C_string() : "<NULL>", i);
358 super_method->access_flags().print_on(tty);
359 tty->print("overriders flags: ");
360 target_method->access_flags().print_on(tty);
361 tty->cr();
362 }
363 #endif /*PRODUCT*/
364 } else {
365 // allocate_new = true; default. We might override one entry,
366 // but not override another. Once we override one, not need new
367 #ifndef PRODUCT
368 if (PrintVtables && Verbose) {
369 tty->print("NOT overriding with %s::%s index %d, original flags: ",
370 _klass->internal_name(), (target_method() != NULL) ?
371 target_method()->name()->as_C_string() : "<NULL>", i);
372 super_method->access_flags().print_on(tty);
373 tty->print("overriders flags: ");
374 target_method->access_flags().print_on(tty);
375 tty->cr();
376 }
377 #endif /*PRODUCT*/
378 }
379 }
380 }
381 return allocate_new;
382 }
384 void klassVtable::put_method_at(methodOop m, int index) {
385 assert(m->is_oop_or_null(), "Not an oop or null");
386 #ifndef PRODUCT
387 if (PrintVtables && Verbose) {
388 ResourceMark rm;
389 tty->print_cr("adding %s::%s at index %d", _klass->internal_name(),
390 (m != NULL) ? m->name()->as_C_string() : "<NULL>", index);
391 }
392 assert(unchecked_method_at(index)->is_oop_or_null(), "Not an oop or null");
393 #endif
394 table()[index].set(m);
395 }
397 // Find out if a method "m" with superclass "super", loader "classloader" and
398 // name "classname" needs a new vtable entry. Let P be a class package defined
399 // by "classloader" and "classname".
400 // NOTE: The logic used here is very similar to the one used for computing
401 // the vtables indices for a method. We cannot directly use that function because,
402 // we allocate the instanceKlass at load time, and that requires that the
403 // superclass has been loaded.
404 // However, the vtable entries are filled in at link time, and therefore
405 // the superclass' vtable may not yet have been filled in.
406 bool klassVtable::needs_new_vtable_entry(methodHandle target_method,
407 klassOop super,
408 Handle classloader,
409 Symbol* classname,
410 AccessFlags class_flags,
411 TRAPS) {
412 if ((class_flags.is_final() || target_method()->is_final()) ||
413 // a final method never needs a new entry; final methods can be statically
414 // resolved and they have to be present in the vtable only if they override
415 // a super's method, in which case they re-use its entry
416 (target_method()->is_static()) ||
417 // static methods don't need to be in vtable
418 (target_method()->name() == vmSymbols::object_initializer_name())
419 // <init> is never called dynamically-bound
420 ) {
421 return false;
422 }
424 // we need a new entry if there is no superclass
425 if (super == NULL) {
426 return true;
427 }
429 // private methods always have a new entry in the vtable
430 // specification interpretation since classic has
431 // private methods not overriding
432 if (target_method()->is_private()) {
433 return true;
434 }
436 // search through the super class hierarchy to see if we need
437 // a new entry
438 ResourceMark rm;
439 Symbol* name = target_method()->name();
440 Symbol* signature = target_method()->signature();
441 klassOop k = super;
442 methodOop super_method = NULL;
443 instanceKlass *holder = NULL;
444 methodOop recheck_method = NULL;
445 while (k != NULL) {
446 // lookup through the hierarchy for a method with matching name and sign.
447 super_method = instanceKlass::cast(k)->lookup_method(name, signature);
448 if (super_method == NULL) {
449 break; // we still have to search for a matching miranda method
450 }
451 // get the class holding the matching method
452 // make sure you use that class for is_override
453 instanceKlass* superk = instanceKlass::cast(super_method->method_holder());
454 // we want only instance method matches
455 // pretend private methods are not in the super vtable
456 // since we do override around them: e.g. a.m pub/b.m private/c.m pub,
457 // ignore private, c.m pub does override a.m pub
458 // For classes that were not javac'd together, we also do transitive overriding around
459 // methods that have less accessibility
460 if ((!super_method->is_static()) &&
461 (!super_method->is_private())) {
462 if (superk->is_override(super_method, classloader, classname, THREAD)) {
463 return false;
464 // else keep looking for transitive overrides
465 }
466 }
468 // Start with lookup result and continue to search up
469 k = superk->super(); // haven't found an override match yet; continue to look
470 }
472 // if the target method is public or protected it may have a matching
473 // miranda method in the super, whose entry it should re-use.
474 // Actually, to handle cases that javac would not generate, we need
475 // this check for all access permissions.
476 instanceKlass *sk = instanceKlass::cast(super);
477 if (sk->has_miranda_methods()) {
478 if (sk->lookup_method_in_all_interfaces(name, signature) != NULL) {
479 return false; // found a matching miranda; we do not need a new entry
480 }
481 }
482 return true; // found no match; we need a new entry
483 }
485 // Support for miranda methods
487 // get the vtable index of a miranda method with matching "name" and "signature"
488 int klassVtable::index_of_miranda(Symbol* name, Symbol* signature) {
489 // search from the bottom, might be faster
490 for (int i = (length() - 1); i >= 0; i--) {
491 methodOop m = table()[i].method();
492 if (is_miranda_entry_at(i) &&
493 m->name() == name && m->signature() == signature) {
494 return i;
495 }
496 }
497 return methodOopDesc::invalid_vtable_index;
498 }
500 // check if an entry is miranda
501 bool klassVtable::is_miranda_entry_at(int i) {
502 methodOop m = method_at(i);
503 klassOop method_holder = m->method_holder();
504 instanceKlass *mhk = instanceKlass::cast(method_holder);
506 // miranda methods are interface methods in a class's vtable
507 if (mhk->is_interface()) {
508 assert(m->is_public() && m->is_abstract(), "should be public and abstract");
509 assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
510 assert(is_miranda(m, ik()->methods(), ik()->super()), "should be a miranda_method");
511 return true;
512 }
513 return false;
514 }
516 // check if a method is a miranda method, given a class's methods table and it's super
517 // the caller must make sure that the method belongs to an interface implemented by the class
518 bool klassVtable::is_miranda(methodOop m, objArrayOop class_methods, klassOop super) {
519 Symbol* name = m->name();
520 Symbol* signature = m->signature();
521 if (instanceKlass::find_method(class_methods, name, signature) == NULL) {
522 // did not find it in the method table of the current class
523 if (super == NULL) {
524 // super doesn't exist
525 return true;
526 }
528 methodOop mo = instanceKlass::cast(super)->lookup_method(name, signature);
529 if (mo == NULL || mo->access_flags().is_private() ) {
530 // super class hierarchy does not implement it or protection is different
531 return true;
532 }
533 }
535 return false;
536 }
538 void klassVtable::add_new_mirandas_to_list(GrowableArray<methodOop>* list_of_current_mirandas,
539 objArrayOop current_interface_methods,
540 objArrayOop class_methods,
541 klassOop super) {
542 // iterate thru the current interface's method to see if it a miranda
543 int num_methods = current_interface_methods->length();
544 for (int i = 0; i < num_methods; i++) {
545 methodOop im = methodOop(current_interface_methods->obj_at(i));
546 bool is_duplicate = false;
547 int num_of_current_mirandas = list_of_current_mirandas->length();
548 // check for duplicate mirandas in different interfaces we implement
549 for (int j = 0; j < num_of_current_mirandas; j++) {
550 methodOop miranda = list_of_current_mirandas->at(j);
551 if ((im->name() == miranda->name()) &&
552 (im->signature() == miranda->signature())) {
553 is_duplicate = true;
554 break;
555 }
556 }
558 if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
559 if (is_miranda(im, class_methods, super)) { // is it a miranda at all?
560 instanceKlass *sk = instanceKlass::cast(super);
561 // check if it is a duplicate of a super's miranda
562 if (sk->lookup_method_in_all_interfaces(im->name(), im->signature()) == NULL) {
563 list_of_current_mirandas->append(im);
564 }
565 }
566 }
567 }
568 }
570 void klassVtable::get_mirandas(GrowableArray<methodOop>* mirandas,
571 klassOop super, objArrayOop class_methods,
572 objArrayOop local_interfaces) {
573 assert((mirandas->length() == 0) , "current mirandas must be 0");
575 // iterate thru the local interfaces looking for a miranda
576 int num_local_ifs = local_interfaces->length();
577 for (int i = 0; i < num_local_ifs; i++) {
578 instanceKlass *ik = instanceKlass::cast(klassOop(local_interfaces->obj_at(i)));
579 add_new_mirandas_to_list(mirandas, ik->methods(), class_methods, super);
580 // iterate thru each local's super interfaces
581 objArrayOop super_ifs = ik->transitive_interfaces();
582 int num_super_ifs = super_ifs->length();
583 for (int j = 0; j < num_super_ifs; j++) {
584 instanceKlass *sik = instanceKlass::cast(klassOop(super_ifs->obj_at(j)));
585 add_new_mirandas_to_list(mirandas, sik->methods(), class_methods, super);
586 }
587 }
588 }
590 // get number of mirandas
591 int klassVtable::get_num_mirandas(klassOop super, objArrayOop class_methods, objArrayOop local_interfaces) {
592 ResourceMark rm;
593 GrowableArray<methodOop>* mirandas = new GrowableArray<methodOop>(20);
594 get_mirandas(mirandas, super, class_methods, local_interfaces);
595 return mirandas->length();
596 }
598 // fill in mirandas
599 void klassVtable::fill_in_mirandas(int& initialized) {
600 ResourceMark rm;
601 GrowableArray<methodOop>* mirandas = new GrowableArray<methodOop>(20);
602 instanceKlass *this_ik = ik();
603 get_mirandas(mirandas, this_ik->super(), this_ik->methods(), this_ik->local_interfaces());
604 int num_mirandas = mirandas->length();
605 for (int i = 0; i < num_mirandas; i++) {
606 put_method_at(mirandas->at(i), initialized);
607 initialized++;
608 }
609 }
611 void klassVtable::copy_vtable_to(vtableEntry* start) {
612 Copy::disjoint_words((HeapWord*)table(), (HeapWord*)start, _length * vtableEntry::size());
613 }
615 void klassVtable::adjust_method_entries(methodOop* old_methods, methodOop* new_methods,
616 int methods_length, bool * trace_name_printed) {
617 // search the vtable for uses of either obsolete or EMCP methods
618 for (int j = 0; j < methods_length; j++) {
619 methodOop old_method = old_methods[j];
620 methodOop new_method = new_methods[j];
622 // In the vast majority of cases we could get the vtable index
623 // by using: old_method->vtable_index()
624 // However, there are rare cases, eg. sun.awt.X11.XDecoratedPeer.getX()
625 // in sun.awt.X11.XFramePeer where methods occur more than once in the
626 // vtable, so, alas, we must do an exhaustive search.
627 for (int index = 0; index < length(); index++) {
628 if (unchecked_method_at(index) == old_method) {
629 put_method_at(new_method, index);
631 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
632 if (!(*trace_name_printed)) {
633 // RC_TRACE_MESG macro has an embedded ResourceMark
634 RC_TRACE_MESG(("adjust: name=%s",
635 Klass::cast(old_method->method_holder())->external_name()));
636 *trace_name_printed = true;
637 }
638 // RC_TRACE macro has an embedded ResourceMark
639 RC_TRACE(0x00100000, ("vtable method update: %s(%s)",
640 new_method->name()->as_C_string(),
641 new_method->signature()->as_C_string()));
642 }
643 }
644 }
645 }
646 }
649 // Garbage collection
650 void klassVtable::oop_follow_contents() {
651 int len = length();
652 for (int i = 0; i < len; i++) {
653 MarkSweep::mark_and_push(adr_method_at(i));
654 }
655 }
657 #ifndef SERIALGC
658 void klassVtable::oop_follow_contents(ParCompactionManager* cm) {
659 int len = length();
660 for (int i = 0; i < len; i++) {
661 PSParallelCompact::mark_and_push(cm, adr_method_at(i));
662 }
663 }
664 #endif // SERIALGC
666 void klassVtable::oop_adjust_pointers() {
667 int len = length();
668 for (int i = 0; i < len; i++) {
669 MarkSweep::adjust_pointer(adr_method_at(i));
670 }
671 }
673 #ifndef SERIALGC
674 void klassVtable::oop_update_pointers(ParCompactionManager* cm) {
675 const int n = length();
676 for (int i = 0; i < n; i++) {
677 PSParallelCompact::adjust_pointer(adr_method_at(i));
678 }
679 }
680 #endif // SERIALGC
682 // Iterators
683 void klassVtable::oop_oop_iterate(OopClosure* blk) {
684 int len = length();
685 for (int i = 0; i < len; i++) {
686 blk->do_oop(adr_method_at(i));
687 }
688 }
690 void klassVtable::oop_oop_iterate_m(OopClosure* blk, MemRegion mr) {
691 int len = length();
692 int i;
693 for (i = 0; i < len; i++) {
694 if ((HeapWord*)adr_method_at(i) >= mr.start()) break;
695 }
696 for (; i < len; i++) {
697 oop* adr = adr_method_at(i);
698 if ((HeapWord*)adr < mr.end()) blk->do_oop(adr);
699 }
700 }
702 //-----------------------------------------------------------------------------------------
703 // Itable code
705 // Initialize a itableMethodEntry
706 void itableMethodEntry::initialize(methodOop m) {
707 if (m == NULL) return;
709 _method = m;
710 }
712 klassItable::klassItable(instanceKlassHandle klass) {
713 _klass = klass;
715 if (klass->itable_length() > 0) {
716 itableOffsetEntry* offset_entry = (itableOffsetEntry*)klass->start_of_itable();
717 if (offset_entry != NULL && offset_entry->interface_klass() != NULL) { // Check that itable is initialized
718 // First offset entry points to the first method_entry
719 intptr_t* method_entry = (intptr_t *)(((address)klass->as_klassOop()) + offset_entry->offset());
720 intptr_t* end = klass->end_of_itable();
722 _table_offset = (intptr_t*)offset_entry - (intptr_t*)klass->as_klassOop();
723 _size_offset_table = (method_entry - ((intptr_t*)offset_entry)) / itableOffsetEntry::size();
724 _size_method_table = (end - method_entry) / itableMethodEntry::size();
725 assert(_table_offset >= 0 && _size_offset_table >= 0 && _size_method_table >= 0, "wrong computation");
726 return;
727 }
728 }
730 // The length of the itable was either zero, or it has not yet been initialized.
731 _table_offset = 0;
732 _size_offset_table = 0;
733 _size_method_table = 0;
734 }
736 // Garbage Collection
738 void klassItable::oop_follow_contents() {
739 // offset table
740 itableOffsetEntry* ioe = offset_entry(0);
741 for(int i = 0; i < _size_offset_table; i++) {
742 MarkSweep::mark_and_push((oop*)&ioe->_interface);
743 ioe++;
744 }
746 // method table
747 itableMethodEntry* ime = method_entry(0);
748 for(int j = 0; j < _size_method_table; j++) {
749 MarkSweep::mark_and_push((oop*)&ime->_method);
750 ime++;
751 }
752 }
754 #ifndef SERIALGC
755 void klassItable::oop_follow_contents(ParCompactionManager* cm) {
756 // offset table
757 itableOffsetEntry* ioe = offset_entry(0);
758 for(int i = 0; i < _size_offset_table; i++) {
759 PSParallelCompact::mark_and_push(cm, (oop*)&ioe->_interface);
760 ioe++;
761 }
763 // method table
764 itableMethodEntry* ime = method_entry(0);
765 for(int j = 0; j < _size_method_table; j++) {
766 PSParallelCompact::mark_and_push(cm, (oop*)&ime->_method);
767 ime++;
768 }
769 }
770 #endif // SERIALGC
772 void klassItable::oop_adjust_pointers() {
773 // offset table
774 itableOffsetEntry* ioe = offset_entry(0);
775 for(int i = 0; i < _size_offset_table; i++) {
776 MarkSweep::adjust_pointer((oop*)&ioe->_interface);
777 ioe++;
778 }
780 // method table
781 itableMethodEntry* ime = method_entry(0);
782 for(int j = 0; j < _size_method_table; j++) {
783 MarkSweep::adjust_pointer((oop*)&ime->_method);
784 ime++;
785 }
786 }
788 #ifndef SERIALGC
789 void klassItable::oop_update_pointers(ParCompactionManager* cm) {
790 // offset table
791 itableOffsetEntry* ioe = offset_entry(0);
792 for(int i = 0; i < _size_offset_table; i++) {
793 PSParallelCompact::adjust_pointer((oop*)&ioe->_interface);
794 ioe++;
795 }
797 // method table
798 itableMethodEntry* ime = method_entry(0);
799 for(int j = 0; j < _size_method_table; j++) {
800 PSParallelCompact::adjust_pointer((oop*)&ime->_method);
801 ime++;
802 }
803 }
804 #endif // SERIALGC
806 // Iterators
807 void klassItable::oop_oop_iterate(OopClosure* blk) {
808 // offset table
809 itableOffsetEntry* ioe = offset_entry(0);
810 for(int i = 0; i < _size_offset_table; i++) {
811 blk->do_oop((oop*)&ioe->_interface);
812 ioe++;
813 }
815 // method table
816 itableMethodEntry* ime = method_entry(0);
817 for(int j = 0; j < _size_method_table; j++) {
818 blk->do_oop((oop*)&ime->_method);
819 ime++;
820 }
821 }
823 void klassItable::oop_oop_iterate_m(OopClosure* blk, MemRegion mr) {
824 // offset table
825 itableOffsetEntry* ioe = offset_entry(0);
826 for(int i = 0; i < _size_offset_table; i++) {
827 oop* adr = (oop*)&ioe->_interface;
828 if (mr.contains(adr)) blk->do_oop(adr);
829 ioe++;
830 }
832 // method table
833 itableMethodEntry* ime = method_entry(0);
834 for(int j = 0; j < _size_method_table; j++) {
835 oop* adr = (oop*)&ime->_method;
836 if (mr.contains(adr)) blk->do_oop(adr);
837 ime++;
838 }
839 }
842 static int initialize_count = 0;
844 // Initialization
845 void klassItable::initialize_itable(bool checkconstraints, TRAPS) {
846 // Cannot be setup doing bootstrapping, interfaces don't have
847 // itables, and klass with only ones entry have empty itables
848 if (Universe::is_bootstrapping() ||
849 _klass->is_interface() ||
850 _klass->itable_length() == itableOffsetEntry::size()) return;
852 // There's alway an extra itable entry so we can null-terminate it.
853 guarantee(size_offset_table() >= 1, "too small");
854 int num_interfaces = size_offset_table() - 1;
855 if (num_interfaces > 0) {
856 if (TraceItables) tty->print_cr("%3d: Initializing itables for %s", ++initialize_count,
857 _klass->name()->as_C_string());
860 // Iterate through all interfaces
861 int i;
862 for(i = 0; i < num_interfaces; i++) {
863 itableOffsetEntry* ioe = offset_entry(i);
864 KlassHandle interf_h (THREAD, ioe->interface_klass());
865 assert(interf_h() != NULL && ioe->offset() != 0, "bad offset entry in itable");
866 initialize_itable_for_interface(ioe->offset(), interf_h, checkconstraints, CHECK);
867 }
869 }
870 // Check that the last entry is empty
871 itableOffsetEntry* ioe = offset_entry(size_offset_table() - 1);
872 guarantee(ioe->interface_klass() == NULL && ioe->offset() == 0, "terminator entry missing");
873 }
876 void klassItable::initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS) {
877 objArrayHandle methods(THREAD, instanceKlass::cast(interf_h())->methods());
878 int nof_methods = methods()->length();
879 HandleMark hm;
880 KlassHandle klass = _klass;
881 assert(nof_methods > 0, "at least one method must exist for interface to be in vtable");
882 Handle interface_loader (THREAD, instanceKlass::cast(interf_h())->class_loader());
883 int ime_num = 0;
885 // Skip first methodOop if it is a class initializer
886 int i = ((methodOop)methods()->obj_at(0))->is_static_initializer() ? 1 : 0;
888 // m, method_name, method_signature, klass reset each loop so they
889 // don't need preserving across check_signature_loaders call
890 // methods needs a handle in case of gc from check_signature_loaders
891 for(; i < nof_methods; i++) {
892 methodOop m = (methodOop)methods()->obj_at(i);
893 Symbol* method_name = m->name();
894 Symbol* method_signature = m->signature();
896 // This is same code as in Linkresolver::lookup_instance_method_in_klasses
897 methodOop target = klass->uncached_lookup_method(method_name, method_signature);
898 while (target != NULL && target->is_static()) {
899 // continue with recursive lookup through the superclass
900 klassOop super = Klass::cast(target->method_holder())->super();
901 target = (super == NULL) ? methodOop(NULL) : Klass::cast(super)->uncached_lookup_method(method_name, method_signature);
902 }
903 if (target == NULL || !target->is_public() || target->is_abstract()) {
904 // Entry do not resolve. Leave it empty
905 } else {
906 // Entry did resolve, check loader constraints before initializing
907 // if checkconstraints requested
908 methodHandle target_h (THREAD, target); // preserve across gc
909 if (checkconstraints) {
910 Handle method_holder_loader (THREAD, instanceKlass::cast(target->method_holder())->class_loader());
911 if (method_holder_loader() != interface_loader()) {
912 ResourceMark rm(THREAD);
913 char* failed_type_name =
914 SystemDictionary::check_signature_loaders(method_signature,
915 method_holder_loader,
916 interface_loader,
917 true, CHECK);
918 if (failed_type_name != NULL) {
919 const char* msg = "loader constraint violation in interface "
920 "itable initialization: when resolving method \"%s\" the class"
921 " loader (instance of %s) of the current class, %s, "
922 "and the class loader (instance of %s) for interface "
923 "%s have different Class objects for the type %s "
924 "used in the signature";
925 char* sig = target_h()->name_and_sig_as_C_string();
926 const char* loader1 = SystemDictionary::loader_name(method_holder_loader());
927 char* current = klass->name()->as_C_string();
928 const char* loader2 = SystemDictionary::loader_name(interface_loader());
929 char* iface = instanceKlass::cast(interf_h())->name()->as_C_string();
930 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
931 strlen(current) + strlen(loader2) + strlen(iface) +
932 strlen(failed_type_name);
933 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
934 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
935 iface, failed_type_name);
936 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
937 }
938 }
939 }
941 // ime may have moved during GC so recalculate address
942 itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target_h());
943 }
944 // Progress to next entry
945 ime_num++;
946 }
947 }
949 // Update entry for specific methodOop
950 void klassItable::initialize_with_method(methodOop m) {
951 itableMethodEntry* ime = method_entry(0);
952 for(int i = 0; i < _size_method_table; i++) {
953 if (ime->method() == m) {
954 ime->initialize(m);
955 }
956 ime++;
957 }
958 }
960 void klassItable::adjust_method_entries(methodOop* old_methods, methodOop* new_methods,
961 int methods_length, bool * trace_name_printed) {
962 // search the itable for uses of either obsolete or EMCP methods
963 for (int j = 0; j < methods_length; j++) {
964 methodOop old_method = old_methods[j];
965 methodOop new_method = new_methods[j];
966 itableMethodEntry* ime = method_entry(0);
968 // The itable can describe more than one interface and the same
969 // method signature can be specified by more than one interface.
970 // This means we have to do an exhaustive search to find all the
971 // old_method references.
972 for (int i = 0; i < _size_method_table; i++) {
973 if (ime->method() == old_method) {
974 ime->initialize(new_method);
976 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
977 if (!(*trace_name_printed)) {
978 // RC_TRACE_MESG macro has an embedded ResourceMark
979 RC_TRACE_MESG(("adjust: name=%s",
980 Klass::cast(old_method->method_holder())->external_name()));
981 *trace_name_printed = true;
982 }
983 // RC_TRACE macro has an embedded ResourceMark
984 RC_TRACE(0x00200000, ("itable method update: %s(%s)",
985 new_method->name()->as_C_string(),
986 new_method->signature()->as_C_string()));
987 }
988 break;
989 }
990 ime++;
991 }
992 }
993 }
996 // Setup
997 class InterfaceVisiterClosure : public StackObj {
998 public:
999 virtual void doit(klassOop intf, int method_count) = 0;
1000 };
1002 // Visit all interfaces with at-least one method (excluding <clinit>)
1003 void visit_all_interfaces(objArrayOop transitive_intf, InterfaceVisiterClosure *blk) {
1004 // Handle array argument
1005 for(int i = 0; i < transitive_intf->length(); i++) {
1006 klassOop intf = (klassOop)transitive_intf->obj_at(i);
1007 assert(Klass::cast(intf)->is_interface(), "sanity check");
1009 // Find no. of methods excluding a <clinit>
1010 int method_count = instanceKlass::cast(intf)->methods()->length();
1011 if (method_count > 0) {
1012 methodOop m = (methodOop)instanceKlass::cast(intf)->methods()->obj_at(0);
1013 assert(m != NULL && m->is_method(), "sanity check");
1014 if (m->name() == vmSymbols::object_initializer_name()) {
1015 method_count--;
1016 }
1017 }
1019 // Only count interfaces with at least one method
1020 if (method_count > 0) {
1021 blk->doit(intf, method_count);
1022 }
1023 }
1024 }
1026 class CountInterfacesClosure : public InterfaceVisiterClosure {
1027 private:
1028 int _nof_methods;
1029 int _nof_interfaces;
1030 public:
1031 CountInterfacesClosure() { _nof_methods = 0; _nof_interfaces = 0; }
1033 int nof_methods() const { return _nof_methods; }
1034 int nof_interfaces() const { return _nof_interfaces; }
1036 void doit(klassOop intf, int method_count) { _nof_methods += method_count; _nof_interfaces++; }
1037 };
1039 class SetupItableClosure : public InterfaceVisiterClosure {
1040 private:
1041 itableOffsetEntry* _offset_entry;
1042 itableMethodEntry* _method_entry;
1043 address _klass_begin;
1044 public:
1045 SetupItableClosure(address klass_begin, itableOffsetEntry* offset_entry, itableMethodEntry* method_entry) {
1046 _klass_begin = klass_begin;
1047 _offset_entry = offset_entry;
1048 _method_entry = method_entry;
1049 }
1051 itableMethodEntry* method_entry() const { return _method_entry; }
1053 void doit(klassOop intf, int method_count) {
1054 int offset = ((address)_method_entry) - _klass_begin;
1055 _offset_entry->initialize(intf, offset);
1056 _offset_entry++;
1057 _method_entry += method_count;
1058 }
1059 };
1061 int klassItable::compute_itable_size(objArrayHandle transitive_interfaces) {
1062 // Count no of interfaces and total number of interface methods
1063 CountInterfacesClosure cic;
1064 visit_all_interfaces(transitive_interfaces(), &cic);
1066 // There's alway an extra itable entry so we can null-terminate it.
1067 int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
1069 // Statistics
1070 update_stats(itable_size * HeapWordSize);
1072 return itable_size;
1073 }
1076 // Fill out offset table and interface klasses into the itable space
1077 void klassItable::setup_itable_offset_table(instanceKlassHandle klass) {
1078 if (klass->itable_length() == 0) return;
1079 assert(!klass->is_interface(), "Should have zero length itable");
1081 // Count no of interfaces and total number of interface methods
1082 CountInterfacesClosure cic;
1083 visit_all_interfaces(klass->transitive_interfaces(), &cic);
1084 int nof_methods = cic.nof_methods();
1085 int nof_interfaces = cic.nof_interfaces();
1087 // Add one extra entry so we can null-terminate the table
1088 nof_interfaces++;
1090 assert(compute_itable_size(objArrayHandle(klass->transitive_interfaces())) ==
1091 calc_itable_size(nof_interfaces, nof_methods),
1092 "mismatch calculation of itable size");
1094 // Fill-out offset table
1095 itableOffsetEntry* ioe = (itableOffsetEntry*)klass->start_of_itable();
1096 itableMethodEntry* ime = (itableMethodEntry*)(ioe + nof_interfaces);
1097 intptr_t* end = klass->end_of_itable();
1098 assert((oop*)(ime + nof_methods) <= (oop*)klass->start_of_nonstatic_oop_maps(), "wrong offset calculation (1)");
1099 assert((oop*)(end) == (oop*)(ime + nof_methods), "wrong offset calculation (2)");
1101 // Visit all interfaces and initialize itable offset table
1102 SetupItableClosure sic((address)klass->as_klassOop(), ioe, ime);
1103 visit_all_interfaces(klass->transitive_interfaces(), &sic);
1105 #ifdef ASSERT
1106 ime = sic.method_entry();
1107 oop* v = (oop*) klass->end_of_itable();
1108 assert( (oop*)(ime) == v, "wrong offset calculation (2)");
1109 #endif
1110 }
1113 // m must be a method in an interface
1114 int klassItable::compute_itable_index(methodOop m) {
1115 klassOop intf = m->method_holder();
1116 assert(instanceKlass::cast(intf)->is_interface(), "sanity check");
1117 objArrayOop methods = instanceKlass::cast(intf)->methods();
1118 int index = 0;
1119 while(methods->obj_at(index) != m) {
1120 index++;
1121 assert(index < methods->length(), "should find index for resolve_invoke");
1122 }
1123 // Adjust for <clinit>, which is left out of table if first method
1124 if (methods->length() > 0 && ((methodOop)methods->obj_at(0))->is_static_initializer()) {
1125 index--;
1126 }
1127 return index;
1128 }
1131 // inverse to compute_itable_index
1132 methodOop klassItable::method_for_itable_index(klassOop intf, int itable_index) {
1133 assert(instanceKlass::cast(intf)->is_interface(), "sanity check");
1134 objArrayOop methods = instanceKlass::cast(intf)->methods();
1136 int index = itable_index;
1137 // Adjust for <clinit>, which is left out of table if first method
1138 if (methods->length() > 0 && ((methodOop)methods->obj_at(0))->is_static_initializer()) {
1139 index++;
1140 }
1142 if (itable_index < 0 || index >= methods->length())
1143 return NULL; // help caller defend against bad indexes
1145 methodOop m = (methodOop)methods->obj_at(index);
1146 assert(compute_itable_index(m) == itable_index, "correct inverse");
1148 return m;
1149 }
1151 void klassVtable::verify(outputStream* st, bool forced) {
1152 // make sure table is initialized
1153 if (!Universe::is_fully_initialized()) return;
1154 #ifndef PRODUCT
1155 // avoid redundant verifies
1156 if (!forced && _verify_count == Universe::verify_count()) return;
1157 _verify_count = Universe::verify_count();
1158 #endif
1159 oop* end_of_obj = (oop*)_klass() + _klass()->size();
1160 oop* end_of_vtable = (oop *)&table()[_length];
1161 if (end_of_vtable > end_of_obj) {
1162 fatal(err_msg("klass %s: klass object too short (vtable extends beyond "
1163 "end)", _klass->internal_name()));
1164 }
1166 for (int i = 0; i < _length; i++) table()[i].verify(this, st);
1167 // verify consistency with superKlass vtable
1168 klassOop super = _klass->super();
1169 if (super != NULL) {
1170 instanceKlass* sk = instanceKlass::cast(super);
1171 klassVtable* vt = sk->vtable();
1172 for (int i = 0; i < vt->length(); i++) {
1173 verify_against(st, vt, i);
1174 }
1175 }
1176 }
1178 void klassVtable::verify_against(outputStream* st, klassVtable* vt, int index) {
1179 vtableEntry* vte = &vt->table()[index];
1180 if (vte->method()->name() != table()[index].method()->name() ||
1181 vte->method()->signature() != table()[index].method()->signature()) {
1182 fatal("mismatched name/signature of vtable entries");
1183 }
1184 }
1186 #ifndef PRODUCT
1187 void klassVtable::print() {
1188 ResourceMark rm;
1189 tty->print("klassVtable for klass %s (length %d):\n", _klass->internal_name(), length());
1190 for (int i = 0; i < length(); i++) {
1191 table()[i].print();
1192 tty->cr();
1193 }
1194 }
1195 #endif
1197 void vtableEntry::verify(klassVtable* vt, outputStream* st) {
1198 NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true));
1199 assert(method() != NULL, "must have set method");
1200 method()->verify();
1201 // we sub_type, because it could be a miranda method
1202 if (!vt->klass()->is_subtype_of(method()->method_holder())) {
1203 #ifndef PRODUCT
1204 print();
1205 #endif
1206 fatal(err_msg("vtableEntry " PTR_FORMAT ": method is from subclass", this));
1207 }
1208 }
1210 #ifndef PRODUCT
1212 void vtableEntry::print() {
1213 ResourceMark rm;
1214 tty->print("vtableEntry %s: ", method()->name()->as_C_string());
1215 if (Verbose) {
1216 tty->print("m %#lx ", (address)method());
1217 }
1218 }
1220 class VtableStats : AllStatic {
1221 public:
1222 static int no_klasses; // # classes with vtables
1223 static int no_array_klasses; // # array classes
1224 static int no_instance_klasses; // # instanceKlasses
1225 static int sum_of_vtable_len; // total # of vtable entries
1226 static int sum_of_array_vtable_len; // total # of vtable entries in array klasses only
1227 static int fixed; // total fixed overhead in bytes
1228 static int filler; // overhead caused by filler bytes
1229 static int entries; // total bytes consumed by vtable entries
1230 static int array_entries; // total bytes consumed by array vtable entries
1232 static void do_class(klassOop k) {
1233 Klass* kl = k->klass_part();
1234 klassVtable* vt = kl->vtable();
1235 if (vt == NULL) return;
1236 no_klasses++;
1237 if (kl->oop_is_instance()) {
1238 no_instance_klasses++;
1239 kl->array_klasses_do(do_class);
1240 }
1241 if (kl->oop_is_array()) {
1242 no_array_klasses++;
1243 sum_of_array_vtable_len += vt->length();
1244 }
1245 sum_of_vtable_len += vt->length();
1246 }
1248 static void compute() {
1249 SystemDictionary::classes_do(do_class);
1250 fixed = no_klasses * oopSize; // vtable length
1251 // filler size is a conservative approximation
1252 filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(instanceKlass) - sizeof(arrayKlass) - 1);
1253 entries = sizeof(vtableEntry) * sum_of_vtable_len;
1254 array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
1255 }
1256 };
1258 int VtableStats::no_klasses = 0;
1259 int VtableStats::no_array_klasses = 0;
1260 int VtableStats::no_instance_klasses = 0;
1261 int VtableStats::sum_of_vtable_len = 0;
1262 int VtableStats::sum_of_array_vtable_len = 0;
1263 int VtableStats::fixed = 0;
1264 int VtableStats::filler = 0;
1265 int VtableStats::entries = 0;
1266 int VtableStats::array_entries = 0;
1268 void klassVtable::print_statistics() {
1269 ResourceMark rm;
1270 HandleMark hm;
1271 VtableStats::compute();
1272 tty->print_cr("vtable statistics:");
1273 tty->print_cr("%6d classes (%d instance, %d array)", VtableStats::no_klasses, VtableStats::no_instance_klasses, VtableStats::no_array_klasses);
1274 int total = VtableStats::fixed + VtableStats::filler + VtableStats::entries;
1275 tty->print_cr("%6d bytes fixed overhead (refs + vtable object header)", VtableStats::fixed);
1276 tty->print_cr("%6d bytes filler overhead", VtableStats::filler);
1277 tty->print_cr("%6d bytes for vtable entries (%d for arrays)", VtableStats::entries, VtableStats::array_entries);
1278 tty->print_cr("%6d bytes total", total);
1279 }
1281 bool klassVtable::check_no_old_entries() {
1282 // Check that there really is no entry
1283 for (int i = 0; i < length(); i++) {
1284 methodOop m = unchecked_method_at(i);
1285 if (m != NULL) {
1286 if (m->is_old()) {
1287 return false;
1288 }
1289 }
1290 }
1291 return true;
1292 }
1294 void klassVtable::dump_vtable() {
1295 tty->print_cr("vtable dump --");
1296 for (int i = 0; i < length(); i++) {
1297 methodOop m = unchecked_method_at(i);
1298 if (m != NULL) {
1299 tty->print(" (%5d) ", i);
1300 m->access_flags().print_on(tty);
1301 tty->print(" -- ");
1302 m->print_name(tty);
1303 tty->cr();
1304 }
1305 }
1306 }
1308 int klassItable::_total_classes; // Total no. of classes with itables
1309 long klassItable::_total_size; // Total no. of bytes used for itables
1311 void klassItable::print_statistics() {
1312 tty->print_cr("itable statistics:");
1313 tty->print_cr("%6d classes with itables", _total_classes);
1314 tty->print_cr("%6d K uses for itables (average by class: %d bytes)", _total_size / K, _total_size / _total_classes);
1315 }
1317 #endif // PRODUCT