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

annotate src/share/vm/oops/klassVtable.cpp @ 12962:5ccbab1c69f3

8026251: New type profiling points: parameters to methods Summary: x86 interpreter and c1 type profiling for parameters on method entries Reviewed-by: kvn, twisti

author	roland
date	Tue, 22 Oct 2013 09:51:47 +0200
parents	ac9cb1d5a202
children	fce21ac5968d

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

Mercurial > hg > truffle

annotate src/share/vm/oops/klassVtable.cpp @ 12962:5ccbab1c69f3