truffle: src/share/vm/oops/klassVtable.cpp annotate

annotate src/share/vm/oops/klassVtable.cpp @ 12264:b2e698d2276c

8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation Summary: Enhance method resolution and resulting data structures, plus some refactoring. Reviewed-by: twisti, acorn, jrose

author	drchase
date	Fri, 13 Sep 2013 22:38:02 -0400
parents	08236d966eea
children	36b97be47bde

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1490 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27 #include "classfile/vmSymbols.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "memory/gcLocker.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "memory/universe.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "oops/klassVtable.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	34 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	36 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	37 #include "prims/jvmtiRedefineClassesTrace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	38 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	39 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	40 #include "utilities/copy.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	41
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	42 inline InstanceKlass* klassVtable::ik() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	43 Klass* k = _klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	44 assert(k->oop_is_instance(), "not an InstanceKlass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	45 return (InstanceKlass*)k;
0 a61af66fc99e Initial load duke parents: diff changeset	46 }
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48
a61af66fc99e Initial load duke parents: diff changeset	49 // this function computes the vtable size (including the size needed for miranda
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	50 // methods) and the number of miranda methods in this class.
0 a61af66fc99e Initial load duke parents: diff changeset	51 // Note on Miranda methods: Let's say there is a class C that implements
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	52 // interface I, and none of C's superclasses implements I.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	53 // Let's say there is an abstract method m in I that neither C
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	54 // nor any of its super classes implement (i.e there is no method of any access,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	55 // with the same name and signature as m), then m is a Miranda method which is
0 a61af66fc99e Initial load duke parents: diff changeset	56 // entered as a public abstract method in C's vtable. From then on it should
a61af66fc99e Initial load duke parents: diff changeset	57 // treated as any other public method in C for method over-ride purposes.
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	58 void klassVtable::compute_vtable_size_and_num_mirandas(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	59 int* vtable_length_ret, int* num_new_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	60 GrowableArray<Method> all_mirandas, Klass* super,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	61 Array<Method> methods, AccessFlags class_flags,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	62 Handle classloader, Symbol* classname, Array<Klass> local_interfaces,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	63 TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	64 No_Safepoint_Verifier nsv;
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66 // set up default result values
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	67 int vtable_length = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // start off with super's vtable length
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	70 InstanceKlass* sk = (InstanceKlass*)super;
0 a61af66fc99e Initial load duke parents: diff changeset	71 vtable_length = super == NULL ? 0 : sk->vtable_length();
a61af66fc99e Initial load duke parents: diff changeset	72
a61af66fc99e Initial load duke parents: diff changeset	73 // go thru each method in the methods table to see if it needs a new entry
a61af66fc99e Initial load duke parents: diff changeset	74 int len = methods->length();
a61af66fc99e Initial load duke parents: diff changeset	75 for (int i = 0; i < len; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	76 assert(methods->at(i)->is_method(), "must be a Method*");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	77 methodHandle mh(THREAD, methods->at(i));
0 a61af66fc99e Initial load duke parents: diff changeset	78
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	79 if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, THREAD)) {
0 a61af66fc99e Initial load duke parents: diff changeset	80 vtable_length += vtableEntry::size(); // we need a new entry
a61af66fc99e Initial load duke parents: diff changeset	81 }
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	84 GrowableArray<Method*> new_mirandas(20);
0 a61af66fc99e Initial load duke parents: diff changeset	85 // compute the number of mirandas methods that must be added to the end
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	86 get_mirandas(&new_mirandas, all_mirandas, super, methods, local_interfaces);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	87 *num_new_mirandas = new_mirandas.length();
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	88
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	89 vtable_length += num_new_mirandas vtableEntry::size();
0 a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 if (Universe::is_bootstrapping() && vtable_length == 0) {
a61af66fc99e Initial load duke parents: diff changeset	92 // array classes don't have their superclass set correctly during
a61af66fc99e Initial load duke parents: diff changeset	93 // bootstrapping
a61af66fc99e Initial load duke parents: diff changeset	94 vtable_length = Universe::base_vtable_size();
a61af66fc99e Initial load duke parents: diff changeset	95 }
a61af66fc99e Initial load duke parents: diff changeset	96
a61af66fc99e Initial load duke parents: diff changeset	97 if (super == NULL && !Universe::is_bootstrapping() &&
a61af66fc99e Initial load duke parents: diff changeset	98 vtable_length != Universe::base_vtable_size()) {
a61af66fc99e Initial load duke parents: diff changeset	99 // Someone is attempting to redefine java.lang.Object incorrectly. The
a61af66fc99e Initial load duke parents: diff changeset	100 // only way this should happen is from
a61af66fc99e Initial load duke parents: diff changeset	101 // SystemDictionary::resolve_from_stream(), which will detect this later
a61af66fc99e Initial load duke parents: diff changeset	102 // and throw a security exception. So don't assert here to let
a61af66fc99e Initial load duke parents: diff changeset	103 // the exception occur.
a61af66fc99e Initial load duke parents: diff changeset	104 vtable_length = Universe::base_vtable_size();
a61af66fc99e Initial load duke parents: diff changeset	105 }
a61af66fc99e Initial load duke parents: diff changeset	106 assert(super != NULL \|\| vtable_length == Universe::base_vtable_size(),
a61af66fc99e Initial load duke parents: diff changeset	107 "bad vtable size for class Object");
a61af66fc99e Initial load duke parents: diff changeset	108 assert(vtable_length % vtableEntry::size() == 0, "bad vtable length");
a61af66fc99e Initial load duke parents: diff changeset	109 assert(vtable_length >= Universe::base_vtable_size(), "vtable too small");
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	110
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	111 *vtable_length_ret = vtable_length;
0 a61af66fc99e Initial load duke parents: diff changeset	112 }
a61af66fc99e Initial load duke parents: diff changeset	113
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	114 int klassVtable::index_of(Method* m, int len) const {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	115 assert(m->has_vtable_index(), "do not ask this of non-vtable methods");
0 a61af66fc99e Initial load duke parents: diff changeset	116 return m->vtable_index();
a61af66fc99e Initial load duke parents: diff changeset	117 }
a61af66fc99e Initial load duke parents: diff changeset	118
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	119 // Copy super class's vtable to the first part (prefix) of this class's vtable,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	120 // and return the number of entries copied. Expects that 'super' is the Java
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	121 // super class (arrays can have "array" super classes that must be skipped).
0 a61af66fc99e Initial load duke parents: diff changeset	122 int klassVtable::initialize_from_super(KlassHandle super) {
a61af66fc99e Initial load duke parents: diff changeset	123 if (super.is_null()) {
a61af66fc99e Initial load duke parents: diff changeset	124 return 0;
a61af66fc99e Initial load duke parents: diff changeset	125 } else {
a61af66fc99e Initial load duke parents: diff changeset	126 // copy methods from superKlass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	127 // can't inherit from array class, so must be InstanceKlass
0 a61af66fc99e Initial load duke parents: diff changeset	128 assert(super->oop_is_instance(), "must be instance klass");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	129 InstanceKlass* sk = (InstanceKlass*)super();
0 a61af66fc99e Initial load duke parents: diff changeset	130 klassVtable* superVtable = sk->vtable();
a61af66fc99e Initial load duke parents: diff changeset	131 assert(superVtable->length() <= _length, "vtable too short");
a61af66fc99e Initial load duke parents: diff changeset	132 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	133 superVtable->verify(tty, true);
a61af66fc99e Initial load duke parents: diff changeset	134 #endif
a61af66fc99e Initial load duke parents: diff changeset	135 superVtable->copy_vtable_to(table());
a61af66fc99e Initial load duke parents: diff changeset	136 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	137 if (PrintVtables && Verbose) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	138 ResourceMark rm;
0 a61af66fc99e Initial load duke parents: diff changeset	139 tty->print_cr("copy vtable from %s to %s size %d", sk->internal_name(), klass()->internal_name(), _length);
a61af66fc99e Initial load duke parents: diff changeset	140 }
a61af66fc99e Initial load duke parents: diff changeset	141 #endif
a61af66fc99e Initial load duke parents: diff changeset	142 return superVtable->length();
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	146 //
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	147 // Revised lookup semantics introduced 1.3 (Kestrel beta)
0 a61af66fc99e Initial load duke parents: diff changeset	148 void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	149
a61af66fc99e Initial load duke parents: diff changeset	150 // Note: Arrays can have intermediate array supers. Use java_super to skip them.
a61af66fc99e Initial load duke parents: diff changeset	151 KlassHandle super (THREAD, klass()->java_super());
a61af66fc99e Initial load duke parents: diff changeset	152 int nofNewEntries = 0;
a61af66fc99e Initial load duke parents: diff changeset	153
a61af66fc99e Initial load duke parents: diff changeset	154 if (PrintVtables && !klass()->oop_is_array()) {
a61af66fc99e Initial load duke parents: diff changeset	155 ResourceMark rm(THREAD);
a61af66fc99e Initial load duke parents: diff changeset	156 tty->print_cr("Initializing: %s", _klass->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	157 }
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	160 oop* end_of_obj = (oop*)_klass() + _klass()->size();
a61af66fc99e Initial load duke parents: diff changeset	161 oop* end_of_vtable = (oop*)&table()[_length];
a61af66fc99e Initial load duke parents: diff changeset	162 assert(end_of_vtable <= end_of_obj, "vtable extends beyond end");
a61af66fc99e Initial load duke parents: diff changeset	163 #endif
a61af66fc99e Initial load duke parents: diff changeset	164
a61af66fc99e Initial load duke parents: diff changeset	165 if (Universe::is_bootstrapping()) {
a61af66fc99e Initial load duke parents: diff changeset	166 // just clear everything
a61af66fc99e Initial load duke parents: diff changeset	167 for (int i = 0; i < _length; i++) table()[i].clear();
a61af66fc99e Initial load duke parents: diff changeset	168 return;
a61af66fc99e Initial load duke parents: diff changeset	169 }
a61af66fc99e Initial load duke parents: diff changeset	170
a61af66fc99e Initial load duke parents: diff changeset	171 int super_vtable_len = initialize_from_super(super);
a61af66fc99e Initial load duke parents: diff changeset	172 if (klass()->oop_is_array()) {
a61af66fc99e Initial load duke parents: diff changeset	173 assert(super_vtable_len == _length, "arrays shouldn't introduce new methods");
a61af66fc99e Initial load duke parents: diff changeset	174 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	175 assert(_klass->oop_is_instance(), "must be InstanceKlass");
0 a61af66fc99e Initial load duke parents: diff changeset	176
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	177 Array<Method> methods = ik()->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	178 int len = methods->length();
0 a61af66fc99e Initial load duke parents: diff changeset	179 int initialized = super_vtable_len;
a61af66fc99e Initial load duke parents: diff changeset	180
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	181 // Check each of this class's methods against super;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	182 // if override, replace in copy of super vtable, otherwise append to end
0 a61af66fc99e Initial load duke parents: diff changeset	183 for (int i = 0; i < len; i++) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	184 // update_inherited_vtable can stop for gc - ensure using handles
0 a61af66fc99e Initial load duke parents: diff changeset	185 HandleMark hm(THREAD);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	186 assert(methods->at(i)->is_method(), "must be a Method*");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	187 methodHandle mh(THREAD, methods->at(i));
0 a61af66fc99e Initial load duke parents: diff changeset	188
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	189 bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, checkconstraints, CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191 if (needs_new_entry) {
a61af66fc99e Initial load duke parents: diff changeset	192 put_method_at(mh(), initialized);
a61af66fc99e Initial load duke parents: diff changeset	193 mh()->set_vtable_index(initialized); // set primary vtable index
a61af66fc99e Initial load duke parents: diff changeset	194 initialized++;
a61af66fc99e Initial load duke parents: diff changeset	195 }
a61af66fc99e Initial load duke parents: diff changeset	196 }
a61af66fc99e Initial load duke parents: diff changeset	197
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	198 // add miranda methods to end of vtable.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	199 initialized = fill_in_mirandas(initialized);
0 a61af66fc99e Initial load duke parents: diff changeset	200
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	201 // In class hierarchies where the accessibility is not increasing (i.e., going from private ->
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	202 // package_private -> public/protected), the vtable might actually be smaller than our initial
0 a61af66fc99e Initial load duke parents: diff changeset	203 // calculation.
a61af66fc99e Initial load duke parents: diff changeset	204 assert(initialized <= _length, "vtable initialization failed");
a61af66fc99e Initial load duke parents: diff changeset	205 for(;initialized < _length; initialized++) {
a61af66fc99e Initial load duke parents: diff changeset	206 put_method_at(NULL, initialized);
a61af66fc99e Initial load duke parents: diff changeset	207 }
a61af66fc99e Initial load duke parents: diff changeset	208 NOT_PRODUCT(verify(tty, true));
a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210 }
a61af66fc99e Initial load duke parents: diff changeset	211
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	212 // Called for cases where a method does not override its superclass' vtable entry
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	213 // For bytecodes not produced by javac together it is possible that a method does not override
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	214 // the superclass's method, but might indirectly override a super-super class's vtable entry
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	215 // If none found, return a null superk, else return the superk of the method this does override
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	216 InstanceKlass* klassVtable::find_transitive_override(InstanceKlass* initialsuper, methodHandle target_method,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	217 int vtable_index, Handle target_loader, Symbol* target_classname, Thread * THREAD) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	218 InstanceKlass* superk = initialsuper;
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	219 while (superk != NULL && superk->super() != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	220 InstanceKlass* supersuperklass = InstanceKlass::cast(superk->super());
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	221 klassVtable* ssVtable = supersuperklass->vtable();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	222 if (vtable_index < ssVtable->length()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	223 Method* super_method = ssVtable->method_at(vtable_index);
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	224 #ifndef PRODUCT
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	225 Symbol* name= target_method()->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	226 Symbol* signature = target_method()->signature();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	227 assert(super_method->name() == name && super_method->signature() == signature, "vtable entry name/sig mismatch");
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	228 #endif
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	229 if (supersuperklass->is_override(super_method, target_loader, target_classname, THREAD)) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	230 #ifndef PRODUCT
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	231 if (PrintVtables && Verbose) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	232 ResourceMark rm(THREAD);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	233 tty->print("transitive overriding superclass %s with %s::%s index %d, original flags: ",
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	234 supersuperklass->internal_name(),
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	235 _klass->internal_name(), (target_method() != NULL) ?
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	236 target_method()->name()->as_C_string() : "<NULL>", vtable_index);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	237 super_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	238 tty->print("overriders flags: ");
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	239 target_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	240 tty->cr();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	241 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	242 #endif /PRODUCT/
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	243 break; // return found superk
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	244 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	245 } else {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	246 // super class has no vtable entry here, stop transitive search
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	247 superk = (InstanceKlass*)NULL;
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	248 break;
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	249 }
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	250 // if no override found yet, continue to search up
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	251 superk = InstanceKlass::cast(superk->super());
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	252 }
0 a61af66fc99e Initial load duke parents: diff changeset	253
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	254 return superk;
0 a61af66fc99e Initial load duke parents: diff changeset	255 }
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 // Update child's copy of super vtable for overrides
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	258 // OR return true if a new vtable entry is required.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	259 // Only called for InstanceKlass's, i.e. not for arrays
0 a61af66fc99e Initial load duke parents: diff changeset	260 // If that changed, could not use _klass as handle for klass
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	261 bool klassVtable::update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len,
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	262 bool checkconstraints, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	263 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	264 bool allocate_new = true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	265 assert(klass->oop_is_instance(), "must be InstanceKlass");
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	266 assert(klass == target_method()->method_holder(), "caller resp.");
0 a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // Initialize the method's vtable index to "nonvirtual".
a61af66fc99e Initial load duke parents: diff changeset	269 // If we allocate a vtable entry, we will update it to a non-negative number.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	270 target_method()->set_vtable_index(Method::nonvirtual_vtable_index);
0 a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 // Static and <init> methods are never in
a61af66fc99e Initial load duke parents: diff changeset	273 if (target_method()->is_static() \|\| target_method()->name() == vmSymbols::object_initializer_name()) {
a61af66fc99e Initial load duke parents: diff changeset	274 return false;
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	277 if (target_method->is_final_method(klass->access_flags())) {
0 a61af66fc99e Initial load duke parents: diff changeset	278 // a final method never needs a new entry; final methods can be statically
a61af66fc99e Initial load duke parents: diff changeset	279 // resolved and they have to be present in the vtable only if they override
a61af66fc99e Initial load duke parents: diff changeset	280 // a super's method, in which case they re-use its entry
a61af66fc99e Initial load duke parents: diff changeset	281 allocate_new = false;
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	282 } else if (klass->is_interface()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	283 allocate_new = false; // see note below in needs_new_vtable_entry
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	284 // An interface never allocates new vtable slots, only inherits old ones.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	285 // This method will either be assigned its own itable index later,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	286 // or be assigned an inherited vtable index in the loop below.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	287 target_method()->set_vtable_index(Method::pending_itable_index);
0 a61af66fc99e Initial load duke parents: diff changeset	288 }
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 // we need a new entry if there is no superclass
a61af66fc99e Initial load duke parents: diff changeset	291 if (klass->super() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	292 return allocate_new;
a61af66fc99e Initial load duke parents: diff changeset	293 }
a61af66fc99e Initial load duke parents: diff changeset	294
a61af66fc99e Initial load duke parents: diff changeset	295 // private methods always have a new entry in the vtable
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	296 // specification interpretation since classic has
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	297 // private methods not overriding
0 a61af66fc99e Initial load duke parents: diff changeset	298 if (target_method()->is_private()) {
a61af66fc99e Initial load duke parents: diff changeset	299 return allocate_new;
a61af66fc99e Initial load duke parents: diff changeset	300 }
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302 // search through the vtable and update overridden entries
a61af66fc99e Initial load duke parents: diff changeset	303 // Since check_signature_loaders acquires SystemDictionary_lock
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	304 // which can block for gc, once we are in this loop, use handles
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	305 // For classfiles built with >= jdk7, we now look for transitive overrides
0 a61af66fc99e Initial load duke parents: diff changeset	306
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	307 Symbol* name = target_method()->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	308 Symbol* signature = target_method()->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	309 Handle target_loader(THREAD, _klass()->class_loader());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	310 Symbol* target_classname = _klass->name();
0 a61af66fc99e Initial load duke parents: diff changeset	311 for(int i = 0; i < super_vtable_len; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	312 Method* super_method = method_at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	313 // Check if method name matches
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	314 if (super_method->name() == name && super_method->signature() == signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	315
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	316 // get super_klass for method_holder for the found method
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	317 InstanceKlass* super_klass = super_method->method_holder();
0 a61af66fc99e Initial load duke parents: diff changeset	318
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	319 if ((super_klass->is_override(super_method, target_loader, target_classname, THREAD)) \|\|
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	320 ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	321 && ((super_klass = find_transitive_override(super_klass, target_method, i, target_loader,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	322 target_classname, THREAD)) != (InstanceKlass*)NULL))) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	323 // overriding, so no new entry
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	324 allocate_new = false;
0 a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 if (checkconstraints) {
a61af66fc99e Initial load duke parents: diff changeset	327 // Override vtable entry if passes loader constraint check
a61af66fc99e Initial load duke parents: diff changeset	328 // if loader constraint checking requested
a61af66fc99e Initial load duke parents: diff changeset	329 // No need to visit his super, since he and his super
a61af66fc99e Initial load duke parents: diff changeset	330 // have already made any needed loader constraints.
a61af66fc99e Initial load duke parents: diff changeset	331 // Since loader constraints are transitive, it is enough
a61af66fc99e Initial load duke parents: diff changeset	332 // to link to the first super, and we get all the others.
a61af66fc99e Initial load duke parents: diff changeset	333 Handle super_loader(THREAD, super_klass->class_loader());
a61af66fc99e Initial load duke parents: diff changeset	334
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	335 if (target_loader() != super_loader()) {
0 a61af66fc99e Initial load duke parents: diff changeset	336 ResourceMark rm(THREAD);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	337 Symbol* failed_type_symbol =
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	338 SystemDictionary::check_signature_loaders(signature, target_loader,
0 a61af66fc99e Initial load duke parents: diff changeset	339 super_loader, true,
a61af66fc99e Initial load duke parents: diff changeset	340 CHECK_(false));
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	341 if (failed_type_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	342 const char* msg = "loader constraint violation: when resolving "
a61af66fc99e Initial load duke parents: diff changeset	343 "overridden method \"%s\" the class loader (instance"
a61af66fc99e Initial load duke parents: diff changeset	344 " of %s) of the current class, %s, and its superclass loader "
a61af66fc99e Initial load duke parents: diff changeset	345 "(instance of %s), have different Class objects for the type "
a61af66fc99e Initial load duke parents: diff changeset	346 "%s used in the signature";
a61af66fc99e Initial load duke parents: diff changeset	347 char* sig = target_method()->name_and_sig_as_C_string();
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	348 const char* loader1 = SystemDictionary::loader_name(target_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	349 char* current = _klass->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	350 const char* loader2 = SystemDictionary::loader_name(super_loader());
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	351 char* failed_type_name = failed_type_symbol->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	352 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
a61af66fc99e Initial load duke parents: diff changeset	353 strlen(current) + strlen(loader2) + strlen(failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	354 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
a61af66fc99e Initial load duke parents: diff changeset	355 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
a61af66fc99e Initial load duke parents: diff changeset	356 failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	357 THROW_MSG_(vmSymbols::java_lang_LinkageError(), buf, false);
a61af66fc99e Initial load duke parents: diff changeset	358 }
a61af66fc99e Initial load duke parents: diff changeset	359 }
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	360 }
0 a61af66fc99e Initial load duke parents: diff changeset	361
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	362 put_method_at(target_method(), i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	363 target_method()->set_vtable_index(i);
0 a61af66fc99e Initial load duke parents: diff changeset	364 #ifndef PRODUCT
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	365 if (PrintVtables && Verbose) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	366 tty->print("overriding with %s::%s index %d, original flags: ",
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	367 _klass->internal_name(), (target_method() != NULL) ?
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	368 target_method()->name()->as_C_string() : "<NULL>", i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	369 super_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	370 tty->print("overriders flags: ");
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	371 target_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	372 tty->cr();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	373 }
0 a61af66fc99e Initial load duke parents: diff changeset	374 #endif /PRODUCT/
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	375 } else {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	376 // allocate_new = true; default. We might override one entry,
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	377 // but not override another. Once we override one, not need new
0 a61af66fc99e Initial load duke parents: diff changeset	378 #ifndef PRODUCT
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	379 if (PrintVtables && Verbose) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	380 tty->print("NOT overriding with %s::%s index %d, original flags: ",
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	381 _klass->internal_name(), (target_method() != NULL) ?
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	382 target_method()->name()->as_C_string() : "<NULL>", i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	383 super_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	384 tty->print("overriders flags: ");
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	385 target_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	386 tty->cr();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	387 }
0 a61af66fc99e Initial load duke parents: diff changeset	388 #endif /PRODUCT/
a61af66fc99e Initial load duke parents: diff changeset	389 }
a61af66fc99e Initial load duke parents: diff changeset	390 }
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392 return allocate_new;
a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	395 void klassVtable::put_method_at(Method* m, int index) {
0 a61af66fc99e Initial load duke parents: diff changeset	396 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	397 if (PrintVtables && Verbose) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	398 ResourceMark rm;
0 a61af66fc99e Initial load duke parents: diff changeset	399 tty->print_cr("adding %s::%s at index %d", _klass->internal_name(),
a61af66fc99e Initial load duke parents: diff changeset	400 (m != NULL) ? m->name()->as_C_string() : "<NULL>", index);
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 #endif
a61af66fc99e Initial load duke parents: diff changeset	403 table()[index].set(m);
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 // Find out if a method "m" with superclass "super", loader "classloader" and
a61af66fc99e Initial load duke parents: diff changeset	407 // name "classname" needs a new vtable entry. Let P be a class package defined
a61af66fc99e Initial load duke parents: diff changeset	408 // by "classloader" and "classname".
a61af66fc99e Initial load duke parents: diff changeset	409 // NOTE: The logic used here is very similar to the one used for computing
a61af66fc99e Initial load duke parents: diff changeset	410 // the vtables indices for a method. We cannot directly use that function because,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	411 // we allocate the InstanceKlass at load time, and that requires that the
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	412 // superclass has been loaded.
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	413 // However, the vtable entries are filled in at link time, and therefore
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	414 // the superclass' vtable may not yet have been filled in.
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	415 bool klassVtable::needs_new_vtable_entry(methodHandle target_method,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	416 Klass* super,
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	417 Handle classloader,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	418 Symbol* classname,
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	419 AccessFlags class_flags,
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	420 TRAPS) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	421 if (class_flags.is_interface()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	422 // Interfaces do not use vtables, so there is no point to assigning
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	423 // a vtable index to any of their methods. If we refrain from doing this,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	424 // we can use Method::_vtable_index to hold the itable index
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	425 return false;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	426 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	427
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	428 if (target_method->is_final_method(class_flags) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	429 // a final method never needs a new entry; final methods can be statically
a61af66fc99e Initial load duke parents: diff changeset	430 // resolved and they have to be present in the vtable only if they override
a61af66fc99e Initial load duke parents: diff changeset	431 // a super's method, in which case they re-use its entry
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	432 (target_method()->is_static()) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	433 // static methods don't need to be in vtable
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	434 (target_method()->name() == vmSymbols::object_initializer_name())
0 a61af66fc99e Initial load duke parents: diff changeset	435 // <init> is never called dynamically-bound
a61af66fc99e Initial load duke parents: diff changeset	436 ) {
a61af66fc99e Initial load duke parents: diff changeset	437 return false;
a61af66fc99e Initial load duke parents: diff changeset	438 }
a61af66fc99e Initial load duke parents: diff changeset	439
a61af66fc99e Initial load duke parents: diff changeset	440 // we need a new entry if there is no superclass
a61af66fc99e Initial load duke parents: diff changeset	441 if (super == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	442 return true;
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 // private methods always have a new entry in the vtable
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	446 // specification interpretation since classic has
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	447 // private methods not overriding
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	448 if (target_method()->is_private()) {
0 a61af66fc99e Initial load duke parents: diff changeset	449 return true;
a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451
a61af66fc99e Initial load duke parents: diff changeset	452 // search through the super class hierarchy to see if we need
a61af66fc99e Initial load duke parents: diff changeset	453 // a new entry
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	454 ResourceMark rm;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	455 Symbol* name = target_method()->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	456 Symbol* signature = target_method()->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	457 Klass* k = super;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	458 Method* super_method = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	459 InstanceKlass *holder = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	460 Method* recheck_method = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	461 while (k != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	462 // lookup through the hierarchy for a method with matching name and sign.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	463 super_method = InstanceKlass::cast(k)->lookup_method(name, signature);
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	464 if (super_method == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	465 break; // we still have to search for a matching miranda method
a61af66fc99e Initial load duke parents: diff changeset	466 }
a61af66fc99e Initial load duke parents: diff changeset	467 // get the class holding the matching method
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	468 // make sure you use that class for is_override
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	469 InstanceKlass* superk = super_method->method_holder();
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	470 // we want only instance method matches
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	471 // pretend private methods are not in the super vtable
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	472 // since we do override around them: e.g. a.m pub/b.m private/c.m pub,
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	473 // ignore private, c.m pub does override a.m pub
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	474 // For classes that were not javac'd together, we also do transitive overriding around
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	475 // methods that have less accessibility
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	476 if ((!super_method->is_static()) &&
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	477 (!super_method->is_private())) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	478 if (superk->is_override(super_method, classloader, classname, THREAD)) {
0 a61af66fc99e Initial load duke parents: diff changeset	479 return false;
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	480 // else keep looking for transitive overrides
0 a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482 }
a61af66fc99e Initial load duke parents: diff changeset	483
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	484 // Start with lookup result and continue to search up
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	485 k = superk->super(); // haven't found an override match yet; continue to look
0 a61af66fc99e Initial load duke parents: diff changeset	486 }
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // if the target method is public or protected it may have a matching
a61af66fc99e Initial load duke parents: diff changeset	489 // miranda method in the super, whose entry it should re-use.
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	490 // Actually, to handle cases that javac would not generate, we need
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	491 // this check for all access permissions.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	492 InstanceKlass *sk = InstanceKlass::cast(super);
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	493 if (sk->has_miranda_methods()) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	494 if (sk->lookup_method_in_all_interfaces(name, signature) != NULL) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	495 return false; // found a matching miranda; we do not need a new entry
0 a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498 return true; // found no match; we need a new entry
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 // Support for miranda methods
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 // get the vtable index of a miranda method with matching "name" and "signature"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	504 int klassVtable::index_of_miranda(Symbol* name, Symbol* signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	505 // search from the bottom, might be faster
a61af66fc99e Initial load duke parents: diff changeset	506 for (int i = (length() - 1); i >= 0; i--) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	507 Method* m = table()[i].method();
0 a61af66fc99e Initial load duke parents: diff changeset	508 if (is_miranda_entry_at(i) &&
a61af66fc99e Initial load duke parents: diff changeset	509 m->name() == name && m->signature() == signature) {
a61af66fc99e Initial load duke parents: diff changeset	510 return i;
a61af66fc99e Initial load duke parents: diff changeset	511 }
a61af66fc99e Initial load duke parents: diff changeset	512 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	513 return Method::invalid_vtable_index;
0 a61af66fc99e Initial load duke parents: diff changeset	514 }
a61af66fc99e Initial load duke parents: diff changeset	515
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	516 // check if an entry at an index is miranda
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	517 // requires that method m at entry be declared ("held") by an interface.
0 a61af66fc99e Initial load duke parents: diff changeset	518 bool klassVtable::is_miranda_entry_at(int i) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	519 Method* m = method_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	520 Klass* method_holder = m->method_holder();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	521 InstanceKlass *mhk = InstanceKlass::cast(method_holder);
0 a61af66fc99e Initial load duke parents: diff changeset	522
a61af66fc99e Initial load duke parents: diff changeset	523 // miranda methods are interface methods in a class's vtable
a61af66fc99e Initial load duke parents: diff changeset	524 if (mhk->is_interface()) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	525 assert(m->is_public(), "should be public");
0 a61af66fc99e Initial load duke parents: diff changeset	526 assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
a61af66fc99e Initial load duke parents: diff changeset	527 assert(is_miranda(m, ik()->methods(), ik()->super()), "should be a miranda_method");
a61af66fc99e Initial load duke parents: diff changeset	528 return true;
a61af66fc99e Initial load duke parents: diff changeset	529 }
a61af66fc99e Initial load duke parents: diff changeset	530 return false;
a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	533 // check if a method is a miranda method, given a class's methods table and its super
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	534 // "miranda" means not static, not defined by this class, and not defined
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	535 // in super unless it is private and therefore inaccessible to this class.
0 a61af66fc99e Initial load duke parents: diff changeset	536 // the caller must make sure that the method belongs to an interface implemented by the class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	537 bool klassVtable::is_miranda(Method* m, Array<Method> class_methods, Klass* super) {
10166 08236d966eea 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87 bharadwaj parents: 8840 diff changeset	538 if (m->is_static()) {
08236d966eea 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87 bharadwaj parents: 8840 diff changeset	539 return false;
08236d966eea 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87 bharadwaj parents: 8840 diff changeset	540 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	541 Symbol* name = m->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	542 Symbol* signature = m->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	543 if (InstanceKlass::find_method(class_methods, name, signature) == NULL) {
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	544 // did not find it in the method table of the current class
0 a61af66fc99e Initial load duke parents: diff changeset	545 if (super == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	546 // super doesn't exist
a61af66fc99e Initial load duke parents: diff changeset	547 return true;
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	548 }
642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	549
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	550 Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	551 if (mo == NULL \|\| mo->access_flags().is_private() ) {
642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	552 // super class hierarchy does not implement it or protection is different
642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	553 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	554 }
a61af66fc99e Initial load duke parents: diff changeset	555 }
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	556
0 a61af66fc99e Initial load duke parents: diff changeset	557 return false;
a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	560 // Scans current_interface_methods for miranda methods that do not
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	561 // already appear in new_mirandas and are also not defined-and-non-private
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	562 // in super (superclass). These mirandas are added to all_mirandas if it is
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	563 // not null; in addition, those that are not duplicates of miranda methods
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	564 // inherited by super from its interfaces are added to new_mirandas.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	565 // Thus, new_mirandas will be the set of mirandas that this class introduces,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	566 // all_mirandas will be the set of all mirandas applicable to this class
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	567 // including all defined in superclasses.
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	568 void klassVtable::add_new_mirandas_to_lists(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	569 GrowableArray<Method> new_mirandas, GrowableArray<Method> all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	570 Array<Method> current_interface_methods, Array<Method> class_methods,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	571 Klass* super) {
0 a61af66fc99e Initial load duke parents: diff changeset	572 // iterate thru the current interface's method to see if it a miranda
a61af66fc99e Initial load duke parents: diff changeset	573 int num_methods = current_interface_methods->length();
a61af66fc99e Initial load duke parents: diff changeset	574 for (int i = 0; i < num_methods; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	575 Method* im = current_interface_methods->at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	576 bool is_duplicate = false;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	577 int num_of_current_mirandas = new_mirandas->length();
0 a61af66fc99e Initial load duke parents: diff changeset	578 // check for duplicate mirandas in different interfaces we implement
a61af66fc99e Initial load duke parents: diff changeset	579 for (int j = 0; j < num_of_current_mirandas; j++) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	580 Method* miranda = new_mirandas->at(j);
0 a61af66fc99e Initial load duke parents: diff changeset	581 if ((im->name() == miranda->name()) &&
a61af66fc99e Initial load duke parents: diff changeset	582 (im->signature() == miranda->signature())) {
a61af66fc99e Initial load duke parents: diff changeset	583 is_duplicate = true;
a61af66fc99e Initial load duke parents: diff changeset	584 break;
a61af66fc99e Initial load duke parents: diff changeset	585 }
a61af66fc99e Initial load duke parents: diff changeset	586 }
a61af66fc99e Initial load duke parents: diff changeset	587
a61af66fc99e Initial load duke parents: diff changeset	588 if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
a61af66fc99e Initial load duke parents: diff changeset	589 if (is_miranda(im, class_methods, super)) { // is it a miranda at all?
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	590 InstanceKlass *sk = InstanceKlass::cast(super);
0 a61af66fc99e Initial load duke parents: diff changeset	591 // check if it is a duplicate of a super's miranda
a61af66fc99e Initial load duke parents: diff changeset	592 if (sk->lookup_method_in_all_interfaces(im->name(), im->signature()) == NULL) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	593 new_mirandas->append(im);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	594 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	595 if (all_mirandas != NULL) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	596 all_mirandas->append(im);
0 a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598 }
a61af66fc99e Initial load duke parents: diff changeset	599 }
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601 }
a61af66fc99e Initial load duke parents: diff changeset	602
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	603 void klassVtable::get_mirandas(GrowableArray<Method> new_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	604 GrowableArray<Method> all_mirandas,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	605 Klass* super, Array<Method> class_methods,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	606 Array<Klass> local_interfaces) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	607 assert((new_mirandas->length() == 0) , "current mirandas must be 0");
0 a61af66fc99e Initial load duke parents: diff changeset	608
a61af66fc99e Initial load duke parents: diff changeset	609 // iterate thru the local interfaces looking for a miranda
a61af66fc99e Initial load duke parents: diff changeset	610 int num_local_ifs = local_interfaces->length();
a61af66fc99e Initial load duke parents: diff changeset	611 for (int i = 0; i < num_local_ifs; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	612 InstanceKlass *ik = InstanceKlass::cast(local_interfaces->at(i));
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	613 add_new_mirandas_to_lists(new_mirandas, all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	614 ik->methods(), class_methods, super);
0 a61af66fc99e Initial load duke parents: diff changeset	615 // iterate thru each local's super interfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	616 Array<Klass> super_ifs = ik->transitive_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	617 int num_super_ifs = super_ifs->length();
a61af66fc99e Initial load duke parents: diff changeset	618 for (int j = 0; j < num_super_ifs; j++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	619 InstanceKlass *sik = InstanceKlass::cast(super_ifs->at(j));
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	620 add_new_mirandas_to_lists(new_mirandas, all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	621 sik->methods(), class_methods, super);
0 a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623 }
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	626 // Discover miranda methods ("miranda" = "interface abstract, no binding"),
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	627 // and append them into the vtable starting at index initialized,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	628 // return the new value of initialized.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	629 int klassVtable::fill_in_mirandas(int initialized) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	630 GrowableArray<Method*> mirandas(20);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	631 get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	632 ik()->local_interfaces());
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	633 for (int i = 0; i < mirandas.length(); i++) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	634 put_method_at(mirandas.at(i), initialized);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	635 ++initialized;
0 a61af66fc99e Initial load duke parents: diff changeset	636 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	637 return initialized;
0 a61af66fc99e Initial load duke parents: diff changeset	638 }
a61af66fc99e Initial load duke parents: diff changeset	639
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	640 // Copy this class's vtable to the vtable beginning at start.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	641 // Used to copy superclass vtable to prefix of subclass's vtable.
0 a61af66fc99e Initial load duke parents: diff changeset	642 void klassVtable::copy_vtable_to(vtableEntry* start) {
a61af66fc99e Initial load duke parents: diff changeset	643 Copy::disjoint_words((HeapWord)table(), (HeapWord)start, _length * vtableEntry::size());
a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	646 #if INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	647 void klassVtable::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	648 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	649 // search the vtable for uses of either obsolete or EMCP methods
a61af66fc99e Initial load duke parents: diff changeset	650 for (int j = 0; j < methods_length; j++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	651 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	652 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	653
a61af66fc99e Initial load duke parents: diff changeset	654 // In the vast majority of cases we could get the vtable index
a61af66fc99e Initial load duke parents: diff changeset	655 // by using: old_method->vtable_index()
a61af66fc99e Initial load duke parents: diff changeset	656 // However, there are rare cases, eg. sun.awt.X11.XDecoratedPeer.getX()
a61af66fc99e Initial load duke parents: diff changeset	657 // in sun.awt.X11.XFramePeer where methods occur more than once in the
a61af66fc99e Initial load duke parents: diff changeset	658 // vtable, so, alas, we must do an exhaustive search.
a61af66fc99e Initial load duke parents: diff changeset	659 for (int index = 0; index < length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	660 if (unchecked_method_at(index) == old_method) {
a61af66fc99e Initial load duke parents: diff changeset	661 put_method_at(new_method, index);
a61af66fc99e Initial load duke parents: diff changeset	662
a61af66fc99e Initial load duke parents: diff changeset	663 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	664 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	665 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	666 RC_TRACE_MESG(("adjust: name=%s",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	667 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	668 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	671 RC_TRACE(0x00100000, ("vtable method update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	672 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	673 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	674 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	675 // cannot 'break' here; see for-loop comment above.
0 a61af66fc99e Initial load duke parents: diff changeset	676 }
a61af66fc99e Initial load duke parents: diff changeset	677 }
a61af66fc99e Initial load duke parents: diff changeset	678 }
a61af66fc99e Initial load duke parents: diff changeset	679 }
a61af66fc99e Initial load duke parents: diff changeset	680
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	681 // a vtable should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	682 bool klassVtable::check_no_old_or_obsolete_entries() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	683 for (int i = 0; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	684 Method* m = unchecked_method_at(i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	685 if (m != NULL &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	686 (NOT_PRODUCT(!m->is_valid() \|\|) m->is_old() \|\| m->is_obsolete())) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	687 return false;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	688 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	689 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	690 return true;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	691 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	692
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	693 void klassVtable::dump_vtable() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	694 tty->print_cr("vtable dump --");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	695 for (int i = 0; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	696 Method* m = unchecked_method_at(i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	697 if (m != NULL) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	698 tty->print(" (%5d) ", i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	699 m->access_flags().print_on(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	700 tty->print(" -- ");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	701 m->print_name(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	702 tty->cr();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	703 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	704 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	705 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	706 #endif // INCLUDE_JVMTI
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	707
3245 8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	708 // CDS/RedefineClasses support - clear vtables so they can be reinitialized
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	709 void klassVtable::clear_vtable() {
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	710 for (int i = 0; i < _length; i++) table()[i].clear();
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	711 }
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	712
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	713 bool klassVtable::is_initialized() {
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	714 return _length == 0 \|\| table()[0].method() != NULL;
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	715 }
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	716
0 a61af66fc99e Initial load duke parents: diff changeset	717 //-----------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	718 // Itable code
a61af66fc99e Initial load duke parents: diff changeset	719
a61af66fc99e Initial load duke parents: diff changeset	720 // Initialize a itableMethodEntry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	721 void itableMethodEntry::initialize(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	722 if (m == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	723
a61af66fc99e Initial load duke parents: diff changeset	724 _method = m;
a61af66fc99e Initial load duke parents: diff changeset	725 }
a61af66fc99e Initial load duke parents: diff changeset	726
a61af66fc99e Initial load duke parents: diff changeset	727 klassItable::klassItable(instanceKlassHandle klass) {
a61af66fc99e Initial load duke parents: diff changeset	728 _klass = klass;
a61af66fc99e Initial load duke parents: diff changeset	729
a61af66fc99e Initial load duke parents: diff changeset	730 if (klass->itable_length() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	731 itableOffsetEntry* offset_entry = (itableOffsetEntry*)klass->start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	732 if (offset_entry != NULL && offset_entry->interface_klass() != NULL) { // Check that itable is initialized
a61af66fc99e Initial load duke parents: diff changeset	733 // First offset entry points to the first method_entry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	734 intptr_t* method_entry = (intptr_t *)(((address)klass()) + offset_entry->offset());
0 a61af66fc99e Initial load duke parents: diff changeset	735 intptr_t* end = klass->end_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	736
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	737 _table_offset = (intptr_t)offset_entry - (intptr_t)klass();
0 a61af66fc99e Initial load duke parents: diff changeset	738 _size_offset_table = (method_entry - ((intptr_t*)offset_entry)) / itableOffsetEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	739 _size_method_table = (end - method_entry) / itableMethodEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	740 assert(_table_offset >= 0 && _size_offset_table >= 0 && _size_method_table >= 0, "wrong computation");
a61af66fc99e Initial load duke parents: diff changeset	741 return;
a61af66fc99e Initial load duke parents: diff changeset	742 }
a61af66fc99e Initial load duke parents: diff changeset	743 }
a61af66fc99e Initial load duke parents: diff changeset	744
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	745 // The length of the itable was either zero, or it has not yet been initialized.
0 a61af66fc99e Initial load duke parents: diff changeset	746 _table_offset = 0;
a61af66fc99e Initial load duke parents: diff changeset	747 _size_offset_table = 0;
a61af66fc99e Initial load duke parents: diff changeset	748 _size_method_table = 0;
a61af66fc99e Initial load duke parents: diff changeset	749 }
a61af66fc99e Initial load duke parents: diff changeset	750
a61af66fc99e Initial load duke parents: diff changeset	751 static int initialize_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	752
a61af66fc99e Initial load duke parents: diff changeset	753 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	754 void klassItable::initialize_itable(bool checkconstraints, TRAPS) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	755 if (_klass->is_interface()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	756 // This needs to go after vtable indexes are assigned but
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	757 // before implementors need to know the number of itable indexes.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	758 assign_itable_indexes_for_interface(_klass());
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	759 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	760
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	761 // Cannot be setup doing bootstrapping, interfaces don't have
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	762 // itables, and klass with only ones entry have empty itables
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	763 if (Universe::is_bootstrapping() \|\|
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	764 _klass->is_interface() \|\|
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	765 _klass->itable_length() == itableOffsetEntry::size()) return;
0 a61af66fc99e Initial load duke parents: diff changeset	766
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	767 // There's alway an extra itable entry so we can null-terminate it.
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	768 guarantee(size_offset_table() >= 1, "too small");
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	769 int num_interfaces = size_offset_table() - 1;
0 a61af66fc99e Initial load duke parents: diff changeset	770 if (num_interfaces > 0) {
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	771 if (TraceItables) tty->print_cr("%3d: Initializing itables for %s", ++initialize_count,
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	772 _klass->name()->as_C_string());
0 a61af66fc99e Initial load duke parents: diff changeset	773
a61af66fc99e Initial load duke parents: diff changeset	774
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	775 // Iterate through all interfaces
0 a61af66fc99e Initial load duke parents: diff changeset	776 int i;
a61af66fc99e Initial load duke parents: diff changeset	777 for(i = 0; i < num_interfaces; i++) {
a61af66fc99e Initial load duke parents: diff changeset	778 itableOffsetEntry* ioe = offset_entry(i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	779 HandleMark hm(THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	780 KlassHandle interf_h (THREAD, ioe->interface_klass());
a61af66fc99e Initial load duke parents: diff changeset	781 assert(interf_h() != NULL && ioe->offset() != 0, "bad offset entry in itable");
a61af66fc99e Initial load duke parents: diff changeset	782 initialize_itable_for_interface(ioe->offset(), interf_h, checkconstraints, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	783 }
a61af66fc99e Initial load duke parents: diff changeset	784
a61af66fc99e Initial load duke parents: diff changeset	785 }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	786 // Check that the last entry is empty
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	787 itableOffsetEntry* ioe = offset_entry(size_offset_table() - 1);
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	788 guarantee(ioe->interface_klass() == NULL && ioe->offset() == 0, "terminator entry missing");
0 a61af66fc99e Initial load duke parents: diff changeset	789 }
a61af66fc99e Initial load duke parents: diff changeset	790
a61af66fc99e Initial load duke parents: diff changeset	791
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	792 inline bool interface_method_needs_itable_index(Method* m) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	793 if (m->is_static()) return false; // e.g., Stream.empty
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	794 if (m->is_initializer()) return false; // <init> or <clinit>
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	795 // If an interface redeclares a method from java.lang.Object,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	796 // it should already have a vtable index, don't touch it.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	797 // e.g., CharSequence.toString (from initialize_vtable)
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	798 // if (m->has_vtable_index()) return false; // NO!
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	799 return true;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	800 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	801
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	802 int klassItable::assign_itable_indexes_for_interface(Klass* klass) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	803 // an interface does not have an itable, but its methods need to be numbered
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	804 if (TraceItables) tty->print_cr("%3d: Initializing itable for interface %s", ++initialize_count,
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	805 klass->name()->as_C_string());
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	806 Array<Method> methods = InstanceKlass::cast(klass)->methods();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	807 int nof_methods = methods->length();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	808 int ime_num = 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	809 for (int i = 0; i < nof_methods; i++) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	810 Method* m = methods->at(i);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	811 if (interface_method_needs_itable_index(m)) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	812 assert(!m->is_final_method(), "no final interface methods");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	813 // If m is already assigned a vtable index, do not disturb it.
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	814 if (!m->has_vtable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	815 assert(m->vtable_index() == Method::pending_itable_index, "set by initialize_vtable");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	816 m->set_itable_index(ime_num);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	817 // Progress to next itable entry
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	818 ime_num++;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	819 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	820 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	821 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	822 assert(ime_num == method_count_for_interface(klass), "proper sizing");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	823 return ime_num;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	824 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	825
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	826 int klassItable::method_count_for_interface(Klass* interf) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	827 assert(interf->oop_is_instance(), "must be");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	828 assert(interf->is_interface(), "must be");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	829 Array<Method> methods = InstanceKlass::cast(interf)->methods();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	830 int nof_methods = methods->length();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	831 while (nof_methods > 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	832 Method* m = methods->at(nof_methods-1);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	833 if (m->has_itable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	834 int length = m->itable_index() + 1;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	835 #ifdef ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	836 while (nof_methods = 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	837 m = methods->at(--nof_methods);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	838 assert(!m->has_itable_index() \|\| m->itable_index() < length, "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	839 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	840 #endif //ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	841 return length; // return the rightmost itable index, plus one
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	842 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	843 nof_methods -= 1;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	844 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	845 // no methods have itable indexes
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	846 return 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	847 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	848
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	849
0 a61af66fc99e Initial load duke parents: diff changeset	850 void klassItable::initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	851 Array<Method> methods = InstanceKlass::cast(interf_h())->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	852 int nof_methods = methods->length();
0 a61af66fc99e Initial load duke parents: diff changeset	853 HandleMark hm;
1489 cff162798819 6888953: some calls to function-like macros are missing semicolons jcoomes parents: 676 diff changeset	854 assert(nof_methods > 0, "at least one method must exist for interface to be in vtable");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	855 Handle interface_loader (THREAD, InstanceKlass::cast(interf_h())->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	856
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	857 int ime_count = method_count_for_interface(interf_h());
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	858 for (int i = 0; i < nof_methods; i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	859 Method* m = methods->at(i);
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	860 methodHandle target;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	861 if (m->has_itable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	862 LinkResolver::lookup_instance_method_in_klasses(target, _klass, m->name(), m->signature(), CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	863 }
a61af66fc99e Initial load duke parents: diff changeset	864 if (target == NULL \|\| !target->is_public() \|\| target->is_abstract()) {
a61af66fc99e Initial load duke parents: diff changeset	865 // Entry do not resolve. Leave it empty
a61af66fc99e Initial load duke parents: diff changeset	866 } else {
a61af66fc99e Initial load duke parents: diff changeset	867 // Entry did resolve, check loader constraints before initializing
a61af66fc99e Initial load duke parents: diff changeset	868 // if checkconstraints requested
a61af66fc99e Initial load duke parents: diff changeset	869 if (checkconstraints) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	870 Handle method_holder_loader (THREAD, target->method_holder()->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	871 if (method_holder_loader() != interface_loader()) {
a61af66fc99e Initial load duke parents: diff changeset	872 ResourceMark rm(THREAD);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	873 Symbol* failed_type_symbol =
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	874 SystemDictionary::check_signature_loaders(m->signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	875 method_holder_loader,
a61af66fc99e Initial load duke parents: diff changeset	876 interface_loader,
a61af66fc99e Initial load duke parents: diff changeset	877 true, CHECK);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	878 if (failed_type_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	879 const char* msg = "loader constraint violation in interface "
a61af66fc99e Initial load duke parents: diff changeset	880 "itable initialization: when resolving method \"%s\" the class"
a61af66fc99e Initial load duke parents: diff changeset	881 " loader (instance of %s) of the current class, %s, "
a61af66fc99e Initial load duke parents: diff changeset	882 "and the class loader (instance of %s) for interface "
a61af66fc99e Initial load duke parents: diff changeset	883 "%s have different Class objects for the type %s "
a61af66fc99e Initial load duke parents: diff changeset	884 "used in the signature";
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	885 char* sig = target()->name_and_sig_as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	886 const char* loader1 = SystemDictionary::loader_name(method_holder_loader());
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	887 char* current = _klass->name()->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	888 const char* loader2 = SystemDictionary::loader_name(interface_loader());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	889 char* iface = InstanceKlass::cast(interf_h())->name()->as_C_string();
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	890 char* failed_type_name = failed_type_symbol->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	891 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
a61af66fc99e Initial load duke parents: diff changeset	892 strlen(current) + strlen(loader2) + strlen(iface) +
a61af66fc99e Initial load duke parents: diff changeset	893 strlen(failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	894 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
a61af66fc99e Initial load duke parents: diff changeset	895 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
a61af66fc99e Initial load duke parents: diff changeset	896 iface, failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	897 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
a61af66fc99e Initial load duke parents: diff changeset	898 }
a61af66fc99e Initial load duke parents: diff changeset	899 }
a61af66fc99e Initial load duke parents: diff changeset	900 }
a61af66fc99e Initial load duke parents: diff changeset	901
a61af66fc99e Initial load duke parents: diff changeset	902 // ime may have moved during GC so recalculate address
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	903 int ime_num = m->itable_index();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	904 assert(ime_num < ime_count, "oob");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	905 itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target());
0 a61af66fc99e Initial load duke parents: diff changeset	906 }
a61af66fc99e Initial load duke parents: diff changeset	907 }
a61af66fc99e Initial load duke parents: diff changeset	908 }
a61af66fc99e Initial load duke parents: diff changeset	909
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	910 // Update entry for specific Method*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	911 void klassItable::initialize_with_method(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	912 itableMethodEntry* ime = method_entry(0);
a61af66fc99e Initial load duke parents: diff changeset	913 for(int i = 0; i < _size_method_table; i++) {
a61af66fc99e Initial load duke parents: diff changeset	914 if (ime->method() == m) {
a61af66fc99e Initial load duke parents: diff changeset	915 ime->initialize(m);
a61af66fc99e Initial load duke parents: diff changeset	916 }
a61af66fc99e Initial load duke parents: diff changeset	917 ime++;
a61af66fc99e Initial load duke parents: diff changeset	918 }
a61af66fc99e Initial load duke parents: diff changeset	919 }
a61af66fc99e Initial load duke parents: diff changeset	920
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	921 #if INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	922 void klassItable::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	923 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	924 // search the itable for uses of either obsolete or EMCP methods
a61af66fc99e Initial load duke parents: diff changeset	925 for (int j = 0; j < methods_length; j++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	926 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	927 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	928 itableMethodEntry* ime = method_entry(0);
a61af66fc99e Initial load duke parents: diff changeset	929
610 70998f2e05ef 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined dcubed parents: 196 diff changeset	930 // The itable can describe more than one interface and the same
70998f2e05ef 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined dcubed parents: 196 diff changeset	931 // method signature can be specified by more than one interface.
70998f2e05ef 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined dcubed parents: 196 diff changeset	932 // This means we have to do an exhaustive search to find all the
70998f2e05ef 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined dcubed parents: 196 diff changeset	933 // old_method references.
0 a61af66fc99e Initial load duke parents: diff changeset	934 for (int i = 0; i < _size_method_table; i++) {
a61af66fc99e Initial load duke parents: diff changeset	935 if (ime->method() == old_method) {
a61af66fc99e Initial load duke parents: diff changeset	936 ime->initialize(new_method);
a61af66fc99e Initial load duke parents: diff changeset	937
a61af66fc99e Initial load duke parents: diff changeset	938 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	939 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	940 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	941 RC_TRACE_MESG(("adjust: name=%s",
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	942 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	943 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	944 }
a61af66fc99e Initial load duke parents: diff changeset	945 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	946 RC_TRACE(0x00200000, ("itable method update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	947 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	948 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	949 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	950 // cannot 'break' here; see for-loop comment above.
0 a61af66fc99e Initial load duke parents: diff changeset	951 }
a61af66fc99e Initial load duke parents: diff changeset	952 ime++;
a61af66fc99e Initial load duke parents: diff changeset	953 }
a61af66fc99e Initial load duke parents: diff changeset	954 }
a61af66fc99e Initial load duke parents: diff changeset	955 }
a61af66fc99e Initial load duke parents: diff changeset	956
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	957 // an itable should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	958 bool klassItable::check_no_old_or_obsolete_entries() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	959 itableMethodEntry* ime = method_entry(0);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	960 for (int i = 0; i < _size_method_table; i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	961 Method* m = ime->method();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	962 if (m != NULL &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	963 (NOT_PRODUCT(!m->is_valid() \|\|) m->is_old() \|\| m->is_obsolete())) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	964 return false;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	965 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	966 ime++;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	967 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	968 return true;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	969 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	970
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	971 void klassItable::dump_itable() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	972 itableMethodEntry* ime = method_entry(0);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	973 tty->print_cr("itable dump --");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	974 for (int i = 0; i < _size_method_table; i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	975 Method* m = ime->method();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	976 if (m != NULL) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	977 tty->print(" (%5d) ", i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	978 m->access_flags().print_on(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	979 tty->print(" -- ");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	980 m->print_name(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	981 tty->cr();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	982 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	983 ime++;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	984 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	985 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	986 #endif // INCLUDE_JVMTI
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	987
0 a61af66fc99e Initial load duke parents: diff changeset	988
a61af66fc99e Initial load duke parents: diff changeset	989 // Setup
a61af66fc99e Initial load duke parents: diff changeset	990 class InterfaceVisiterClosure : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	991 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	992 virtual void doit(Klass* intf, int method_count) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	993 };
a61af66fc99e Initial load duke parents: diff changeset	994
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	995 // Visit all interfaces with at least one itable method
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	996 void visit_all_interfaces(Array<Klass> transitive_intf, InterfaceVisiterClosure *blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	997 // Handle array argument
a61af66fc99e Initial load duke parents: diff changeset	998 for(int i = 0; i < transitive_intf->length(); i++) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	999 Klass* intf = transitive_intf->at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	1000 assert(intf->is_interface(), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	1001
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1002 // Find no. of itable methods
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1003 int method_count = 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1004 // method_count = klassItable::method_count_for_interface(intf);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1005 Array<Method> methods = InstanceKlass::cast(intf)->methods();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1006 if (methods->length() > 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1007 for (int i = methods->length(); --i >= 0; ) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1008 if (interface_method_needs_itable_index(methods->at(i))) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1009 method_count++;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1010 }
0 a61af66fc99e Initial load duke parents: diff changeset	1011 }
a61af66fc99e Initial load duke parents: diff changeset	1012 }
a61af66fc99e Initial load duke parents: diff changeset	1013
a61af66fc99e Initial load duke parents: diff changeset	1014 // Only count interfaces with at least one method
a61af66fc99e Initial load duke parents: diff changeset	1015 if (method_count > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1016 blk->doit(intf, method_count);
a61af66fc99e Initial load duke parents: diff changeset	1017 }
a61af66fc99e Initial load duke parents: diff changeset	1018 }
a61af66fc99e Initial load duke parents: diff changeset	1019 }
a61af66fc99e Initial load duke parents: diff changeset	1020
a61af66fc99e Initial load duke parents: diff changeset	1021 class CountInterfacesClosure : public InterfaceVisiterClosure {
a61af66fc99e Initial load duke parents: diff changeset	1022 private:
a61af66fc99e Initial load duke parents: diff changeset	1023 int _nof_methods;
a61af66fc99e Initial load duke parents: diff changeset	1024 int _nof_interfaces;
a61af66fc99e Initial load duke parents: diff changeset	1025 public:
a61af66fc99e Initial load duke parents: diff changeset	1026 CountInterfacesClosure() { _nof_methods = 0; _nof_interfaces = 0; }
a61af66fc99e Initial load duke parents: diff changeset	1027
a61af66fc99e Initial load duke parents: diff changeset	1028 int nof_methods() const { return _nof_methods; }
a61af66fc99e Initial load duke parents: diff changeset	1029 int nof_interfaces() const { return _nof_interfaces; }
a61af66fc99e Initial load duke parents: diff changeset	1030
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1031 void doit(Klass* intf, int method_count) { _nof_methods += method_count; _nof_interfaces++; }
0 a61af66fc99e Initial load duke parents: diff changeset	1032 };
a61af66fc99e Initial load duke parents: diff changeset	1033
a61af66fc99e Initial load duke parents: diff changeset	1034 class SetupItableClosure : public InterfaceVisiterClosure {
a61af66fc99e Initial load duke parents: diff changeset	1035 private:
a61af66fc99e Initial load duke parents: diff changeset	1036 itableOffsetEntry* _offset_entry;
a61af66fc99e Initial load duke parents: diff changeset	1037 itableMethodEntry* _method_entry;
a61af66fc99e Initial load duke parents: diff changeset	1038 address _klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1039 public:
a61af66fc99e Initial load duke parents: diff changeset	1040 SetupItableClosure(address klass_begin, itableOffsetEntry* offset_entry, itableMethodEntry* method_entry) {
a61af66fc99e Initial load duke parents: diff changeset	1041 _klass_begin = klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1042 _offset_entry = offset_entry;
a61af66fc99e Initial load duke parents: diff changeset	1043 _method_entry = method_entry;
a61af66fc99e Initial load duke parents: diff changeset	1044 }
a61af66fc99e Initial load duke parents: diff changeset	1045
a61af66fc99e Initial load duke parents: diff changeset	1046 itableMethodEntry* method_entry() const { return _method_entry; }
a61af66fc99e Initial load duke parents: diff changeset	1047
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1048 void doit(Klass* intf, int method_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	1049 int offset = ((address)_method_entry) - _klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1050 _offset_entry->initialize(intf, offset);
a61af66fc99e Initial load duke parents: diff changeset	1051 _offset_entry++;
a61af66fc99e Initial load duke parents: diff changeset	1052 _method_entry += method_count;
a61af66fc99e Initial load duke parents: diff changeset	1053 }
a61af66fc99e Initial load duke parents: diff changeset	1054 };
a61af66fc99e Initial load duke parents: diff changeset	1055
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1056 int klassItable::compute_itable_size(Array<Klass> transitive_interfaces) {
0 a61af66fc99e Initial load duke parents: diff changeset	1057 // Count no of interfaces and total number of interface methods
a61af66fc99e Initial load duke parents: diff changeset	1058 CountInterfacesClosure cic;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1059 visit_all_interfaces(transitive_interfaces, &cic);
0 a61af66fc99e Initial load duke parents: diff changeset	1060
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1061 // There's alway an extra itable entry so we can null-terminate it.
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1062 int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
0 a61af66fc99e Initial load duke parents: diff changeset	1063
a61af66fc99e Initial load duke parents: diff changeset	1064 // Statistics
a61af66fc99e Initial load duke parents: diff changeset	1065 update_stats(itable_size * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	1066
a61af66fc99e Initial load duke parents: diff changeset	1067 return itable_size;
a61af66fc99e Initial load duke parents: diff changeset	1068 }
a61af66fc99e Initial load duke parents: diff changeset	1069
a61af66fc99e Initial load duke parents: diff changeset	1070
a61af66fc99e Initial load duke parents: diff changeset	1071 // Fill out offset table and interface klasses into the itable space
a61af66fc99e Initial load duke parents: diff changeset	1072 void klassItable::setup_itable_offset_table(instanceKlassHandle klass) {
a61af66fc99e Initial load duke parents: diff changeset	1073 if (klass->itable_length() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1074 assert(!klass->is_interface(), "Should have zero length itable");
a61af66fc99e Initial load duke parents: diff changeset	1075
a61af66fc99e Initial load duke parents: diff changeset	1076 // Count no of interfaces and total number of interface methods
a61af66fc99e Initial load duke parents: diff changeset	1077 CountInterfacesClosure cic;
a61af66fc99e Initial load duke parents: diff changeset	1078 visit_all_interfaces(klass->transitive_interfaces(), &cic);
a61af66fc99e Initial load duke parents: diff changeset	1079 int nof_methods = cic.nof_methods();
a61af66fc99e Initial load duke parents: diff changeset	1080 int nof_interfaces = cic.nof_interfaces();
a61af66fc99e Initial load duke parents: diff changeset	1081
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1082 // Add one extra entry so we can null-terminate the table
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1083 nof_interfaces++;
0 a61af66fc99e Initial load duke parents: diff changeset	1084
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1085 assert(compute_itable_size(klass->transitive_interfaces()) ==
0 a61af66fc99e Initial load duke parents: diff changeset	1086 calc_itable_size(nof_interfaces, nof_methods),
a61af66fc99e Initial load duke parents: diff changeset	1087 "mismatch calculation of itable size");
a61af66fc99e Initial load duke parents: diff changeset	1088
a61af66fc99e Initial load duke parents: diff changeset	1089 // Fill-out offset table
a61af66fc99e Initial load duke parents: diff changeset	1090 itableOffsetEntry* ioe = (itableOffsetEntry*)klass->start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	1091 itableMethodEntry* ime = (itableMethodEntry*)(ioe + nof_interfaces);
a61af66fc99e Initial load duke parents: diff changeset	1092 intptr_t* end = klass->end_of_itable();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2334 diff changeset	1093 assert((oop)(ime + nof_methods) <= (oop)klass->start_of_nonstatic_oop_maps(), "wrong offset calculation (1)");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 16 diff changeset	1094 assert((oop)(end) == (oop)(ime + nof_methods), "wrong offset calculation (2)");
0 a61af66fc99e Initial load duke parents: diff changeset	1095
a61af66fc99e Initial load duke parents: diff changeset	1096 // Visit all interfaces and initialize itable offset table
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1097 SetupItableClosure sic((address)klass(), ioe, ime);
0 a61af66fc99e Initial load duke parents: diff changeset	1098 visit_all_interfaces(klass->transitive_interfaces(), &sic);
a61af66fc99e Initial load duke parents: diff changeset	1099
a61af66fc99e Initial load duke parents: diff changeset	1100 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1101 ime = sic.method_entry();
a61af66fc99e Initial load duke parents: diff changeset	1102 oop* v = (oop*) klass->end_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	1103 assert( (oop*)(ime) == v, "wrong offset calculation (2)");
a61af66fc99e Initial load duke parents: diff changeset	1104 #endif
a61af66fc99e Initial load duke parents: diff changeset	1105 }
a61af66fc99e Initial load duke parents: diff changeset	1106
a61af66fc99e Initial load duke parents: diff changeset	1107
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1108 // inverse to itable_index
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1109 Method* klassItable::method_for_itable_index(Klass* intf, int itable_index) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1110 assert(InstanceKlass::cast(intf)->is_interface(), "sanity check");
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1111 assert(intf->verify_itable_index(itable_index), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1112 Array<Method> methods = InstanceKlass::cast(intf)->methods();
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1113
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1114 if (itable_index < 0 \|\| itable_index >= method_count_for_interface(intf))
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1115 return NULL; // help caller defend against bad indexes
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1116
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1117 int index = itable_index;
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1118 Method* m = methods->at(index);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1119 int index2 = -1;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1120 while (!m->has_itable_index() \|\|
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1121 (index2 = m->itable_index()) != itable_index) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1122 assert(index2 < itable_index, "monotonic");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1123 if (++index == methods->length())
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1124 return NULL;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1125 m = methods->at(index);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1126 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1127 assert(m->itable_index() == itable_index, "correct inverse");
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1128
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1129 return m;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1130 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1131
0 a61af66fc99e Initial load duke parents: diff changeset	1132 void klassVtable::verify(outputStream* st, bool forced) {
a61af66fc99e Initial load duke parents: diff changeset	1133 // make sure table is initialized
a61af66fc99e Initial load duke parents: diff changeset	1134 if (!Universe::is_fully_initialized()) return;
a61af66fc99e Initial load duke parents: diff changeset	1135 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1136 // avoid redundant verifies
a61af66fc99e Initial load duke parents: diff changeset	1137 if (!forced && _verify_count == Universe::verify_count()) return;
a61af66fc99e Initial load duke parents: diff changeset	1138 _verify_count = Universe::verify_count();
a61af66fc99e Initial load duke parents: diff changeset	1139 #endif
a61af66fc99e Initial load duke parents: diff changeset	1140 oop* end_of_obj = (oop*)_klass() + _klass()->size();
a61af66fc99e Initial load duke parents: diff changeset	1141 oop* end_of_vtable = (oop *)&table()[_length];
a61af66fc99e Initial load duke parents: diff changeset	1142 if (end_of_vtable > end_of_obj) {
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1489 diff changeset	1143 fatal(err_msg("klass %s: klass object too short (vtable extends beyond "
f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1489 diff changeset	1144 "end)", _klass->internal_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	1145 }
a61af66fc99e Initial load duke parents: diff changeset	1146
a61af66fc99e Initial load duke parents: diff changeset	1147 for (int i = 0; i < _length; i++) table()[i].verify(this, st);
a61af66fc99e Initial load duke parents: diff changeset	1148 // verify consistency with superKlass vtable
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1149 Klass* super = _klass->super();
0 a61af66fc99e Initial load duke parents: diff changeset	1150 if (super != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1151 InstanceKlass* sk = InstanceKlass::cast(super);
0 a61af66fc99e Initial load duke parents: diff changeset	1152 klassVtable* vt = sk->vtable();
a61af66fc99e Initial load duke parents: diff changeset	1153 for (int i = 0; i < vt->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1154 verify_against(st, vt, i);
a61af66fc99e Initial load duke parents: diff changeset	1155 }
a61af66fc99e Initial load duke parents: diff changeset	1156 }
a61af66fc99e Initial load duke parents: diff changeset	1157 }
a61af66fc99e Initial load duke parents: diff changeset	1158
a61af66fc99e Initial load duke parents: diff changeset	1159 void klassVtable::verify_against(outputStream* st, klassVtable* vt, int index) {
a61af66fc99e Initial load duke parents: diff changeset	1160 vtableEntry* vte = &vt->table()[index];
a61af66fc99e Initial load duke parents: diff changeset	1161 if (vte->method()->name() != table()[index].method()->name() \|\|
a61af66fc99e Initial load duke parents: diff changeset	1162 vte->method()->signature() != table()[index].method()->signature()) {
a61af66fc99e Initial load duke parents: diff changeset	1163 fatal("mismatched name/signature of vtable entries");
a61af66fc99e Initial load duke parents: diff changeset	1164 }
a61af66fc99e Initial load duke parents: diff changeset	1165 }
a61af66fc99e Initial load duke parents: diff changeset	1166
a61af66fc99e Initial load duke parents: diff changeset	1167 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1168 void klassVtable::print() {
a61af66fc99e Initial load duke parents: diff changeset	1169 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1170 tty->print("klassVtable for klass %s (length %d):\n", _klass->internal_name(), length());
a61af66fc99e Initial load duke parents: diff changeset	1171 for (int i = 0; i < length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1172 table()[i].print();
a61af66fc99e Initial load duke parents: diff changeset	1173 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1174 }
a61af66fc99e Initial load duke parents: diff changeset	1175 }
a61af66fc99e Initial load duke parents: diff changeset	1176 #endif
a61af66fc99e Initial load duke parents: diff changeset	1177
a61af66fc99e Initial load duke parents: diff changeset	1178 void vtableEntry::verify(klassVtable* vt, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	1179 NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true));
a61af66fc99e Initial load duke parents: diff changeset	1180 assert(method() != NULL, "must have set method");
a61af66fc99e Initial load duke parents: diff changeset	1181 method()->verify();
a61af66fc99e Initial load duke parents: diff changeset	1182 // we sub_type, because it could be a miranda method
a61af66fc99e Initial load duke parents: diff changeset	1183 if (!vt->klass()->is_subtype_of(method()->method_holder())) {
a61af66fc99e Initial load duke parents: diff changeset	1184 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1185 print();
a61af66fc99e Initial load duke parents: diff changeset	1186 #endif
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1489 diff changeset	1187 fatal(err_msg("vtableEntry " PTR_FORMAT ": method is from subclass", this));
0 a61af66fc99e Initial load duke parents: diff changeset	1188 }
a61af66fc99e Initial load duke parents: diff changeset	1189 }
a61af66fc99e Initial load duke parents: diff changeset	1190
a61af66fc99e Initial load duke parents: diff changeset	1191 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1192
a61af66fc99e Initial load duke parents: diff changeset	1193 void vtableEntry::print() {
a61af66fc99e Initial load duke parents: diff changeset	1194 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1195 tty->print("vtableEntry %s: ", method()->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	1196 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1197 tty->print("m %#lx ", (address)method());
a61af66fc99e Initial load duke parents: diff changeset	1198 }
a61af66fc99e Initial load duke parents: diff changeset	1199 }
a61af66fc99e Initial load duke parents: diff changeset	1200
a61af66fc99e Initial load duke parents: diff changeset	1201 class VtableStats : AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	1202 public:
a61af66fc99e Initial load duke parents: diff changeset	1203 static int no_klasses; // # classes with vtables
a61af66fc99e Initial load duke parents: diff changeset	1204 static int no_array_klasses; // # array classes
a61af66fc99e Initial load duke parents: diff changeset	1205 static int no_instance_klasses; // # instanceKlasses
a61af66fc99e Initial load duke parents: diff changeset	1206 static int sum_of_vtable_len; // total # of vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1207 static int sum_of_array_vtable_len; // total # of vtable entries in array klasses only
a61af66fc99e Initial load duke parents: diff changeset	1208 static int fixed; // total fixed overhead in bytes
a61af66fc99e Initial load duke parents: diff changeset	1209 static int filler; // overhead caused by filler bytes
a61af66fc99e Initial load duke parents: diff changeset	1210 static int entries; // total bytes consumed by vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1211 static int array_entries; // total bytes consumed by array vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1212
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1213 static void do_class(Klass* k) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1214 Klass* kl = k;
0 a61af66fc99e Initial load duke parents: diff changeset	1215 klassVtable* vt = kl->vtable();
a61af66fc99e Initial load duke parents: diff changeset	1216 if (vt == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	1217 no_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1218 if (kl->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	1219 no_instance_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1220 kl->array_klasses_do(do_class);
a61af66fc99e Initial load duke parents: diff changeset	1221 }
a61af66fc99e Initial load duke parents: diff changeset	1222 if (kl->oop_is_array()) {
a61af66fc99e Initial load duke parents: diff changeset	1223 no_array_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1224 sum_of_array_vtable_len += vt->length();
a61af66fc99e Initial load duke parents: diff changeset	1225 }
a61af66fc99e Initial load duke parents: diff changeset	1226 sum_of_vtable_len += vt->length();
a61af66fc99e Initial load duke parents: diff changeset	1227 }
a61af66fc99e Initial load duke parents: diff changeset	1228
a61af66fc99e Initial load duke parents: diff changeset	1229 static void compute() {
a61af66fc99e Initial load duke parents: diff changeset	1230 SystemDictionary::classes_do(do_class);
a61af66fc99e Initial load duke parents: diff changeset	1231 fixed = no_klasses * oopSize; // vtable length
a61af66fc99e Initial load duke parents: diff changeset	1232 // filler size is a conservative approximation
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	1233 filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(ArrayKlass) - 1);
0 a61af66fc99e Initial load duke parents: diff changeset	1234 entries = sizeof(vtableEntry) * sum_of_vtable_len;
a61af66fc99e Initial load duke parents: diff changeset	1235 array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
a61af66fc99e Initial load duke parents: diff changeset	1236 }
a61af66fc99e Initial load duke parents: diff changeset	1237 };
a61af66fc99e Initial load duke parents: diff changeset	1238
a61af66fc99e Initial load duke parents: diff changeset	1239 int VtableStats::no_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1240 int VtableStats::no_array_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1241 int VtableStats::no_instance_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1242 int VtableStats::sum_of_vtable_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	1243 int VtableStats::sum_of_array_vtable_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	1244 int VtableStats::fixed = 0;
a61af66fc99e Initial load duke parents: diff changeset	1245 int VtableStats::filler = 0;
a61af66fc99e Initial load duke parents: diff changeset	1246 int VtableStats::entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	1247 int VtableStats::array_entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	1248
a61af66fc99e Initial load duke parents: diff changeset	1249 void klassVtable::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	1250 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1251 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	1252 VtableStats::compute();
a61af66fc99e Initial load duke parents: diff changeset	1253 tty->print_cr("vtable statistics:");
a61af66fc99e Initial load duke parents: diff changeset	1254 tty->print_cr("%6d classes (%d instance, %d array)", VtableStats::no_klasses, VtableStats::no_instance_klasses, VtableStats::no_array_klasses);
a61af66fc99e Initial load duke parents: diff changeset	1255 int total = VtableStats::fixed + VtableStats::filler + VtableStats::entries;
a61af66fc99e Initial load duke parents: diff changeset	1256 tty->print_cr("%6d bytes fixed overhead (refs + vtable object header)", VtableStats::fixed);
a61af66fc99e Initial load duke parents: diff changeset	1257 tty->print_cr("%6d bytes filler overhead", VtableStats::filler);
a61af66fc99e Initial load duke parents: diff changeset	1258 tty->print_cr("%6d bytes for vtable entries (%d for arrays)", VtableStats::entries, VtableStats::array_entries);
a61af66fc99e Initial load duke parents: diff changeset	1259 tty->print_cr("%6d bytes total", total);
a61af66fc99e Initial load duke parents: diff changeset	1260 }
a61af66fc99e Initial load duke parents: diff changeset	1261
a61af66fc99e Initial load duke parents: diff changeset	1262 int klassItable::_total_classes; // Total no. of classes with itables
a61af66fc99e Initial load duke parents: diff changeset	1263 long klassItable::_total_size; // Total no. of bytes used for itables
a61af66fc99e Initial load duke parents: diff changeset	1264
a61af66fc99e Initial load duke parents: diff changeset	1265 void klassItable::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	1266 tty->print_cr("itable statistics:");
a61af66fc99e Initial load duke parents: diff changeset	1267 tty->print_cr("%6d classes with itables", _total_classes);
a61af66fc99e Initial load duke parents: diff changeset	1268 tty->print_cr("%6d K uses for itables (average by class: %d bytes)", _total_size / K, _total_size / _total_classes);
a61af66fc99e Initial load duke parents: diff changeset	1269 }
a61af66fc99e Initial load duke parents: diff changeset	1270
a61af66fc99e Initial load duke parents: diff changeset	1271 #endif // PRODUCT

Mercurial > hg > truffle

annotate src/share/vm/oops/klassVtable.cpp @ 12264:b2e698d2276c