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

annotate src/share/vm/oops/klassVtable.cpp @ 17571:c02077c4b79c

8032536: JVM resolves wrong method in some unusual cases Summary: Handle package private case Reviewed-by: coleenp, acorn, jdn

author	hseigel
date	Tue, 04 Mar 2014 15:46:33 -0500
parents	5832cdaf89c6
children	3eed8712d410 364b73402247

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

Mercurial > hg > truffle

annotate src/share/vm/oops/klassVtable.cpp @ 17571:c02077c4b79c