Mercurial > hg > truffle
annotate src/share/vm/oops/klassVtable.cpp @ 17716:cdb71841f4bc
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 | 5832cdaf89c6 |
children | 4ca6dc0799b6 c02077c4b79c 386dd1c71858 |
rev | line source |
---|---|
0 | 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 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
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 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/systemDictionary.hpp" | |
27 #include "classfile/vmSymbols.hpp" | |
28 #include "gc_implementation/shared/markSweep.inline.hpp" | |
29 #include "memory/gcLocker.hpp" | |
30 #include "memory/resourceArea.hpp" | |
31 #include "memory/universe.inline.hpp" | |
32 #include "oops/instanceKlass.hpp" | |
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 | 35 #include "oops/objArrayOop.hpp" |
36 #include "oops/oop.inline.hpp" | |
37 #include "prims/jvmtiRedefineClassesTrace.hpp" | |
38 #include "runtime/arguments.hpp" | |
39 #include "runtime/handles.inline.hpp" | |
40 #include "utilities/copy.hpp" | |
0 | 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 | 46 } |
47 | |
48 | |
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 | 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 | 56 // entered as a public abstract method in C's vtable. From then on it should |
57 // treated as any other public method in C for method over-ride purposes. | |
6934 | 58 void klassVtable::compute_vtable_size_and_num_mirandas( |
59 int* vtable_length_ret, int* num_new_mirandas, | |
60 GrowableArray<Method*>* all_mirandas, Klass* super, | |
61 Array<Method*>* methods, AccessFlags class_flags, | |
62 Handle classloader, Symbol* classname, Array<Klass*>* local_interfaces, | |
63 TRAPS) { | |
0 | 64 No_Safepoint_Verifier nsv; |
65 | |
66 // set up default result values | |
6934 | 67 int vtable_length = 0; |
0 | 68 |
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 | 71 vtable_length = super == NULL ? 0 : sk->vtable_length(); |
72 | |
73 // go thru each method in the methods table to see if it needs a new entry | |
74 int len = methods->length(); | |
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 | 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 | 80 vtable_length += vtableEntry::size(); // we need a new entry |
81 } | |
82 } | |
83 | |
6934 | 84 GrowableArray<Method*> new_mirandas(20); |
0 | 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 | 87 *num_new_mirandas = new_mirandas.length(); |
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 | 94 |
95 if (Universe::is_bootstrapping() && vtable_length == 0) { | |
96 // array classes don't have their superclass set correctly during | |
97 // bootstrapping | |
98 vtable_length = Universe::base_vtable_size(); | |
99 } | |
100 | |
101 if (super == NULL && !Universe::is_bootstrapping() && | |
102 vtable_length != Universe::base_vtable_size()) { | |
103 // Someone is attempting to redefine java.lang.Object incorrectly. The | |
104 // only way this should happen is from | |
105 // SystemDictionary::resolve_from_stream(), which will detect this later | |
106 // and throw a security exception. So don't assert here to let | |
107 // the exception occur. | |
108 vtable_length = Universe::base_vtable_size(); | |
109 } | |
110 assert(super != NULL || vtable_length == Universe::base_vtable_size(), | |
111 "bad vtable size for class Object"); | |
112 assert(vtable_length % vtableEntry::size() == 0, "bad vtable length"); | |
113 assert(vtable_length >= Universe::base_vtable_size(), "vtable too small"); | |
6934 | 114 |
115 *vtable_length_ret = vtable_length; | |
0 | 116 } |
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 | 120 return m->vtable_index(); |
121 } | |
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 | 126 int klassVtable::initialize_from_super(KlassHandle super) { |
127 if (super.is_null()) { | |
128 return 0; | |
129 } else { | |
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 | 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 | 134 klassVtable* superVtable = sk->vtable(); |
135 assert(superVtable->length() <= _length, "vtable too short"); | |
136 #ifdef ASSERT | |
137 superVtable->verify(tty, true); | |
138 #endif | |
139 superVtable->copy_vtable_to(table()); | |
140 #ifndef PRODUCT | |
141 if (PrintVtables && Verbose) { | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
610
diff
changeset
|
142 ResourceMark rm; |
0 | 143 tty->print_cr("copy vtable from %s to %s size %d", sk->internal_name(), klass()->internal_name(), _length); |
144 } | |
145 #endif | |
146 return superVtable->length(); | |
147 } | |
148 } | |
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 | 152 void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) { |
153 | |
154 // Note: Arrays can have intermediate array supers. Use java_super to skip them. | |
155 KlassHandle super (THREAD, klass()->java_super()); | |
156 int nofNewEntries = 0; | |
157 | |
158 if (PrintVtables && !klass()->oop_is_array()) { | |
159 ResourceMark rm(THREAD); | |
160 tty->print_cr("Initializing: %s", _klass->name()->as_C_string()); | |
161 } | |
162 | |
163 #ifdef ASSERT | |
164 oop* end_of_obj = (oop*)_klass() + _klass()->size(); | |
165 oop* end_of_vtable = (oop*)&table()[_length]; | |
166 assert(end_of_vtable <= end_of_obj, "vtable extends beyond end"); | |
167 #endif | |
168 | |
169 if (Universe::is_bootstrapping()) { | |
170 // just clear everything | |
171 for (int i = 0; i < _length; i++) table()[i].clear(); | |
172 return; | |
173 } | |
174 | |
175 int super_vtable_len = initialize_from_super(super); | |
176 if (klass()->oop_is_array()) { | |
177 assert(super_vtable_len == _length, "arrays shouldn't introduce new methods"); | |
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 | 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 | 183 int initialized = super_vtable_len; |
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 | 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 | 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 | 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 | 194 |
195 if (needs_new_entry) { | |
196 put_method_at(mh(), initialized); | |
197 mh()->set_vtable_index(initialized); // set primary vtable index | |
198 initialized++; | |
199 } | |
200 } | |
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 | 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 | 239 // calculation. |
240 assert(initialized <= _length, "vtable initialization failed"); | |
241 for(;initialized < _length; initialized++) { | |
242 put_method_at(NULL, initialized); | |
243 } | |
244 NOT_PRODUCT(verify(tty, true)); | |
245 } | |
246 } | |
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 | 294 |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
610
diff
changeset
|
295 return superk; |
0 | 296 } |
297 | |
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 | 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 | 305 ResourceMark rm; |
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 | 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 | 327 |
328 // Static and <init> methods are never in | |
329 if (target_method()->is_static() || target_method()->name() == vmSymbols::object_initializer_name()) { | |
330 return false; | |
331 } | |
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 | 334 // a final method never needs a new entry; final methods can be statically |
335 // resolved and they have to be present in the vtable only if they override | |
336 // a super's method, in which case they re-use its entry | |
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 | 352 } |
353 | |
354 // we need a new entry if there is no superclass | |
355 if (klass->super() == NULL) { | |
356 return allocate_new; | |
357 } | |
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 | 363 if (target_method()->is_private()) { |
364 return allocate_new; | |
365 } | |
366 | |
367 // search through the vtable and update overridden entries | |
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 | 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 | 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 | 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 | 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 | 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 | 401 |
402 if (checkconstraints) { | |
403 // Override vtable entry if passes loader constraint check | |
404 // if loader constraint checking requested | |
405 // No need to visit his super, since he and his super | |
406 // have already made any needed loader constraints. | |
407 // Since loader constraints are transitive, it is enough | |
408 // to link to the first super, and we get all the others. | |
409 Handle super_loader(THREAD, super_klass->class_loader()); | |
410 | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
610
diff
changeset
|
411 if (target_loader() != super_loader()) { |
0 | 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 | 415 super_loader, true, |
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 | 418 const char* msg = "loader constraint violation: when resolving " |
419 "overridden method \"%s\" the class loader (instance" | |
420 " of %s) of the current class, %s, and its superclass loader " | |
421 "(instance of %s), have different Class objects for the type " | |
422 "%s used in the signature"; | |
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 | 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 | 428 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
429 strlen(current) + strlen(loader2) + strlen(failed_type_name); | |
430 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
431 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, | |
432 failed_type_name); | |
433 THROW_MSG_(vmSymbols::java_lang_LinkageError(), buf, false); | |
434 } | |
435 } | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
610
diff
changeset
|
436 } |
0 | 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 | 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 | 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 | 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 | 500 #endif /*PRODUCT*/ |
501 } | |
502 } | |
503 } | |
504 return allocate_new; | |
505 } | |
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 | 508 #ifndef PRODUCT |
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 | 523 } |
524 #endif | |
525 table()[index].set(m); | |
526 } | |
527 | |
528 // Find out if a method "m" with superclass "super", loader "classloader" and | |
529 // name "classname" needs a new vtable entry. Let P be a class package defined | |
530 // by "classloader" and "classname". | |
531 // NOTE: The logic used here is very similar to the one used for computing | |
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 | 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 | 551 // a final method never needs a new entry; final methods can be statically |
552 // resolved and they have to be present in the vtable only if they override | |
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 | 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 | 557 // <init> is never called dynamically-bound |
558 ) { | |
559 return false; | |
560 } | |
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 | 570 // we need a new entry if there is no superclass |
571 if (super == NULL) { | |
572 return true; | |
573 } | |
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 | 580 return true; |
581 } | |
582 | |
583 // search through the super class hierarchy to see if we need | |
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 | 592 while (k != NULL) { |
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 | 596 break; // we still have to search for a matching miranda method |
597 } | |
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 | 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 | 612 } |
613 } | |
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 | 617 } |
618 | |
619 // if the target method is public or protected it may have a matching | |
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()) { |
17464
5832cdaf89c6
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 | 627 } |
628 } | |
629 return true; // found no match; we need a new entry | |
630 } | |
631 | |
632 // Support for miranda methods | |
633 | |
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 | 636 // search from the bottom, might be faster |
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 | 639 if (is_miranda_entry_at(i) && |
640 m->name() == name && m->signature() == signature) { | |
641 return i; | |
642 } | |
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 | 645 } |
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 | 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 | 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 | 655 if (mhk->is_interface()) { |
6934 | 656 assert(m->is_public(), "should be public"); |
0 | 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 | 662 } |
663 return false; | |
664 } | |
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 | 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 | 707 } |
708 } | |
2018
642e54d1850a
6989076: JVM crashes in klassItable::initialize_itable_for_interface
dsamersoff
parents:
1972
diff
changeset
|
709 |
0 | 710 return false; |
711 } | |
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 | 721 void klassVtable::add_new_mirandas_to_lists( |
722 GrowableArray<Method*>* new_mirandas, GrowableArray<Method*>* all_mirandas, | |
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 | 726 // iterate thru the current interface's method to see if it a miranda |
727 int num_methods = current_interface_methods->length(); | |
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 | 730 bool is_duplicate = false; |
6934 | 731 int num_of_current_mirandas = new_mirandas->length(); |
0 | 732 // check for duplicate mirandas in different interfaces we implement |
733 for (int j = 0; j < num_of_current_mirandas; j++) { | |
6934 | 734 Method* miranda = new_mirandas->at(j); |
0 | 735 if ((im->name() == miranda->name()) && |
736 (im->signature() == miranda->signature())) { | |
737 is_duplicate = true; | |
738 break; | |
739 } | |
740 } | |
741 | |
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 | 745 // check if it is a duplicate of a super's miranda |
17464
5832cdaf89c6
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
13414
diff
changeset
|
746 if (sk->lookup_method_in_all_interfaces(im->name(), im->signature(), false) == NULL) { |
6934 | 747 new_mirandas->append(im); |
748 } | |
749 if (all_mirandas != NULL) { | |
750 all_mirandas->append(im); | |
0 | 751 } |
752 } | |
753 } | |
754 } | |
755 } | |
756 | |
6934 | 757 void klassVtable::get_mirandas(GrowableArray<Method*>* new_mirandas, |
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 | 762 assert((new_mirandas->length() == 0) , "current mirandas must be 0"); |
0 | 763 |
764 // iterate thru the local interfaces looking for a miranda | |
765 int num_local_ifs = local_interfaces->length(); | |
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 | 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 | 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 | 773 int num_super_ifs = super_ifs->length(); |
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 | 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 | 779 } |
780 } | |
781 } | |
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 | 789 GrowableArray<Method*> mirandas(20); |
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 | 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 | 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 | 811 } |
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 | 815 void klassVtable::copy_vtable_to(vtableEntry* start) { |
816 Copy::disjoint_words((HeapWord*)table(), (HeapWord*)start, _length * vtableEntry::size()); | |
817 } | |
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 | 841 int methods_length, bool * trace_name_printed) { |
842 // search the vtable for uses of either obsolete or EMCP methods | |
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 | 846 |
847 // In the vast majority of cases we could get the vtable index | |
848 // by using: old_method->vtable_index() | |
849 // However, there are rare cases, eg. sun.awt.X11.XDecoratedPeer.getX() | |
850 // in sun.awt.X11.XFramePeer where methods occur more than once in the | |
851 // vtable, so, alas, we must do an exhaustive search. | |
852 for (int index = 0; index < length(); index++) { | |
853 if (unchecked_method_at(index) == old_method) { | |
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 | 861 |
862 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) { | |
863 if (!(*trace_name_printed)) { | |
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 | 868 *trace_name_printed = true; |
869 } | |
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 | 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 | 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 | 877 } |
878 } | |
879 } | |
880 } | |
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 | 924 //----------------------------------------------------------------------------------------- |
925 // Itable code | |
926 | |
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 | 929 if (m == NULL) return; |
930 | |
931 _method = m; | |
932 } | |
933 | |
934 klassItable::klassItable(instanceKlassHandle klass) { | |
935 _klass = klass; | |
936 | |
937 if (klass->itable_length() > 0) { | |
938 itableOffsetEntry* offset_entry = (itableOffsetEntry*)klass->start_of_itable(); | |
939 if (offset_entry != NULL && offset_entry->interface_klass() != NULL) { // Check that itable is initialized | |
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 | 942 intptr_t* end = klass->end_of_itable(); |
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 | 945 _size_offset_table = (method_entry - ((intptr_t*)offset_entry)) / itableOffsetEntry::size(); |
946 _size_method_table = (end - method_entry) / itableMethodEntry::size(); | |
947 assert(_table_offset >= 0 && _size_offset_table >= 0 && _size_method_table >= 0, "wrong computation"); | |
948 return; | |
949 } | |
950 } | |
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 | 953 _table_offset = 0; |
954 _size_offset_table = 0; | |
955 _size_method_table = 0; | |
956 } | |
957 | |
958 static int initialize_count = 0; | |
959 | |
960 // Initialization | |
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 | 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 | 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 | 980 |
981 | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
610
diff
changeset
|
982 // Iterate through all interfaces |
0 | 983 int i; |
984 for(i = 0; i < num_interfaces; i++) { | |
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 | 987 KlassHandle interf_h (THREAD, ioe->interface_klass()); |
988 assert(interf_h() != NULL && ioe->offset() != 0, "bad offset entry in itable"); | |
989 initialize_itable_for_interface(ioe->offset(), interf_h, checkconstraints, CHECK); | |
990 } | |
991 | |
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 | 996 } |
997 | |
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 | 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 | 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 | 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()) { |
17464
5832cdaf89c6
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 |
5832cdaf89c6
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 | 1091 } |
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 | 1099 } else { |
1100 // Entry did resolve, check loader constraints before initializing | |
1101 // if checkconstraints requested | |
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 | 1104 if (method_holder_loader() != interface_loader()) { |
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 | 1108 method_holder_loader, |
1109 interface_loader, | |
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 | 1112 const char* msg = "loader constraint violation in interface " |
1113 "itable initialization: when resolving method \"%s\" the class" | |
1114 " loader (instance of %s) of the current class, %s, " | |
1115 "and the class loader (instance of %s) for interface " | |
1116 "%s have different Class objects for the type %s " | |
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 | 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 | 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 | 1124 size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) + |
1125 strlen(current) + strlen(loader2) + strlen(iface) + | |
1126 strlen(failed_type_name); | |
1127 char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen); | |
1128 jio_snprintf(buf, buflen, msg, sig, loader1, current, loader2, | |
1129 iface, failed_type_name); | |
1130 THROW_MSG(vmSymbols::java_lang_LinkageError(), buf); | |
1131 } | |
1132 } | |
1133 } | |
1134 | |
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 | 1154 } |
1155 } | |
1156 } | |
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 | 1160 itableMethodEntry* ime = method_entry(0); |
1161 for(int i = 0; i < _size_method_table; i++) { | |
1162 if (ime->method() == m) { | |
1163 ime->initialize(m); | |
1164 } | |
1165 ime++; | |
1166 } | |
1167 } | |
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 | 1171 int methods_length, bool * trace_name_printed) { |
1172 // search the itable for uses of either obsolete or EMCP methods | |
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 | 1176 itableMethodEntry* ime = method_entry(0); |
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 | 1182 for (int i = 0; i < _size_method_table; i++) { |
1183 if (ime->method() == old_method) { | |
1184 ime->initialize(new_method); | |
1185 | |
1186 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) { | |
1187 if (!(*trace_name_printed)) { | |
1188 // RC_TRACE_MESG macro has an embedded ResourceMark | |
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 | 1191 *trace_name_printed = true; |
1192 } | |
1193 // RC_TRACE macro has an embedded ResourceMark | |
1194 RC_TRACE(0x00200000, ("itable method update: %s(%s)", | |
1195 new_method->name()->as_C_string(), | |
1196 new_method->signature()->as_C_string())); | |
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 | 1199 } |
1200 ime++; | |
1201 } | |
1202 } | |
1203 } | |
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 | 1239 |
1240 // Setup | |
1241 class InterfaceVisiterClosure : public StackObj { | |
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 | 1244 }; |
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 | 1248 // Handle array argument |
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 | 1251 assert(intf->is_interface(), "sanity check"); |
0 | 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 | 1262 } |
1263 } | |
1264 | |
1265 // Only count interfaces with at least one method | |
1266 if (method_count > 0) { | |
1267 blk->doit(intf, method_count); | |
1268 } | |
1269 } | |
1270 } | |
1271 | |
1272 class CountInterfacesClosure : public InterfaceVisiterClosure { | |
1273 private: | |
1274 int _nof_methods; | |
1275 int _nof_interfaces; | |
1276 public: | |
1277 CountInterfacesClosure() { _nof_methods = 0; _nof_interfaces = 0; } | |
1278 | |
1279 int nof_methods() const { return _nof_methods; } | |
1280 int nof_interfaces() const { return _nof_interfaces; } | |
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 | 1283 }; |
1284 | |
1285 class SetupItableClosure : public InterfaceVisiterClosure { | |
1286 private: | |
1287 itableOffsetEntry* _offset_entry; | |
1288 itableMethodEntry* _method_entry; | |
1289 address _klass_begin; | |
1290 public: | |
1291 SetupItableClosure(address klass_begin, itableOffsetEntry* offset_entry, itableMethodEntry* method_entry) { | |
1292 _klass_begin = klass_begin; | |
1293 _offset_entry = offset_entry; | |
1294 _method_entry = method_entry; | |
1295 } | |
1296 | |
1297 itableMethodEntry* method_entry() const { return _method_entry; } | |
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 | 1300 int offset = ((address)_method_entry) - _klass_begin; |
1301 _offset_entry->initialize(intf, offset); | |
1302 _offset_entry++; | |
1303 _method_entry += method_count; | |
1304 } | |
1305 }; | |
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 | 1308 // Count no of interfaces and total number of interface methods |
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 | 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 | 1314 |
1315 // Statistics | |
1316 update_stats(itable_size * HeapWordSize); | |
1317 | |
1318 return itable_size; | |
1319 } | |
1320 | |
1321 | |
1322 // Fill out offset table and interface klasses into the itable space | |
1323 void klassItable::setup_itable_offset_table(instanceKlassHandle klass) { | |
1324 if (klass->itable_length() == 0) return; | |
1325 assert(!klass->is_interface(), "Should have zero length itable"); | |
1326 | |
1327 // Count no of interfaces and total number of interface methods | |
1328 CountInterfacesClosure cic; | |
1329 visit_all_interfaces(klass->transitive_interfaces(), &cic); | |
1330 int nof_methods = cic.nof_methods(); | |
1331 int nof_interfaces = cic.nof_interfaces(); | |
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 | 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 | 1337 calc_itable_size(nof_interfaces, nof_methods), |
1338 "mismatch calculation of itable size"); | |
1339 | |
1340 // Fill-out offset table | |
1341 itableOffsetEntry* ioe = (itableOffsetEntry*)klass->start_of_itable(); | |
1342 itableMethodEntry* ime = (itableMethodEntry*)(ioe + nof_interfaces); | |
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 | 1346 |
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 | 1349 visit_all_interfaces(klass->transitive_interfaces(), &sic); |
1350 | |
1351 #ifdef ASSERT | |
1352 ime = sic.method_entry(); | |
1353 oop* v = (oop*) klass->end_of_itable(); | |
1354 assert( (oop*)(ime) == v, "wrong offset calculation (2)"); | |
1355 #endif | |
1356 } | |
1357 | |
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 | 1383 void klassVtable::verify(outputStream* st, bool forced) { |
1384 // make sure table is initialized | |
1385 if (!Universe::is_fully_initialized()) return; | |
1386 #ifndef PRODUCT | |
1387 // avoid redundant verifies | |
1388 if (!forced && _verify_count == Universe::verify_count()) return; | |
1389 _verify_count = Universe::verify_count(); | |
1390 #endif | |
1391 oop* end_of_obj = (oop*)_klass() + _klass()->size(); | |
1392 oop* end_of_vtable = (oop *)&table()[_length]; | |
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 | 1396 } |
1397 | |
1398 for (int i = 0; i < _length; i++) table()[i].verify(this, st); | |
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 | 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 | 1403 klassVtable* vt = sk->vtable(); |
1404 for (int i = 0; i < vt->length(); i++) { | |
1405 verify_against(st, vt, i); | |
1406 } | |
1407 } | |
1408 } | |
1409 | |
1410 void klassVtable::verify_against(outputStream* st, klassVtable* vt, int index) { | |
1411 vtableEntry* vte = &vt->table()[index]; | |
1412 if (vte->method()->name() != table()[index].method()->name() || | |
1413 vte->method()->signature() != table()[index].method()->signature()) { | |
1414 fatal("mismatched name/signature of vtable entries"); | |
1415 } | |
1416 } | |
1417 | |
1418 #ifndef PRODUCT | |
1419 void klassVtable::print() { | |
1420 ResourceMark rm; | |
1421 tty->print("klassVtable for klass %s (length %d):\n", _klass->internal_name(), length()); | |
1422 for (int i = 0; i < length(); i++) { | |
1423 table()[i].print(); | |
1424 tty->cr(); | |
1425 } | |
1426 } | |
1427 #endif | |
1428 | |
1429 void vtableEntry::verify(klassVtable* vt, outputStream* st) { | |
1430 NOT_PRODUCT(FlagSetting fs(IgnoreLockingAssertions, true)); | |
1431 assert(method() != NULL, "must have set method"); | |
1432 method()->verify(); | |
1433 // we sub_type, because it could be a miranda method | |
1434 if (!vt->klass()->is_subtype_of(method()->method_holder())) { | |
1435 #ifndef PRODUCT | |
1436 print(); | |
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 | 1439 } |
1440 } | |
1441 | |
1442 #ifndef PRODUCT | |
1443 | |
1444 void vtableEntry::print() { | |
1445 ResourceMark rm; | |
1446 tty->print("vtableEntry %s: ", method()->name()->as_C_string()); | |
1447 if (Verbose) { | |
1448 tty->print("m %#lx ", (address)method()); | |
1449 } | |
1450 } | |
1451 | |
1452 class VtableStats : AllStatic { | |
1453 public: | |
1454 static int no_klasses; // # classes with vtables | |
1455 static int no_array_klasses; // # array classes | |
1456 static int no_instance_klasses; // # instanceKlasses | |
1457 static int sum_of_vtable_len; // total # of vtable entries | |
1458 static int sum_of_array_vtable_len; // total # of vtable entries in array klasses only | |
1459 static int fixed; // total fixed overhead in bytes | |
1460 static int filler; // overhead caused by filler bytes | |
1461 static int entries; // total bytes consumed by vtable entries | |
1462 static int array_entries; // total bytes consumed by array vtable entries | |
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 | 1466 klassVtable* vt = kl->vtable(); |
1467 if (vt == NULL) return; | |
1468 no_klasses++; | |
1469 if (kl->oop_is_instance()) { | |
1470 no_instance_klasses++; | |
1471 kl->array_klasses_do(do_class); | |
1472 } | |
1473 if (kl->oop_is_array()) { | |
1474 no_array_klasses++; | |
1475 sum_of_array_vtable_len += vt->length(); | |
1476 } | |
1477 sum_of_vtable_len += vt->length(); | |
1478 } | |
1479 | |
1480 static void compute() { | |
1481 SystemDictionary::classes_do(do_class); | |
1482 fixed = no_klasses * oopSize; // vtable length | |
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 | 1485 entries = sizeof(vtableEntry) * sum_of_vtable_len; |
1486 array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len; | |
1487 } | |
1488 }; | |
1489 | |
1490 int VtableStats::no_klasses = 0; | |
1491 int VtableStats::no_array_klasses = 0; | |
1492 int VtableStats::no_instance_klasses = 0; | |
1493 int VtableStats::sum_of_vtable_len = 0; | |
1494 int VtableStats::sum_of_array_vtable_len = 0; | |
1495 int VtableStats::fixed = 0; | |
1496 int VtableStats::filler = 0; | |
1497 int VtableStats::entries = 0; | |
1498 int VtableStats::array_entries = 0; | |
1499 | |
1500 void klassVtable::print_statistics() { | |
1501 ResourceMark rm; | |
1502 HandleMark hm; | |
1503 VtableStats::compute(); | |
1504 tty->print_cr("vtable statistics:"); | |
1505 tty->print_cr("%6d classes (%d instance, %d array)", VtableStats::no_klasses, VtableStats::no_instance_klasses, VtableStats::no_array_klasses); | |
1506 int total = VtableStats::fixed + VtableStats::filler + VtableStats::entries; | |
1507 tty->print_cr("%6d bytes fixed overhead (refs + vtable object header)", VtableStats::fixed); | |
1508 tty->print_cr("%6d bytes filler overhead", VtableStats::filler); | |
1509 tty->print_cr("%6d bytes for vtable entries (%d for arrays)", VtableStats::entries, VtableStats::array_entries); | |
1510 tty->print_cr("%6d bytes total", total); | |
1511 } | |
1512 | |
1513 int klassItable::_total_classes; // Total no. of classes with itables | |
1514 long klassItable::_total_size; // Total no. of bytes used for itables | |
1515 | |
1516 void klassItable::print_statistics() { | |
1517 tty->print_cr("itable statistics:"); | |
1518 tty->print_cr("%6d classes with itables", _total_classes); | |
1519 tty->print_cr("%6d K uses for itables (average by class: %d bytes)", _total_size / K, _total_size / _total_classes); | |
1520 } | |
1521 | |
1522 #endif // PRODUCT |