graal-jvmci-8: src/share/vm/oops/klassVtable.cpp annotate

annotate src/share/vm/oops/klassVtable.cpp @ 12318:36b97be47bde

8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. Reviewed-by: coleenp, bharadwaj, minqi

author	acorn
date	Tue, 01 Oct 2013 08:10:42 -0400
parents	b2e698d2276c
children	ac9cb1d5a202

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
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	295 // private methods in classes 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
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	298 // JDK8 adds private methods in interfaces which require invokespecial
0 a61af66fc99e Initial load duke parents: diff changeset	299 if (target_method()->is_private()) {
a61af66fc99e Initial load duke parents: diff changeset	300 return allocate_new;
a61af66fc99e Initial load duke parents: diff changeset	301 }
a61af66fc99e Initial load duke parents: diff changeset	302
a61af66fc99e Initial load duke parents: diff changeset	303 // search through the vtable and update overridden entries
a61af66fc99e Initial load duke parents: diff changeset	304 // Since check_signature_loaders acquires SystemDictionary_lock
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	305 // 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	306 // For classfiles built with >= jdk7, we now look for transitive overrides
0 a61af66fc99e Initial load duke parents: diff changeset	307
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	308 Symbol* name = target_method()->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	309 Symbol* signature = target_method()->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	310 Handle target_loader(THREAD, _klass()->class_loader());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	311 Symbol* target_classname = _klass->name();
0 a61af66fc99e Initial load duke parents: diff changeset	312 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	313 Method* super_method = method_at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	314 // Check if method name matches
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	315 if (super_method->name() == name && super_method->signature() == signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	316
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	317 // 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	318 InstanceKlass* super_klass = super_method->method_holder();
0 a61af66fc99e Initial load duke parents: diff changeset	319
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	320 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	321 ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	322 && ((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	323 target_classname, THREAD)) != (InstanceKlass*)NULL))) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	324 // overriding, so no new entry
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	325 allocate_new = false;
0 a61af66fc99e Initial load duke parents: diff changeset	326
a61af66fc99e Initial load duke parents: diff changeset	327 if (checkconstraints) {
a61af66fc99e Initial load duke parents: diff changeset	328 // Override vtable entry if passes loader constraint check
a61af66fc99e Initial load duke parents: diff changeset	329 // if loader constraint checking requested
a61af66fc99e Initial load duke parents: diff changeset	330 // No need to visit his super, since he and his super
a61af66fc99e Initial load duke parents: diff changeset	331 // have already made any needed loader constraints.
a61af66fc99e Initial load duke parents: diff changeset	332 // Since loader constraints are transitive, it is enough
a61af66fc99e Initial load duke parents: diff changeset	333 // to link to the first super, and we get all the others.
a61af66fc99e Initial load duke parents: diff changeset	334 Handle super_loader(THREAD, super_klass->class_loader());
a61af66fc99e Initial load duke parents: diff changeset	335
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	336 if (target_loader() != super_loader()) {
0 a61af66fc99e Initial load duke parents: diff changeset	337 ResourceMark rm(THREAD);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	338 Symbol* failed_type_symbol =
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	339 SystemDictionary::check_signature_loaders(signature, target_loader,
0 a61af66fc99e Initial load duke parents: diff changeset	340 super_loader, true,
a61af66fc99e Initial load duke parents: diff changeset	341 CHECK_(false));
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	342 if (failed_type_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	343 const char* msg = "loader constraint violation: when resolving "
a61af66fc99e Initial load duke parents: diff changeset	344 "overridden method \"%s\" the class loader (instance"
a61af66fc99e Initial load duke parents: diff changeset	345 " of %s) of the current class, %s, and its superclass loader "
a61af66fc99e Initial load duke parents: diff changeset	346 "(instance of %s), have different Class objects for the type "
a61af66fc99e Initial load duke parents: diff changeset	347 "%s used in the signature";
a61af66fc99e Initial load duke parents: diff changeset	348 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	349 const char* loader1 = SystemDictionary::loader_name(target_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	350 char* current = _klass->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	351 const char* loader2 = SystemDictionary::loader_name(super_loader());
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	352 char* failed_type_name = failed_type_symbol->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	353 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
a61af66fc99e Initial load duke parents: diff changeset	354 strlen(current) + strlen(loader2) + strlen(failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	355 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
a61af66fc99e Initial load duke parents: diff changeset	356 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
a61af66fc99e Initial load duke parents: diff changeset	357 failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	358 THROW_MSG_(vmSymbols::java_lang_LinkageError(), buf, false);
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 }
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	361 }
0 a61af66fc99e Initial load duke parents: diff changeset	362
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	363 put_method_at(target_method(), i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	364 target_method()->set_vtable_index(i);
0 a61af66fc99e Initial load duke parents: diff changeset	365 #ifndef PRODUCT
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	366 if (PrintVtables && Verbose) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	367 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	368 _klass->internal_name(), (target_method() != NULL) ?
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	369 target_method()->name()->as_C_string() : "<NULL>", i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	370 super_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	371 tty->print("overriders flags: ");
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	372 target_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	373 tty->cr();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	374 }
0 a61af66fc99e Initial load duke parents: diff changeset	375 #endif /PRODUCT/
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	376 } else {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	377 // allocate_new = true; default. We might override one entry,
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	378 // but not override another. Once we override one, not need new
0 a61af66fc99e Initial load duke parents: diff changeset	379 #ifndef PRODUCT
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	380 if (PrintVtables && Verbose) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	381 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	382 _klass->internal_name(), (target_method() != NULL) ?
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	383 target_method()->name()->as_C_string() : "<NULL>", i);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	384 super_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	385 tty->print("overriders flags: ");
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	386 target_method->access_flags().print_on(tty);
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	387 tty->cr();
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	388 }
0 a61af66fc99e Initial load duke parents: diff changeset	389 #endif /PRODUCT/
a61af66fc99e Initial load duke parents: diff changeset	390 }
a61af66fc99e Initial load duke parents: diff changeset	391 }
a61af66fc99e Initial load duke parents: diff changeset	392 }
a61af66fc99e Initial load duke parents: diff changeset	393 return allocate_new;
a61af66fc99e Initial load duke parents: diff changeset	394 }
a61af66fc99e Initial load duke parents: diff changeset	395
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	396 void klassVtable::put_method_at(Method* m, int index) {
0 a61af66fc99e Initial load duke parents: diff changeset	397 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	398 if (PrintVtables && Verbose) {
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	399 ResourceMark rm;
0 a61af66fc99e Initial load duke parents: diff changeset	400 tty->print_cr("adding %s::%s at index %d", _klass->internal_name(),
a61af66fc99e Initial load duke parents: diff changeset	401 (m != NULL) ? m->name()->as_C_string() : "<NULL>", index);
a61af66fc99e Initial load duke parents: diff changeset	402 }
a61af66fc99e Initial load duke parents: diff changeset	403 #endif
a61af66fc99e Initial load duke parents: diff changeset	404 table()[index].set(m);
a61af66fc99e Initial load duke parents: diff changeset	405 }
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // Find out if a method "m" with superclass "super", loader "classloader" and
a61af66fc99e Initial load duke parents: diff changeset	408 // name "classname" needs a new vtable entry. Let P be a class package defined
a61af66fc99e Initial load duke parents: diff changeset	409 // by "classloader" and "classname".
a61af66fc99e Initial load duke parents: diff changeset	410 // NOTE: The logic used here is very similar to the one used for computing
a61af66fc99e Initial load duke parents: diff changeset	411 // 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	412 // 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	413 // superclass has been loaded.
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	414 // 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	415 // 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	416 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	417 Klass* super,
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	418 Handle classloader,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	419 Symbol* classname,
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	420 AccessFlags class_flags,
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	421 TRAPS) {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	422 if (class_flags.is_interface()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	423 // 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	424 // 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	425 // 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	426 return false;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	427 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	428
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	429 if (target_method->is_final_method(class_flags) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	430 // a final method never needs a new entry; final methods can be statically
a61af66fc99e Initial load duke parents: diff changeset	431 // resolved and they have to be present in the vtable only if they override
a61af66fc99e Initial load duke parents: diff changeset	432 // 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	433 (target_method()->is_static()) \|\|
0 a61af66fc99e Initial load duke parents: diff changeset	434 // 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	435 (target_method()->name() == vmSymbols::object_initializer_name())
0 a61af66fc99e Initial load duke parents: diff changeset	436 // <init> is never called dynamically-bound
a61af66fc99e Initial load duke parents: diff changeset	437 ) {
a61af66fc99e Initial load duke parents: diff changeset	438 return false;
a61af66fc99e Initial load duke parents: diff changeset	439 }
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 // we need a new entry if there is no superclass
a61af66fc99e Initial load duke parents: diff changeset	442 if (super == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	443 return true;
a61af66fc99e Initial load duke parents: diff changeset	444 }
a61af66fc99e Initial load duke parents: diff changeset	445
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	446 // private methods in classes always have a new entry in the vtable
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	447 // specification interpretation since classic has
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	448 // private methods not overriding
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	449 // JDK8 adds private methods in interfaces which require invokespecial
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	450 if (target_method()->is_private()) {
0 a61af66fc99e Initial load duke parents: diff changeset	451 return true;
a61af66fc99e Initial load duke parents: diff changeset	452 }
a61af66fc99e Initial load duke parents: diff changeset	453
a61af66fc99e Initial load duke parents: diff changeset	454 // search through the super class hierarchy to see if we need
a61af66fc99e Initial load duke parents: diff changeset	455 // a new entry
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	456 ResourceMark rm;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	457 Symbol* name = target_method()->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	458 Symbol* signature = target_method()->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	459 Klass* k = super;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	460 Method* super_method = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	461 InstanceKlass *holder = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	462 Method* recheck_method = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	463 while (k != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	464 // 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	465 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	466 if (super_method == NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	467 break; // we still have to search for a matching miranda method
a61af66fc99e Initial load duke parents: diff changeset	468 }
a61af66fc99e Initial load duke parents: diff changeset	469 // get the class holding the matching method
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	470 // 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	471 InstanceKlass* superk = super_method->method_holder();
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	472 // we want only instance method matches
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	473 // pretend private methods are not in the super vtable
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	474 // 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	475 // 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	476 // 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	477 // methods that have less accessibility
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	478 if ((!super_method->is_static()) &&
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	479 (!super_method->is_private())) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	480 if (superk->is_override(super_method, classloader, classname, THREAD)) {
0 a61af66fc99e Initial load duke parents: diff changeset	481 return false;
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	482 // else keep looking for transitive overrides
0 a61af66fc99e Initial load duke parents: diff changeset	483 }
a61af66fc99e Initial load duke parents: diff changeset	484 }
a61af66fc99e Initial load duke parents: diff changeset	485
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	486 // Start with lookup result and continue to search up
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	487 k = superk->super(); // haven't found an override match yet; continue to look
0 a61af66fc99e Initial load duke parents: diff changeset	488 }
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490 // if the target method is public or protected it may have a matching
a61af66fc99e Initial load duke parents: diff changeset	491 // 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	492 // 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	493 // this check for all access permissions.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	494 InstanceKlass *sk = InstanceKlass::cast(super);
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	495 if (sk->has_miranda_methods()) {
4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	496 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	497 return false; // found a matching miranda; we do not need a new entry
0 a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500 return true; // found no match; we need a new entry
a61af66fc99e Initial load duke parents: diff changeset	501 }
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 // Support for miranda methods
a61af66fc99e Initial load duke parents: diff changeset	504
a61af66fc99e Initial load duke parents: diff changeset	505 // 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	506 int klassVtable::index_of_miranda(Symbol* name, Symbol* signature) {
0 a61af66fc99e Initial load duke parents: diff changeset	507 // search from the bottom, might be faster
a61af66fc99e Initial load duke parents: diff changeset	508 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	509 Method* m = table()[i].method();
0 a61af66fc99e Initial load duke parents: diff changeset	510 if (is_miranda_entry_at(i) &&
a61af66fc99e Initial load duke parents: diff changeset	511 m->name() == name && m->signature() == signature) {
a61af66fc99e Initial load duke parents: diff changeset	512 return i;
a61af66fc99e Initial load duke parents: diff changeset	513 }
a61af66fc99e Initial load duke parents: diff changeset	514 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	515 return Method::invalid_vtable_index;
0 a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	518 // 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	519 // requires that method m at entry be declared ("held") by an interface.
0 a61af66fc99e Initial load duke parents: diff changeset	520 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	521 Method* m = method_at(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	522 Klass* method_holder = m->method_holder();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	523 InstanceKlass *mhk = InstanceKlass::cast(method_holder);
0 a61af66fc99e Initial load duke parents: diff changeset	524
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	525 // miranda methods are public abstract instance interface methods in a class's vtable
0 a61af66fc99e Initial load duke parents: diff changeset	526 if (mhk->is_interface()) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	527 assert(m->is_public(), "should be public");
0 a61af66fc99e Initial load duke parents: diff changeset	528 assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
a61af66fc99e Initial load duke parents: diff changeset	529 assert(is_miranda(m, ik()->methods(), ik()->super()), "should be a miranda_method");
a61af66fc99e Initial load duke parents: diff changeset	530 return true;
a61af66fc99e Initial load duke parents: diff changeset	531 }
a61af66fc99e Initial load duke parents: diff changeset	532 return false;
a61af66fc99e Initial load duke parents: diff changeset	533 }
a61af66fc99e Initial load duke parents: diff changeset	534
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	535 // 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	536 // "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	537 // in super unless it is private and therefore inaccessible to this class.
0 a61af66fc99e Initial load duke parents: diff changeset	538 // the caller must make sure that the method belongs to an interface implemented by the class
12318 36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	539 // Miranda methods only include public interface instance methods
36b97be47bde 8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default. acorn parents: 12264 diff changeset	540 // Not private methods, not static methods, not default = concrete abstract
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	541 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	542 if (m->is_static()) {
08236d966eea 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87 bharadwaj parents: 8840 diff changeset	543 return false;
08236d966eea 8013418: assert(i == total_args_passed) in AdapterHandlerLibrary::get_adapter since 8-b87 bharadwaj parents: 8840 diff changeset	544 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	545 Symbol* name = m->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2018 diff changeset	546 Symbol* signature = m->signature();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	547 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	548 // did not find it in the method table of the current class
0 a61af66fc99e Initial load duke parents: diff changeset	549 if (super == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	550 // super doesn't exist
a61af66fc99e Initial load duke parents: diff changeset	551 return true;
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	552 }
642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	553
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	554 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	555 if (mo == NULL \|\| mo->access_flags().is_private() ) {
642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	556 // 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	557 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559 }
2018 642e54d1850a 6989076: JVM crashes in klassItable::initialize_itable_for_interface dsamersoff parents: 1972 diff changeset	560
0 a61af66fc99e Initial load duke parents: diff changeset	561 return false;
a61af66fc99e Initial load duke parents: diff changeset	562 }
a61af66fc99e Initial load duke parents: diff changeset	563
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	564 // 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	565 // 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	566 // 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	567 // 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	568 // 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	569 // 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	570 // 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	571 // including all defined in superclasses.
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	572 void klassVtable::add_new_mirandas_to_lists(
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	573 GrowableArray<Method> new_mirandas, GrowableArray<Method> all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	574 Array<Method> current_interface_methods, Array<Method> class_methods,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	575 Klass* super) {
0 a61af66fc99e Initial load duke parents: diff changeset	576 // iterate thru the current interface's method to see if it a miranda
a61af66fc99e Initial load duke parents: diff changeset	577 int num_methods = current_interface_methods->length();
a61af66fc99e Initial load duke parents: diff changeset	578 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	579 Method* im = current_interface_methods->at(i);
0 a61af66fc99e Initial load duke parents: diff changeset	580 bool is_duplicate = false;
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	581 int num_of_current_mirandas = new_mirandas->length();
0 a61af66fc99e Initial load duke parents: diff changeset	582 // check for duplicate mirandas in different interfaces we implement
a61af66fc99e Initial load duke parents: diff changeset	583 for (int j = 0; j < num_of_current_mirandas; j++) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	584 Method* miranda = new_mirandas->at(j);
0 a61af66fc99e Initial load duke parents: diff changeset	585 if ((im->name() == miranda->name()) &&
a61af66fc99e Initial load duke parents: diff changeset	586 (im->signature() == miranda->signature())) {
a61af66fc99e Initial load duke parents: diff changeset	587 is_duplicate = true;
a61af66fc99e Initial load duke parents: diff changeset	588 break;
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590 }
a61af66fc99e Initial load duke parents: diff changeset	591
a61af66fc99e Initial load duke parents: diff changeset	592 if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
a61af66fc99e Initial load duke parents: diff changeset	593 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	594 InstanceKlass *sk = InstanceKlass::cast(super);
0 a61af66fc99e Initial load duke parents: diff changeset	595 // check if it is a duplicate of a super's miranda
a61af66fc99e Initial load duke parents: diff changeset	596 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	597 new_mirandas->append(im);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	598 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	599 if (all_mirandas != NULL) {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	600 all_mirandas->append(im);
0 a61af66fc99e Initial load duke parents: diff changeset	601 }
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605 }
a61af66fc99e Initial load duke parents: diff changeset	606
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	607 void klassVtable::get_mirandas(GrowableArray<Method> new_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	608 GrowableArray<Method> all_mirandas,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	609 Klass* super, Array<Method> class_methods,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	610 Array<Klass> local_interfaces) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	611 assert((new_mirandas->length() == 0) , "current mirandas must be 0");
0 a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 // iterate thru the local interfaces looking for a miranda
a61af66fc99e Initial load duke parents: diff changeset	614 int num_local_ifs = local_interfaces->length();
a61af66fc99e Initial load duke parents: diff changeset	615 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	616 InstanceKlass *ik = InstanceKlass::cast(local_interfaces->at(i));
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	617 add_new_mirandas_to_lists(new_mirandas, all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	618 ik->methods(), class_methods, super);
0 a61af66fc99e Initial load duke parents: diff changeset	619 // iterate thru each local's super interfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	620 Array<Klass> super_ifs = ik->transitive_interfaces();
0 a61af66fc99e Initial load duke parents: diff changeset	621 int num_super_ifs = super_ifs->length();
a61af66fc99e Initial load duke parents: diff changeset	622 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	623 InstanceKlass *sik = InstanceKlass::cast(super_ifs->at(j));
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	624 add_new_mirandas_to_lists(new_mirandas, all_mirandas,
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	625 sik->methods(), class_methods, super);
0 a61af66fc99e Initial load duke parents: diff changeset	626 }
a61af66fc99e Initial load duke parents: diff changeset	627 }
a61af66fc99e Initial load duke parents: diff changeset	628 }
a61af66fc99e Initial load duke parents: diff changeset	629
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	630 // 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	631 // 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	632 // 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	633 int klassVtable::fill_in_mirandas(int initialized) {
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	634 GrowableArray<Method*> mirandas(20);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	635 get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	636 ik()->local_interfaces());
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6831 diff changeset	637 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	638 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	639 ++initialized;
0 a61af66fc99e Initial load duke parents: diff changeset	640 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	641 return initialized;
0 a61af66fc99e Initial load duke parents: diff changeset	642 }
a61af66fc99e Initial load duke parents: diff changeset	643
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	644 // 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	645 // Used to copy superclass vtable to prefix of subclass's vtable.
0 a61af66fc99e Initial load duke parents: diff changeset	646 void klassVtable::copy_vtable_to(vtableEntry* start) {
a61af66fc99e Initial load duke parents: diff changeset	647 Copy::disjoint_words((HeapWord)table(), (HeapWord)start, _length * vtableEntry::size());
a61af66fc99e Initial load duke parents: diff changeset	648 }
a61af66fc99e Initial load duke parents: diff changeset	649
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	650 #if INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	651 void klassVtable::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	652 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	653 // search the vtable for uses of either obsolete or EMCP methods
a61af66fc99e Initial load duke parents: diff changeset	654 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	655 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	656 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	657
a61af66fc99e Initial load duke parents: diff changeset	658 // In the vast majority of cases we could get the vtable index
a61af66fc99e Initial load duke parents: diff changeset	659 // by using: old_method->vtable_index()
a61af66fc99e Initial load duke parents: diff changeset	660 // However, there are rare cases, eg. sun.awt.X11.XDecoratedPeer.getX()
a61af66fc99e Initial load duke parents: diff changeset	661 // in sun.awt.X11.XFramePeer where methods occur more than once in the
a61af66fc99e Initial load duke parents: diff changeset	662 // vtable, so, alas, we must do an exhaustive search.
a61af66fc99e Initial load duke parents: diff changeset	663 for (int index = 0; index < length(); index++) {
a61af66fc99e Initial load duke parents: diff changeset	664 if (unchecked_method_at(index) == old_method) {
a61af66fc99e Initial load duke parents: diff changeset	665 put_method_at(new_method, index);
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	668 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	669 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	670 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	671 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	672 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	673 }
a61af66fc99e Initial load duke parents: diff changeset	674 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	675 RC_TRACE(0x00100000, ("vtable method update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	676 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	677 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	678 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	679 // cannot 'break' here; see for-loop comment above.
0 a61af66fc99e Initial load duke parents: diff changeset	680 }
a61af66fc99e Initial load duke parents: diff changeset	681 }
a61af66fc99e Initial load duke parents: diff changeset	682 }
a61af66fc99e Initial load duke parents: diff changeset	683 }
a61af66fc99e Initial load duke parents: diff changeset	684
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	685 // a vtable should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	686 bool klassVtable::check_no_old_or_obsolete_entries() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	687 for (int i = 0; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	688 Method* m = unchecked_method_at(i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	689 if (m != NULL &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	690 (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	691 return false;
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 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	694 return true;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	695 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	696
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	697 void klassVtable::dump_vtable() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	698 tty->print_cr("vtable dump --");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	699 for (int i = 0; i < length(); i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	700 Method* m = unchecked_method_at(i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	701 if (m != NULL) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	702 tty->print(" (%5d) ", i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	703 m->access_flags().print_on(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	704 tty->print(" -- ");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	705 m->print_name(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	706 tty->cr();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	707 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	708 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	709 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	710 #endif // INCLUDE_JVMTI
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	711
3245 8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	712 // CDS/RedefineClasses support - clear vtables so they can be reinitialized
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	713 void klassVtable::clear_vtable() {
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	714 for (int i = 0; i < _length; i++) table()[i].clear();
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
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	717 bool klassVtable::is_initialized() {
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	718 return _length == 0 \|\| table()[0].method() != NULL;
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	719 }
8ce625481709 7032407: Crash in LinkResolver::runtime_resolve_virtual_method() coleenp parents: 2376 diff changeset	720
0 a61af66fc99e Initial load duke parents: diff changeset	721 //-----------------------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	722 // Itable code
a61af66fc99e Initial load duke parents: diff changeset	723
a61af66fc99e Initial load duke parents: diff changeset	724 // Initialize a itableMethodEntry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	725 void itableMethodEntry::initialize(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	726 if (m == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	727
a61af66fc99e Initial load duke parents: diff changeset	728 _method = m;
a61af66fc99e Initial load duke parents: diff changeset	729 }
a61af66fc99e Initial load duke parents: diff changeset	730
a61af66fc99e Initial load duke parents: diff changeset	731 klassItable::klassItable(instanceKlassHandle klass) {
a61af66fc99e Initial load duke parents: diff changeset	732 _klass = klass;
a61af66fc99e Initial load duke parents: diff changeset	733
a61af66fc99e Initial load duke parents: diff changeset	734 if (klass->itable_length() > 0) {
a61af66fc99e Initial load duke parents: diff changeset	735 itableOffsetEntry* offset_entry = (itableOffsetEntry*)klass->start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	736 if (offset_entry != NULL && offset_entry->interface_klass() != NULL) { // Check that itable is initialized
a61af66fc99e Initial load duke parents: diff changeset	737 // 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	738 intptr_t* method_entry = (intptr_t *)(((address)klass()) + offset_entry->offset());
0 a61af66fc99e Initial load duke parents: diff changeset	739 intptr_t* end = klass->end_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	740
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	741 _table_offset = (intptr_t)offset_entry - (intptr_t)klass();
0 a61af66fc99e Initial load duke parents: diff changeset	742 _size_offset_table = (method_entry - ((intptr_t*)offset_entry)) / itableOffsetEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	743 _size_method_table = (end - method_entry) / itableMethodEntry::size();
a61af66fc99e Initial load duke parents: diff changeset	744 assert(_table_offset >= 0 && _size_offset_table >= 0 && _size_method_table >= 0, "wrong computation");
a61af66fc99e Initial load duke parents: diff changeset	745 return;
a61af66fc99e Initial load duke parents: diff changeset	746 }
a61af66fc99e Initial load duke parents: diff changeset	747 }
a61af66fc99e Initial load duke parents: diff changeset	748
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	749 // The length of the itable was either zero, or it has not yet been initialized.
0 a61af66fc99e Initial load duke parents: diff changeset	750 _table_offset = 0;
a61af66fc99e Initial load duke parents: diff changeset	751 _size_offset_table = 0;
a61af66fc99e Initial load duke parents: diff changeset	752 _size_method_table = 0;
a61af66fc99e Initial load duke parents: diff changeset	753 }
a61af66fc99e Initial load duke parents: diff changeset	754
a61af66fc99e Initial load duke parents: diff changeset	755 static int initialize_count = 0;
a61af66fc99e Initial load duke parents: diff changeset	756
a61af66fc99e Initial load duke parents: diff changeset	757 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	758 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	759 if (_klass->is_interface()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	760 // 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	761 // 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	762 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	763 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	764
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	765 // 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	766 // 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	767 if (Universe::is_bootstrapping() \|\|
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	768 _klass->is_interface() \|\|
f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	769 _klass->itable_length() == itableOffsetEntry::size()) return;
0 a61af66fc99e Initial load duke parents: diff changeset	770
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	771 // 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	772 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	773 int num_interfaces = size_offset_table() - 1;
0 a61af66fc99e Initial load duke parents: diff changeset	774 if (num_interfaces > 0) {
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	775 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	776 _klass->name()->as_C_string());
0 a61af66fc99e Initial load duke parents: diff changeset	777
a61af66fc99e Initial load duke parents: diff changeset	778
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 610 diff changeset	779 // Iterate through all interfaces
0 a61af66fc99e Initial load duke parents: diff changeset	780 int i;
a61af66fc99e Initial load duke parents: diff changeset	781 for(i = 0; i < num_interfaces; i++) {
a61af66fc99e Initial load duke parents: diff changeset	782 itableOffsetEntry* ioe = offset_entry(i);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	783 HandleMark hm(THREAD);
0 a61af66fc99e Initial load duke parents: diff changeset	784 KlassHandle interf_h (THREAD, ioe->interface_klass());
a61af66fc99e Initial load duke parents: diff changeset	785 assert(interf_h() != NULL && ioe->offset() != 0, "bad offset entry in itable");
a61af66fc99e Initial load duke parents: diff changeset	786 initialize_itable_for_interface(ioe->offset(), interf_h, checkconstraints, CHECK);
a61af66fc99e Initial load duke parents: diff changeset	787 }
a61af66fc99e Initial load duke parents: diff changeset	788
a61af66fc99e Initial load duke parents: diff changeset	789 }
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	790 // 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	791 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	792 guarantee(ioe->interface_klass() == NULL && ioe->offset() == 0, "terminator entry missing");
0 a61af66fc99e Initial load duke parents: diff changeset	793 }
a61af66fc99e Initial load duke parents: diff changeset	794
a61af66fc99e Initial load duke parents: diff changeset	795
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	796 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	797 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	798 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	799 // 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	800 // 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	801 // 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	802 // 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	803 return true;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	804 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	805
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	806 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	807 // 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	808 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	809 klass->name()->as_C_string());
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	810 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	811 int nof_methods = methods->length();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	812 int ime_num = 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	813 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	814 Method* m = methods->at(i);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	815 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	816 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	817 // 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	818 if (!m->has_vtable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	819 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	820 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	821 // Progress to next itable entry
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	822 ime_num++;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	823 }
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 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	827 return ime_num;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	828 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	829
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	830 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	831 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	832 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	833 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	834 int nof_methods = methods->length();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	835 while (nof_methods > 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	836 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	837 if (m->has_itable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	838 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	839 #ifdef ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	840 while (nof_methods = 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	841 m = methods->at(--nof_methods);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	842 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	843 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	844 #endif //ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	845 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	846 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	847 nof_methods -= 1;
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 // no methods have itable indexes
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	850 return 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	851 }
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	852
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	853
0 a61af66fc99e Initial load duke parents: diff changeset	854 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	855 Array<Method> methods = InstanceKlass::cast(interf_h())->methods();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	856 int nof_methods = methods->length();
0 a61af66fc99e Initial load duke parents: diff changeset	857 HandleMark hm;
1489 cff162798819 6888953: some calls to function-like macros are missing semicolons jcoomes parents: 676 diff changeset	858 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	859 Handle interface_loader (THREAD, InstanceKlass::cast(interf_h())->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	860
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	861 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	862 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	863 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	864 methodHandle target;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	865 if (m->has_itable_index()) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	866 LinkResolver::lookup_instance_method_in_klasses(target, _klass, m->name(), m->signature(), CHECK);
0 a61af66fc99e Initial load duke parents: diff changeset	867 }
a61af66fc99e Initial load duke parents: diff changeset	868 if (target == NULL \|\| !target->is_public() \|\| target->is_abstract()) {
a61af66fc99e Initial load duke parents: diff changeset	869 // Entry do not resolve. Leave it empty
a61af66fc99e Initial load duke parents: diff changeset	870 } else {
a61af66fc99e Initial load duke parents: diff changeset	871 // Entry did resolve, check loader constraints before initializing
a61af66fc99e Initial load duke parents: diff changeset	872 // if checkconstraints requested
a61af66fc99e Initial load duke parents: diff changeset	873 if (checkconstraints) {
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6934 diff changeset	874 Handle method_holder_loader (THREAD, target->method_holder()->class_loader());
0 a61af66fc99e Initial load duke parents: diff changeset	875 if (method_holder_loader() != interface_loader()) {
a61af66fc99e Initial load duke parents: diff changeset	876 ResourceMark rm(THREAD);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	877 Symbol* failed_type_symbol =
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	878 SystemDictionary::check_signature_loaders(m->signature(),
0 a61af66fc99e Initial load duke parents: diff changeset	879 method_holder_loader,
a61af66fc99e Initial load duke parents: diff changeset	880 interface_loader,
a61af66fc99e Initial load duke parents: diff changeset	881 true, CHECK);
8840 cd3089a56438 8009731: Confusing error message for loader constraint violation acorn parents: 8021 diff changeset	882 if (failed_type_symbol != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	883 const char* msg = "loader constraint violation in interface "
a61af66fc99e Initial load duke parents: diff changeset	884 "itable initialization: when resolving method \"%s\" the class"
a61af66fc99e Initial load duke parents: diff changeset	885 " loader (instance of %s) of the current class, %s, "
a61af66fc99e Initial load duke parents: diff changeset	886 "and the class loader (instance of %s) for interface "
a61af66fc99e Initial load duke parents: diff changeset	887 "%s have different Class objects for the type %s "
a61af66fc99e Initial load duke parents: diff changeset	888 "used in the signature";
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	889 char* sig = target()->name_and_sig_as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	890 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	891 char* current = _klass->name()->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	892 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	893 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	894 char* failed_type_name = failed_type_symbol->as_C_string();
0 a61af66fc99e Initial load duke parents: diff changeset	895 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
a61af66fc99e Initial load duke parents: diff changeset	896 strlen(current) + strlen(loader2) + strlen(iface) +
a61af66fc99e Initial load duke parents: diff changeset	897 strlen(failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	898 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
a61af66fc99e Initial load duke parents: diff changeset	899 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2,
a61af66fc99e Initial load duke parents: diff changeset	900 iface, failed_type_name);
a61af66fc99e Initial load duke parents: diff changeset	901 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
a61af66fc99e Initial load duke parents: diff changeset	902 }
a61af66fc99e Initial load duke parents: diff changeset	903 }
a61af66fc99e Initial load duke parents: diff changeset	904 }
a61af66fc99e Initial load duke parents: diff changeset	905
a61af66fc99e Initial load duke parents: diff changeset	906 // 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	907 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	908 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	909 itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target());
0 a61af66fc99e Initial load duke parents: diff changeset	910 }
a61af66fc99e Initial load duke parents: diff changeset	911 }
a61af66fc99e Initial load duke parents: diff changeset	912 }
a61af66fc99e Initial load duke parents: diff changeset	913
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	914 // Update entry for specific Method*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	915 void klassItable::initialize_with_method(Method* m) {
0 a61af66fc99e Initial load duke parents: diff changeset	916 itableMethodEntry* ime = method_entry(0);
a61af66fc99e Initial load duke parents: diff changeset	917 for(int i = 0; i < _size_method_table; i++) {
a61af66fc99e Initial load duke parents: diff changeset	918 if (ime->method() == m) {
a61af66fc99e Initial load duke parents: diff changeset	919 ime->initialize(m);
a61af66fc99e Initial load duke parents: diff changeset	920 }
a61af66fc99e Initial load duke parents: diff changeset	921 ime++;
a61af66fc99e Initial load duke parents: diff changeset	922 }
a61af66fc99e Initial load duke parents: diff changeset	923 }
a61af66fc99e Initial load duke parents: diff changeset	924
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	925 #if INCLUDE_JVMTI
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	926 void klassItable::adjust_method_entries(Method old_methods, Method new_methods,
0 a61af66fc99e Initial load duke parents: diff changeset	927 int methods_length, bool * trace_name_printed) {
a61af66fc99e Initial load duke parents: diff changeset	928 // search the itable for uses of either obsolete or EMCP methods
a61af66fc99e Initial load duke parents: diff changeset	929 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	930 Method* old_method = old_methods[j];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	931 Method* new_method = new_methods[j];
0 a61af66fc99e Initial load duke parents: diff changeset	932 itableMethodEntry* ime = method_entry(0);
a61af66fc99e Initial load duke parents: diff changeset	933
610 70998f2e05ef 6805864: 4/3 Problem with jvmti->redefineClasses: some methods don't get redefined dcubed parents: 196 diff changeset	934 // 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	935 // 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	936 // 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	937 // old_method references.
0 a61af66fc99e Initial load duke parents: diff changeset	938 for (int i = 0; i < _size_method_table; i++) {
a61af66fc99e Initial load duke parents: diff changeset	939 if (ime->method() == old_method) {
a61af66fc99e Initial load duke parents: diff changeset	940 ime->initialize(new_method);
a61af66fc99e Initial load duke parents: diff changeset	941
a61af66fc99e Initial load duke parents: diff changeset	942 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
a61af66fc99e Initial load duke parents: diff changeset	943 if (!(*trace_name_printed)) {
a61af66fc99e Initial load duke parents: diff changeset	944 // RC_TRACE_MESG macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	945 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	946 old_method->method_holder()->external_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	947 *trace_name_printed = true;
a61af66fc99e Initial load duke parents: diff changeset	948 }
a61af66fc99e Initial load duke parents: diff changeset	949 // RC_TRACE macro has an embedded ResourceMark
a61af66fc99e Initial load duke parents: diff changeset	950 RC_TRACE(0x00200000, ("itable method update: %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	951 new_method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	952 new_method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	953 }
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	954 // cannot 'break' here; see for-loop comment above.
0 a61af66fc99e Initial load duke parents: diff changeset	955 }
a61af66fc99e Initial load duke parents: diff changeset	956 ime++;
a61af66fc99e Initial load duke parents: diff changeset	957 }
a61af66fc99e Initial load duke parents: diff changeset	958 }
a61af66fc99e Initial load duke parents: diff changeset	959 }
a61af66fc99e Initial load duke parents: diff changeset	960
8021 8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	961 // an itable should never contain old or obsolete methods
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	962 bool klassItable::check_no_old_or_obsolete_entries() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	963 itableMethodEntry* ime = method_entry(0);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	964 for (int i = 0; i < _size_method_table; i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	965 Method* m = ime->method();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	966 if (m != NULL &&
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	967 (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	968 return false;
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 ime++;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	971 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	972 return true;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	973 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	974
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	975 void klassItable::dump_itable() {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	976 itableMethodEntry* ime = method_entry(0);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	977 tty->print_cr("itable dump --");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	978 for (int i = 0; i < _size_method_table; i++) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	979 Method* m = ime->method();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	980 if (m != NULL) {
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	981 tty->print(" (%5d) ", i);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	982 m->access_flags().print_on(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	983 tty->print(" -- ");
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	984 m->print_name(tty);
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	985 tty->cr();
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	986 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	987 ime++;
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	988 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	989 }
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	990 #endif // INCLUDE_JVMTI
8d9fc28831cc 7182152: Instrumentation hot swap test incorrect monitor count dcubed parents: 6983 diff changeset	991
0 a61af66fc99e Initial load duke parents: diff changeset	992
a61af66fc99e Initial load duke parents: diff changeset	993 // Setup
a61af66fc99e Initial load duke parents: diff changeset	994 class InterfaceVisiterClosure : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	995 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	996 virtual void doit(Klass* intf, int method_count) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	997 };
a61af66fc99e Initial load duke parents: diff changeset	998
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	999 // 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	1000 void visit_all_interfaces(Array<Klass> transitive_intf, InterfaceVisiterClosure *blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	1001 // Handle array argument
a61af66fc99e Initial load duke parents: diff changeset	1002 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	1003 Klass* intf = transitive_intf->at(i);
6983 070d523b96a7 8001471: Klass::cast() does nothing hseigel parents: 6940 diff changeset	1004 assert(intf->is_interface(), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	1005
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1006 // Find no. of itable methods
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1007 int method_count = 0;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1008 // 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	1009 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	1010 if (methods->length() > 0) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1011 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	1012 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	1013 method_count++;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1014 }
0 a61af66fc99e Initial load duke parents: diff changeset	1015 }
a61af66fc99e Initial load duke parents: diff changeset	1016 }
a61af66fc99e Initial load duke parents: diff changeset	1017
a61af66fc99e Initial load duke parents: diff changeset	1018 // Only count interfaces with at least one method
a61af66fc99e Initial load duke parents: diff changeset	1019 if (method_count > 0) {
a61af66fc99e Initial load duke parents: diff changeset	1020 blk->doit(intf, method_count);
a61af66fc99e Initial load duke parents: diff changeset	1021 }
a61af66fc99e Initial load duke parents: diff changeset	1022 }
a61af66fc99e Initial load duke parents: diff changeset	1023 }
a61af66fc99e Initial load duke parents: diff changeset	1024
a61af66fc99e Initial load duke parents: diff changeset	1025 class CountInterfacesClosure : public InterfaceVisiterClosure {
a61af66fc99e Initial load duke parents: diff changeset	1026 private:
a61af66fc99e Initial load duke parents: diff changeset	1027 int _nof_methods;
a61af66fc99e Initial load duke parents: diff changeset	1028 int _nof_interfaces;
a61af66fc99e Initial load duke parents: diff changeset	1029 public:
a61af66fc99e Initial load duke parents: diff changeset	1030 CountInterfacesClosure() { _nof_methods = 0; _nof_interfaces = 0; }
a61af66fc99e Initial load duke parents: diff changeset	1031
a61af66fc99e Initial load duke parents: diff changeset	1032 int nof_methods() const { return _nof_methods; }
a61af66fc99e Initial load duke parents: diff changeset	1033 int nof_interfaces() const { return _nof_interfaces; }
a61af66fc99e Initial load duke parents: diff changeset	1034
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1035 void doit(Klass* intf, int method_count) { _nof_methods += method_count; _nof_interfaces++; }
0 a61af66fc99e Initial load duke parents: diff changeset	1036 };
a61af66fc99e Initial load duke parents: diff changeset	1037
a61af66fc99e Initial load duke parents: diff changeset	1038 class SetupItableClosure : public InterfaceVisiterClosure {
a61af66fc99e Initial load duke parents: diff changeset	1039 private:
a61af66fc99e Initial load duke parents: diff changeset	1040 itableOffsetEntry* _offset_entry;
a61af66fc99e Initial load duke parents: diff changeset	1041 itableMethodEntry* _method_entry;
a61af66fc99e Initial load duke parents: diff changeset	1042 address _klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1043 public:
a61af66fc99e Initial load duke parents: diff changeset	1044 SetupItableClosure(address klass_begin, itableOffsetEntry* offset_entry, itableMethodEntry* method_entry) {
a61af66fc99e Initial load duke parents: diff changeset	1045 _klass_begin = klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1046 _offset_entry = offset_entry;
a61af66fc99e Initial load duke parents: diff changeset	1047 _method_entry = method_entry;
a61af66fc99e Initial load duke parents: diff changeset	1048 }
a61af66fc99e Initial load duke parents: diff changeset	1049
a61af66fc99e Initial load duke parents: diff changeset	1050 itableMethodEntry* method_entry() const { return _method_entry; }
a61af66fc99e Initial load duke parents: diff changeset	1051
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1052 void doit(Klass* intf, int method_count) {
0 a61af66fc99e Initial load duke parents: diff changeset	1053 int offset = ((address)_method_entry) - _klass_begin;
a61af66fc99e Initial load duke parents: diff changeset	1054 _offset_entry->initialize(intf, offset);
a61af66fc99e Initial load duke parents: diff changeset	1055 _offset_entry++;
a61af66fc99e Initial load duke parents: diff changeset	1056 _method_entry += method_count;
a61af66fc99e Initial load duke parents: diff changeset	1057 }
a61af66fc99e Initial load duke parents: diff changeset	1058 };
a61af66fc99e Initial load duke parents: diff changeset	1059
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1060 int klassItable::compute_itable_size(Array<Klass> transitive_interfaces) {
0 a61af66fc99e Initial load duke parents: diff changeset	1061 // Count no of interfaces and total number of interface methods
a61af66fc99e Initial load duke parents: diff changeset	1062 CountInterfacesClosure cic;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1063 visit_all_interfaces(transitive_interfaces, &cic);
0 a61af66fc99e Initial load duke parents: diff changeset	1064
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1065 // 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	1066 int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
0 a61af66fc99e Initial load duke parents: diff changeset	1067
a61af66fc99e Initial load duke parents: diff changeset	1068 // Statistics
a61af66fc99e Initial load duke parents: diff changeset	1069 update_stats(itable_size * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	1070
a61af66fc99e Initial load duke parents: diff changeset	1071 return itable_size;
a61af66fc99e Initial load duke parents: diff changeset	1072 }
a61af66fc99e Initial load duke parents: diff changeset	1073
a61af66fc99e Initial load duke parents: diff changeset	1074
a61af66fc99e Initial load duke parents: diff changeset	1075 // Fill out offset table and interface klasses into the itable space
a61af66fc99e Initial load duke parents: diff changeset	1076 void klassItable::setup_itable_offset_table(instanceKlassHandle klass) {
a61af66fc99e Initial load duke parents: diff changeset	1077 if (klass->itable_length() == 0) return;
a61af66fc99e Initial load duke parents: diff changeset	1078 assert(!klass->is_interface(), "Should have zero length itable");
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080 // Count no of interfaces and total number of interface methods
a61af66fc99e Initial load duke parents: diff changeset	1081 CountInterfacesClosure cic;
a61af66fc99e Initial load duke parents: diff changeset	1082 visit_all_interfaces(klass->transitive_interfaces(), &cic);
a61af66fc99e Initial load duke parents: diff changeset	1083 int nof_methods = cic.nof_methods();
a61af66fc99e Initial load duke parents: diff changeset	1084 int nof_interfaces = cic.nof_interfaces();
a61af66fc99e Initial load duke parents: diff changeset	1085
16 f8236e79048a 6664627: Merge changes made only in hotspot 11 forward to jdk 7 dcubed parents: 0 diff changeset	1086 // 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	1087 nof_interfaces++;
0 a61af66fc99e Initial load duke parents: diff changeset	1088
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1089 assert(compute_itable_size(klass->transitive_interfaces()) ==
0 a61af66fc99e Initial load duke parents: diff changeset	1090 calc_itable_size(nof_interfaces, nof_methods),
a61af66fc99e Initial load duke parents: diff changeset	1091 "mismatch calculation of itable size");
a61af66fc99e Initial load duke parents: diff changeset	1092
a61af66fc99e Initial load duke parents: diff changeset	1093 // Fill-out offset table
a61af66fc99e Initial load duke parents: diff changeset	1094 itableOffsetEntry* ioe = (itableOffsetEntry*)klass->start_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	1095 itableMethodEntry* ime = (itableMethodEntry*)(ioe + nof_interfaces);
a61af66fc99e Initial load duke parents: diff changeset	1096 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	1097 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	1098 assert((oop)(end) == (oop)(ime + nof_methods), "wrong offset calculation (2)");
0 a61af66fc99e Initial load duke parents: diff changeset	1099
a61af66fc99e Initial load duke parents: diff changeset	1100 // 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	1101 SetupItableClosure sic((address)klass(), ioe, ime);
0 a61af66fc99e Initial load duke parents: diff changeset	1102 visit_all_interfaces(klass->transitive_interfaces(), &sic);
a61af66fc99e Initial load duke parents: diff changeset	1103
a61af66fc99e Initial load duke parents: diff changeset	1104 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1105 ime = sic.method_entry();
a61af66fc99e Initial load duke parents: diff changeset	1106 oop* v = (oop*) klass->end_of_itable();
a61af66fc99e Initial load duke parents: diff changeset	1107 assert( (oop*)(ime) == v, "wrong offset calculation (2)");
a61af66fc99e Initial load duke parents: diff changeset	1108 #endif
a61af66fc99e Initial load duke parents: diff changeset	1109 }
a61af66fc99e Initial load duke parents: diff changeset	1110
a61af66fc99e Initial load duke parents: diff changeset	1111
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1112 // inverse to itable_index
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1113 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	1114 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	1115 assert(intf->verify_itable_index(itable_index), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1116 Array<Method> methods = InstanceKlass::cast(intf)->methods();
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1117
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1118 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	1119 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	1120
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1121 int index = itable_index;
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1122 Method* m = methods->at(index);
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1123 int index2 = -1;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1124 while (!m->has_itable_index() \|\|
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1125 (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	1126 assert(index2 < itable_index, "monotonic");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1127 if (++index == methods->length())
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1128 return NULL;
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1129 m = methods->at(index);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1130 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10166 diff changeset	1131 assert(m->itable_index() == itable_index, "correct inverse");
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1132
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1133 return m;
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1134 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 610 diff changeset	1135
0 a61af66fc99e Initial load duke parents: diff changeset	1136 void klassVtable::verify(outputStream* st, bool forced) {
a61af66fc99e Initial load duke parents: diff changeset	1137 // make sure table is initialized
a61af66fc99e Initial load duke parents: diff changeset	1138 if (!Universe::is_fully_initialized()) return;
a61af66fc99e Initial load duke parents: diff changeset	1139 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1140 // avoid redundant verifies
a61af66fc99e Initial load duke parents: diff changeset	1141 if (!forced && _verify_count == Universe::verify_count()) return;
a61af66fc99e Initial load duke parents: diff changeset	1142 _verify_count = Universe::verify_count();
a61af66fc99e Initial load duke parents: diff changeset	1143 #endif
a61af66fc99e Initial load duke parents: diff changeset	1144 oop* end_of_obj = (oop*)_klass() + _klass()->size();
a61af66fc99e Initial load duke parents: diff changeset	1145 oop* end_of_vtable = (oop *)&table()[_length];
a61af66fc99e Initial load duke parents: diff changeset	1146 if (end_of_vtable > end_of_obj) {
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1489 diff changeset	1147 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	1148 "end)", _klass->internal_name()));
0 a61af66fc99e Initial load duke parents: diff changeset	1149 }
a61af66fc99e Initial load duke parents: diff changeset	1150
a61af66fc99e Initial load duke parents: diff changeset	1151 for (int i = 0; i < _length; i++) table()[i].verify(this, st);
a61af66fc99e Initial load duke parents: diff changeset	1152 // verify consistency with superKlass vtable
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1153 Klass* super = _klass->super();
0 a61af66fc99e Initial load duke parents: diff changeset	1154 if (super != NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1155 InstanceKlass* sk = InstanceKlass::cast(super);
0 a61af66fc99e Initial load duke parents: diff changeset	1156 klassVtable* vt = sk->vtable();
a61af66fc99e Initial load duke parents: diff changeset	1157 for (int i = 0; i < vt->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1158 verify_against(st, vt, i);
a61af66fc99e Initial load duke parents: diff changeset	1159 }
a61af66fc99e Initial load duke parents: diff changeset	1160 }
a61af66fc99e Initial load duke parents: diff changeset	1161 }
a61af66fc99e Initial load duke parents: diff changeset	1162
a61af66fc99e Initial load duke parents: diff changeset	1163 void klassVtable::verify_against(outputStream* st, klassVtable* vt, int index) {
a61af66fc99e Initial load duke parents: diff changeset	1164 vtableEntry* vte = &vt->table()[index];
a61af66fc99e Initial load duke parents: diff changeset	1165 if (vte->method()->name() != table()[index].method()->name() \|\|
a61af66fc99e Initial load duke parents: diff changeset	1166 vte->method()->signature() != table()[index].method()->signature()) {
a61af66fc99e Initial load duke parents: diff changeset	1167 fatal("mismatched name/signature of vtable entries");
a61af66fc99e Initial load duke parents: diff changeset	1168 }
a61af66fc99e Initial load duke parents: diff changeset	1169 }
a61af66fc99e Initial load duke parents: diff changeset	1170
a61af66fc99e Initial load duke parents: diff changeset	1171 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1172 void klassVtable::print() {
a61af66fc99e Initial load duke parents: diff changeset	1173 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1174 tty->print("klassVtable for klass %s (length %d):\n", _klass->internal_name(), length());
a61af66fc99e Initial load duke parents: diff changeset	1175 for (int i = 0; i < length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	1176 table()[i].print();
a61af66fc99e Initial load duke parents: diff changeset	1177 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	1178 }
a61af66fc99e Initial load duke parents: diff changeset	1179 }
a61af66fc99e Initial load duke parents: diff changeset	1180 #endif
a61af66fc99e Initial load duke parents: diff changeset	1181
a61af66fc99e Initial load duke parents: diff changeset	1182 void vtableEntry::verify(klassVtable* vt, outputStream* st) {
a61af66fc99e Initial load duke parents: diff changeset	1183 NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true));
a61af66fc99e Initial load duke parents: diff changeset	1184 assert(method() != NULL, "must have set method");
a61af66fc99e Initial load duke parents: diff changeset	1185 method()->verify();
a61af66fc99e Initial load duke parents: diff changeset	1186 // we sub_type, because it could be a miranda method
a61af66fc99e Initial load duke parents: diff changeset	1187 if (!vt->klass()->is_subtype_of(method()->method_holder())) {
a61af66fc99e Initial load duke parents: diff changeset	1188 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1189 print();
a61af66fc99e Initial load duke parents: diff changeset	1190 #endif
1490 f03d0a26bf83 6888954: argument formatting for assert() and friends jcoomes parents: 1489 diff changeset	1191 fatal(err_msg("vtableEntry " PTR_FORMAT ": method is from subclass", this));
0 a61af66fc99e Initial load duke parents: diff changeset	1192 }
a61af66fc99e Initial load duke parents: diff changeset	1193 }
a61af66fc99e Initial load duke parents: diff changeset	1194
a61af66fc99e Initial load duke parents: diff changeset	1195 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1196
a61af66fc99e Initial load duke parents: diff changeset	1197 void vtableEntry::print() {
a61af66fc99e Initial load duke parents: diff changeset	1198 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1199 tty->print("vtableEntry %s: ", method()->name()->as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	1200 if (Verbose) {
a61af66fc99e Initial load duke parents: diff changeset	1201 tty->print("m %#lx ", (address)method());
a61af66fc99e Initial load duke parents: diff changeset	1202 }
a61af66fc99e Initial load duke parents: diff changeset	1203 }
a61af66fc99e Initial load duke parents: diff changeset	1204
a61af66fc99e Initial load duke parents: diff changeset	1205 class VtableStats : AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	1206 public:
a61af66fc99e Initial load duke parents: diff changeset	1207 static int no_klasses; // # classes with vtables
a61af66fc99e Initial load duke parents: diff changeset	1208 static int no_array_klasses; // # array classes
a61af66fc99e Initial load duke parents: diff changeset	1209 static int no_instance_klasses; // # instanceKlasses
a61af66fc99e Initial load duke parents: diff changeset	1210 static int sum_of_vtable_len; // total # of vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1211 static int sum_of_array_vtable_len; // total # of vtable entries in array klasses only
a61af66fc99e Initial load duke parents: diff changeset	1212 static int fixed; // total fixed overhead in bytes
a61af66fc99e Initial load duke parents: diff changeset	1213 static int filler; // overhead caused by filler bytes
a61af66fc99e Initial load duke parents: diff changeset	1214 static int entries; // total bytes consumed by vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1215 static int array_entries; // total bytes consumed by array vtable entries
a61af66fc99e Initial load duke parents: diff changeset	1216
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1217 static void do_class(Klass* k) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3245 diff changeset	1218 Klass* kl = k;
0 a61af66fc99e Initial load duke parents: diff changeset	1219 klassVtable* vt = kl->vtable();
a61af66fc99e Initial load duke parents: diff changeset	1220 if (vt == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	1221 no_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1222 if (kl->oop_is_instance()) {
a61af66fc99e Initial load duke parents: diff changeset	1223 no_instance_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1224 kl->array_klasses_do(do_class);
a61af66fc99e Initial load duke parents: diff changeset	1225 }
a61af66fc99e Initial load duke parents: diff changeset	1226 if (kl->oop_is_array()) {
a61af66fc99e Initial load duke parents: diff changeset	1227 no_array_klasses++;
a61af66fc99e Initial load duke parents: diff changeset	1228 sum_of_array_vtable_len += vt->length();
a61af66fc99e Initial load duke parents: diff changeset	1229 }
a61af66fc99e Initial load duke parents: diff changeset	1230 sum_of_vtable_len += vt->length();
a61af66fc99e Initial load duke parents: diff changeset	1231 }
a61af66fc99e Initial load duke parents: diff changeset	1232
a61af66fc99e Initial load duke parents: diff changeset	1233 static void compute() {
a61af66fc99e Initial load duke parents: diff changeset	1234 SystemDictionary::classes_do(do_class);
a61af66fc99e Initial load duke parents: diff changeset	1235 fixed = no_klasses * oopSize; // vtable length
a61af66fc99e Initial load duke parents: diff changeset	1236 // filler size is a conservative approximation
6831 d8ce2825b193 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass coleenp parents: 6725 diff changeset	1237 filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(ArrayKlass) - 1);
0 a61af66fc99e Initial load duke parents: diff changeset	1238 entries = sizeof(vtableEntry) * sum_of_vtable_len;
a61af66fc99e Initial load duke parents: diff changeset	1239 array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
a61af66fc99e Initial load duke parents: diff changeset	1240 }
a61af66fc99e Initial load duke parents: diff changeset	1241 };
a61af66fc99e Initial load duke parents: diff changeset	1242
a61af66fc99e Initial load duke parents: diff changeset	1243 int VtableStats::no_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1244 int VtableStats::no_array_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1245 int VtableStats::no_instance_klasses = 0;
a61af66fc99e Initial load duke parents: diff changeset	1246 int VtableStats::sum_of_vtable_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	1247 int VtableStats::sum_of_array_vtable_len = 0;
a61af66fc99e Initial load duke parents: diff changeset	1248 int VtableStats::fixed = 0;
a61af66fc99e Initial load duke parents: diff changeset	1249 int VtableStats::filler = 0;
a61af66fc99e Initial load duke parents: diff changeset	1250 int VtableStats::entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	1251 int VtableStats::array_entries = 0;
a61af66fc99e Initial load duke parents: diff changeset	1252
a61af66fc99e Initial load duke parents: diff changeset	1253 void klassVtable::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	1254 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	1255 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	1256 VtableStats::compute();
a61af66fc99e Initial load duke parents: diff changeset	1257 tty->print_cr("vtable statistics:");
a61af66fc99e Initial load duke parents: diff changeset	1258 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	1259 int total = VtableStats::fixed + VtableStats::filler + VtableStats::entries;
a61af66fc99e Initial load duke parents: diff changeset	1260 tty->print_cr("%6d bytes fixed overhead (refs + vtable object header)", VtableStats::fixed);
a61af66fc99e Initial load duke parents: diff changeset	1261 tty->print_cr("%6d bytes filler overhead", VtableStats::filler);
a61af66fc99e Initial load duke parents: diff changeset	1262 tty->print_cr("%6d bytes for vtable entries (%d for arrays)", VtableStats::entries, VtableStats::array_entries);
a61af66fc99e Initial load duke parents: diff changeset	1263 tty->print_cr("%6d bytes total", total);
a61af66fc99e Initial load duke parents: diff changeset	1264 }
a61af66fc99e Initial load duke parents: diff changeset	1265
a61af66fc99e Initial load duke parents: diff changeset	1266 int klassItable::_total_classes; // Total no. of classes with itables
a61af66fc99e Initial load duke parents: diff changeset	1267 long klassItable::_total_size; // Total no. of bytes used for itables
a61af66fc99e Initial load duke parents: diff changeset	1268
a61af66fc99e Initial load duke parents: diff changeset	1269 void klassItable::print_statistics() {
a61af66fc99e Initial load duke parents: diff changeset	1270 tty->print_cr("itable statistics:");
a61af66fc99e Initial load duke parents: diff changeset	1271 tty->print_cr("%6d classes with itables", _total_classes);
a61af66fc99e Initial load duke parents: diff changeset	1272 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	1273 }
a61af66fc99e Initial load duke parents: diff changeset	1274
a61af66fc99e Initial load duke parents: diff changeset	1275 #endif // PRODUCT

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/oops/klassVtable.cpp @ 12318:36b97be47bde