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

annotate src/share/vm/oops/klassVtable.cpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	2353011244bd
children	4ca6dc0799b6 c02077c4b79c 386dd1c71858

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

Mercurial > hg > truffle

annotate src/share/vm/oops/klassVtable.cpp @ 14649:f6301b007a16