author | kvn |
Fri, 12 May 2017 13:14:25 -0700 | |
changeset 46458 | 3c12af929e7d |
parent 46444 | 677be3444372 |
parent 44993 | f61bcd80ec1f |
child 46464 | 6432a858a220 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
43430
a815cfd97cd1
8170959: unloading archived shared class caused crash
iklam
parents:
42650
diff
changeset
|
2 |
* Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
5403
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
42650 | 26 |
#include "aot/aotLoader.hpp" |
34666 | 27 |
#include "classfile/classFileParser.hpp" |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
28 |
#include "classfile/classFileStream.hpp" |
42650 | 29 |
#include "classfile/classLoader.hpp" |
7397 | 30 |
#include "classfile/javaClasses.hpp" |
42307
cefc81dc1d52
8169069: Module system implementation refresh (11/2016)
alanb
parents:
42031
diff
changeset
|
31 |
#include "classfile/moduleEntry.hpp" |
7397 | 32 |
#include "classfile/systemDictionary.hpp" |
39713 | 33 |
#include "classfile/systemDictionaryShared.hpp" |
7397 | 34 |
#include "classfile/verifier.hpp" |
35 |
#include "classfile/vmSymbols.hpp" |
|
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
36 |
#include "code/dependencyContext.hpp" |
7397 | 37 |
#include "compiler/compileBroker.hpp" |
30764 | 38 |
#include "gc/shared/collectedHeap.inline.hpp" |
39 |
#include "gc/shared/specialized_oop_closures.hpp" |
|
7397 | 40 |
#include "interpreter/oopMapCache.hpp" |
41 |
#include "interpreter/rewriter.hpp" |
|
42 |
#include "jvmtifiles/jvmti.h" |
|
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
43 |
#include "logging/log.hpp" |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
44 |
#include "logging/logMessage.hpp" |
15437 | 45 |
#include "memory/heapInspection.hpp" |
25356
4a4a482298a6
8046670: Make CMS metadata aware closures applicable for other collectors
stefank
parents:
25351
diff
changeset
|
46 |
#include "memory/iterator.inline.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
47 |
#include "memory/metadataFactory.hpp" |
41182 | 48 |
#include "memory/metaspaceShared.hpp" |
7397 | 49 |
#include "memory/oopFactory.hpp" |
37248 | 50 |
#include "memory/resourceArea.hpp" |
10546 | 51 |
#include "oops/fieldStreams.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
52 |
#include "oops/instanceClassLoaderKlass.hpp" |
30150
d9c940aa42ef
8075955: Replace the macro based implementation of oop_oop_iterate with a template based solution
stefank
parents:
29792
diff
changeset
|
53 |
#include "oops/instanceKlass.inline.hpp" |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
54 |
#include "oops/instanceMirrorKlass.hpp" |
7397 | 55 |
#include "oops/instanceOop.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
56 |
#include "oops/klass.inline.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
57 |
#include "oops/method.hpp" |
7397 | 58 |
#include "oops/oop.inline.hpp" |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
59 |
#include "oops/symbol.hpp" |
7397 | 60 |
#include "prims/jvmtiExport.hpp" |
30764 | 61 |
#include "prims/jvmtiRedefineClasses.hpp" |
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
62 |
#include "prims/jvmtiThreadState.hpp" |
15099
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
63 |
#include "prims/methodComparator.hpp" |
40655
9f644073d3a0
8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents:
40102
diff
changeset
|
64 |
#include "runtime/atomic.hpp" |
7397 | 65 |
#include "runtime/fieldDescriptor.hpp" |
66 |
#include "runtime/handles.inline.hpp" |
|
67 |
#include "runtime/javaCalls.hpp" |
|
68 |
#include "runtime/mutexLocker.hpp" |
|
24351
61b33cc6d3cf
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
24322
diff
changeset
|
69 |
#include "runtime/orderAccess.inline.hpp" |
14583
d70ee55535f4
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
14490
diff
changeset
|
70 |
#include "runtime/thread.inline.hpp" |
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
71 |
#include "services/classLoadingService.hpp" |
7397 | 72 |
#include "services/threadService.hpp" |
73 |
#include "utilities/dtrace.hpp" |
|
15482
470d0b0c09f1
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
15216
diff
changeset
|
74 |
#include "utilities/macros.hpp" |
40016 | 75 |
#include "utilities/stringUtils.hpp" |
7397 | 76 |
#ifdef COMPILER1 |
77 |
#include "c1/c1_Compiler.hpp" |
|
78 |
#endif |
|
1 | 79 |
|
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
80 |
#ifdef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
81 |
|
10739 | 82 |
|
83 |
#define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED |
|
84 |
#define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE |
|
85 |
#define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT |
|
86 |
#define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS |
|
87 |
#define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED |
|
88 |
#define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT |
|
89 |
#define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR |
|
90 |
#define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
91 |
#define DTRACE_CLASSINIT_PROBE(type, thread_type) \ |
10739 | 92 |
{ \ |
93 |
char* data = NULL; \ |
|
94 |
int len = 0; \ |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
95 |
Symbol* clss_name = name(); \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
96 |
if (clss_name != NULL) { \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
97 |
data = (char*)clss_name->bytes(); \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
98 |
len = clss_name->utf8_length(); \ |
10739 | 99 |
} \ |
100 |
HOTSPOT_CLASS_INITIALIZATION_##type( \ |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
101 |
data, len, class_loader(), thread_type); \ |
10739 | 102 |
} |
103 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
104 |
#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait) \ |
10739 | 105 |
{ \ |
106 |
char* data = NULL; \ |
|
107 |
int len = 0; \ |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
108 |
Symbol* clss_name = name(); \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
109 |
if (clss_name != NULL) { \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
110 |
data = (char*)clss_name->bytes(); \ |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
111 |
len = clss_name->utf8_length(); \ |
10739 | 112 |
} \ |
113 |
HOTSPOT_CLASS_INITIALIZATION_##type( \ |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
114 |
data, len, class_loader(), thread_type, wait); \ |
10739 | 115 |
} |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
116 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
117 |
#else // ndef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
118 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
119 |
#define DTRACE_CLASSINIT_PROBE(type, thread_type) |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
120 |
#define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait) |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
121 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
122 |
#endif // ndef DTRACE_ENABLED |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
123 |
|
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
124 |
volatile int InstanceKlass::_total_instanceKlass_count = 0; |
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
125 |
|
34666 | 126 |
static inline bool is_class_loader(const Symbol* class_name, |
127 |
const ClassFileParser& parser) { |
|
128 |
assert(class_name != NULL, "invariant"); |
|
129 |
||
130 |
if (class_name == vmSymbols::java_lang_ClassLoader()) { |
|
131 |
return true; |
|
132 |
} |
|
133 |
||
134 |
if (SystemDictionary::ClassLoader_klass_loaded()) { |
|
135 |
const Klass* const super_klass = parser.super_klass(); |
|
136 |
if (super_klass != NULL) { |
|
137 |
if (super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass())) { |
|
138 |
return true; |
|
139 |
} |
|
140 |
} |
|
141 |
} |
|
142 |
return false; |
|
143 |
} |
|
144 |
||
145 |
InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) { |
|
146 |
const int size = InstanceKlass::size(parser.vtable_size(), |
|
147 |
parser.itable_size(), |
|
148 |
nonstatic_oop_map_size(parser.total_oop_map_count()), |
|
149 |
parser.is_interface(), |
|
42650 | 150 |
parser.is_anonymous(), |
151 |
should_store_fingerprint()); |
|
34666 | 152 |
|
153 |
const Symbol* const class_name = parser.class_name(); |
|
154 |
assert(class_name != NULL, "invariant"); |
|
155 |
ClassLoaderData* loader_data = parser.loader_data(); |
|
156 |
assert(loader_data != NULL, "invariant"); |
|
157 |
||
158 |
InstanceKlass* ik; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
159 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
160 |
// Allocation |
34666 | 161 |
if (REF_NONE == parser.reference_type()) { |
162 |
if (class_name == vmSymbols::java_lang_Class()) { |
|
163 |
// mirror |
|
164 |
ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser); |
|
165 |
} |
|
166 |
else if (is_class_loader(class_name, parser)) { |
|
167 |
// class loader |
|
168 |
ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
169 |
} |
34666 | 170 |
else { |
171 |
// normal |
|
172 |
ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_misc_kind_other); |
|
173 |
} |
|
174 |
} |
|
175 |
else { |
|
176 |
// reference |
|
177 |
ik = new (loader_data, size, THREAD) InstanceRefKlass(parser); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
178 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
179 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
180 |
// Check for pending exception before adding to the loader data and incrementing |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
181 |
// class count. Can get OOM here. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
182 |
if (HAS_PENDING_EXCEPTION) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
183 |
return NULL; |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
184 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
185 |
|
34666 | 186 |
assert(ik != NULL, "invariant"); |
187 |
||
188 |
const bool publicize = !parser.is_internal(); |
|
189 |
||
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
190 |
// Add all classes to our internal class loader list here, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
191 |
// including classes in the bootstrap (NULL) class loader. |
34666 | 192 |
loader_data->add_class(ik, publicize); |
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
193 |
Atomic::inc(&_total_instanceKlass_count); |
34666 | 194 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
195 |
return ik; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
196 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
197 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
198 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
199 |
// copy method ordering from resource area to Metaspace |
34666 | 200 |
void InstanceKlass::copy_method_ordering(const intArray* m, TRAPS) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
201 |
if (m != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
202 |
// allocate a new array and copy contents (memcpy?) |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
203 |
_method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
204 |
for (int i = 0; i < m->length(); i++) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
205 |
_method_ordering->at_put(i, m->at(i)); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
206 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
207 |
} else { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
208 |
_method_ordering = Universe::the_empty_int_array(); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
209 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
210 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
211 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
212 |
// create a new array of vtable_indices for default methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
213 |
Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
214 |
Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
215 |
assert(default_vtable_indices() == NULL, "only create once"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
216 |
set_default_vtable_indices(vtable_indices); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
217 |
return vtable_indices; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
218 |
} |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
219 |
|
34666 | 220 |
InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind) : |
221 |
_static_field_size(parser.static_field_size()), |
|
222 |
_nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())), |
|
223 |
_itable_len(parser.itable_size()), |
|
224 |
_reference_type(parser.reference_type()) { |
|
35899 | 225 |
set_vtable_length(parser.vtable_size()); |
34666 | 226 |
set_kind(kind); |
227 |
set_access_flags(parser.access_flags()); |
|
228 |
set_is_anonymous(parser.is_anonymous()); |
|
229 |
set_layout_helper(Klass::instance_layout_helper(parser.layout_size(), |
|
230 |
false)); |
|
231 |
||
232 |
assert(NULL == _methods, "underlying memory not zeroed?"); |
|
233 |
assert(is_instance_klass(), "is layout incorrect?"); |
|
234 |
assert(size_helper() == parser.layout_size(), "incorrect size_helper?"); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
235 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
236 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
237 |
void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
238 |
Array<Method*>* methods) { |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
239 |
if (methods != NULL && methods != Universe::the_empty_method_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
240 |
!methods->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
241 |
for (int i = 0; i < methods->length(); i++) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
242 |
Method* method = methods->at(i); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
243 |
if (method == NULL) continue; // maybe null if error processing |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
244 |
// Only want to delete methods that are not executing for RedefineClasses. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
245 |
// The previous version will point to them so they're not totally dangling |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
246 |
assert (!method->on_stack(), "shouldn't be called with methods on stack"); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
247 |
MetadataFactory::free_metadata(loader_data, method); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
248 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
249 |
MetadataFactory::free_array<Method*>(loader_data, methods); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
250 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
251 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
252 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
253 |
void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data, |
34666 | 254 |
const Klass* super_klass, |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
255 |
Array<Klass*>* local_interfaces, |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
256 |
Array<Klass*>* transitive_interfaces) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
257 |
// Only deallocate transitive interfaces if not empty, same as super class |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
258 |
// or same as local interfaces. See code in parseClassFile. |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
259 |
Array<Klass*>* ti = transitive_interfaces; |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
260 |
if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
261 |
// check that the interfaces don't come from super class |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
262 |
Array<Klass*>* sti = (super_klass == NULL) ? NULL : |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
263 |
InstanceKlass::cast(super_klass)->transitive_interfaces(); |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
264 |
if (ti != sti && ti != NULL && !ti->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
265 |
MetadataFactory::free_array<Klass*>(loader_data, ti); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
266 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
267 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
268 |
|
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
269 |
// local interfaces can be empty |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
270 |
if (local_interfaces != Universe::the_empty_klass_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
271 |
local_interfaces != NULL && !local_interfaces->is_shared()) { |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
272 |
MetadataFactory::free_array<Klass*>(loader_data, local_interfaces); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
273 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
274 |
} |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
275 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
276 |
// This function deallocates the metadata and C heap pointers that the |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
277 |
// InstanceKlass points to. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
278 |
void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
279 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
280 |
// Orphan the mirror first, CMS thinks it's still live. |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
281 |
if (java_mirror() != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
282 |
java_lang_Class::set_klass(java_mirror(), NULL); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
283 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
284 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
285 |
// Need to take this class off the class loader data list. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
286 |
loader_data->remove_class(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
287 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
288 |
// The array_klass for this class is created later, after error handling. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
289 |
// For class redefinition, we keep the original class so this scratch class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
290 |
// doesn't have an array class. Either way, assert that there is nothing |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
291 |
// to deallocate. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
292 |
assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
293 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
294 |
// Release C heap allocated data that this might point to, which includes |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
295 |
// reference counting symbol names. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
296 |
release_C_heap_structures(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
297 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
298 |
deallocate_methods(loader_data, methods()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
299 |
set_methods(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
300 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
301 |
if (method_ordering() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
302 |
method_ordering() != Universe::the_empty_int_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
303 |
!method_ordering()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
304 |
MetadataFactory::free_array<int>(loader_data, method_ordering()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
305 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
306 |
set_method_ordering(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
307 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
308 |
// default methods can be empty |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
309 |
if (default_methods() != NULL && |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
310 |
default_methods() != Universe::the_empty_method_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
311 |
!default_methods()->is_shared()) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
312 |
MetadataFactory::free_array<Method*>(loader_data, default_methods()); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
313 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
314 |
// Do NOT deallocate the default methods, they are owned by superinterfaces. |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
315 |
set_default_methods(NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
316 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
317 |
// default methods vtable indices can be empty |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
318 |
if (default_vtable_indices() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
319 |
!default_vtable_indices()->is_shared()) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
320 |
MetadataFactory::free_array<int>(loader_data, default_vtable_indices()); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
321 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
322 |
set_default_vtable_indices(NULL); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
323 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
324 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
325 |
// This array is in Klass, but remove it with the InstanceKlass since |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
326 |
// this place would be the only caller and it can share memory with transitive |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
327 |
// interfaces. |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
328 |
if (secondary_supers() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
329 |
secondary_supers() != Universe::the_empty_klass_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
330 |
secondary_supers() != transitive_interfaces() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
331 |
!secondary_supers()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
332 |
MetadataFactory::free_array<Klass*>(loader_data, secondary_supers()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
333 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
334 |
set_secondary_supers(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
335 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
336 |
deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
337 |
set_transitive_interfaces(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
338 |
set_local_interfaces(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
339 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
340 |
if (fields() != NULL && !fields()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
341 |
MetadataFactory::free_array<jushort>(loader_data, fields()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
342 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
343 |
set_fields(NULL, 0); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
344 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
345 |
// If a method from a redefined class is using this constant pool, don't |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
346 |
// delete it, yet. The new class's previous version will point to this. |
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
347 |
if (constants() != NULL) { |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
348 |
assert (!constants()->on_stack(), "shouldn't be called if anything is onstack"); |
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
349 |
if (!constants()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
350 |
MetadataFactory::free_metadata(loader_data, constants()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
351 |
} |
31353
cd33628db166
8076110: VM crash when class is redefined with Instrumentation.redefineClasses
aeriksso
parents:
31050
diff
changeset
|
352 |
// Delete any cached resolution errors for the constant pool |
cd33628db166
8076110: VM crash when class is redefined with Instrumentation.redefineClasses
aeriksso
parents:
31050
diff
changeset
|
353 |
SystemDictionary::delete_resolution_error(constants()); |
cd33628db166
8076110: VM crash when class is redefined with Instrumentation.redefineClasses
aeriksso
parents:
31050
diff
changeset
|
354 |
|
15935
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
355 |
set_constants(NULL); |
50da9e5eb858
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
15930
diff
changeset
|
356 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
357 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
358 |
if (inner_classes() != NULL && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
359 |
inner_classes() != Universe::the_empty_short_array() && |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
360 |
!inner_classes()->is_shared()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
361 |
MetadataFactory::free_array<jushort>(loader_data, inner_classes()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
362 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
363 |
set_inner_classes(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
364 |
|
20684
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
365 |
// We should deallocate the Annotations instance if it's not in shared spaces. |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
366 |
if (annotations() != NULL && !annotations()->is_shared()) { |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
367 |
MetadataFactory::free_metadata(loader_data, annotations()); |
057f5443edab
8024667: VM crashes with "assert(method() != NULL) failed: must have set method"
hseigel
parents:
20396
diff
changeset
|
368 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
369 |
set_annotations(NULL); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
370 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
371 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
372 |
bool InstanceKlass::should_be_initialized() const { |
1 | 373 |
return !is_initialized(); |
374 |
} |
|
375 |
||
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
376 |
klassItable InstanceKlass::itable() const { |
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
377 |
return klassItable(const_cast<InstanceKlass*>(this)); |
1 | 378 |
} |
379 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
380 |
void InstanceKlass::eager_initialize(Thread *thread) { |
1 | 381 |
if (!EagerInitialization) return; |
382 |
||
383 |
if (this->is_not_initialized()) { |
|
384 |
// abort if the the class has a class initializer |
|
385 |
if (this->class_initializer() != NULL) return; |
|
386 |
||
387 |
// abort if it is java.lang.Object (initialization is handled in genesis) |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
388 |
Klass* super_klass = super(); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
389 |
if (super_klass == NULL) return; |
1 | 390 |
|
391 |
// abort if the super class should be initialized |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
392 |
if (!InstanceKlass::cast(super_klass)->is_initialized()) return; |
1 | 393 |
|
394 |
// call body to expose the this pointer |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
395 |
eager_initialize_impl(); |
1 | 396 |
} |
397 |
} |
|
398 |
||
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
399 |
// JVMTI spec thinks there are signers and protection domain in the |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
400 |
// instanceKlass. These accessors pretend these fields are there. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
401 |
// The hprof specification also thinks these fields are in InstanceKlass. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
402 |
oop InstanceKlass::protection_domain() const { |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
403 |
// return the protection_domain from the mirror |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
404 |
return java_lang_Class::protection_domain(java_mirror()); |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
405 |
} |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
406 |
|
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
407 |
// To remove these from requires an incompatible change and CCC request. |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
408 |
objArrayOop InstanceKlass::signers() const { |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
409 |
// return the signers from the mirror |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
410 |
return java_lang_Class::signers(java_mirror()); |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
411 |
} |
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
412 |
|
20379
a4c59d30d67d
8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries
coleenp
parents:
20284
diff
changeset
|
413 |
oop InstanceKlass::init_lock() const { |
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
414 |
// return the init lock from the mirror |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
415 |
oop lock = java_lang_Class::init_lock(java_mirror()); |
26556
72da4c813e44
8046210: Missing memory barrier when reading init_lock
dholmes
parents:
26316
diff
changeset
|
416 |
// Prevent reordering with any access of initialization state |
72da4c813e44
8046210: Missing memory barrier when reading init_lock
dholmes
parents:
26316
diff
changeset
|
417 |
OrderAccess::loadload(); |
21079
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
418 |
assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
419 |
"only fully initialized state can have a null lock"); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
420 |
return lock; |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
421 |
} |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
422 |
|
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
423 |
// Set the initialization lock to null so the object can be GC'ed. Any racing |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
424 |
// threads to get this lock will see a null lock and will not lock. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
425 |
// That's okay because they all check for initialized state after getting |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
426 |
// the lock and return. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
427 |
void InstanceKlass::fence_and_clear_init_lock() { |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
428 |
// make sure previous stores are all done, notably the init_state. |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
429 |
OrderAccess::storestore(); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
430 |
java_lang_Class::set_init_lock(java_mirror(), NULL); |
7028d0cb9b49
8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread
iklam
parents:
20684
diff
changeset
|
431 |
assert(!is_not_initialized(), "class must be initialized now"); |
17826
9ad5cd464a75
8003421: NPG: Move oops out of InstanceKlass into mirror
coleenp
parents:
17370
diff
changeset
|
432 |
} |
1 | 433 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
434 |
void InstanceKlass::eager_initialize_impl() { |
1 | 435 |
EXCEPTION_MARK; |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
436 |
HandleMark hm(THREAD); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
437 |
Handle h_init_lock(THREAD, init_lock()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
438 |
ObjectLocker ol(h_init_lock, THREAD, init_lock() != NULL); |
1 | 439 |
|
440 |
// abort if someone beat us to the initialization |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
441 |
if (!is_not_initialized()) return; // note: not equivalent to is_initialized() |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
442 |
|
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
443 |
ClassState old_state = init_state(); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
444 |
link_class_impl(true, THREAD); |
1 | 445 |
if (HAS_PENDING_EXCEPTION) { |
446 |
CLEAR_PENDING_EXCEPTION; |
|
447 |
// Abort if linking the class throws an exception. |
|
448 |
||
449 |
// Use a test to avoid redundantly resetting the state if there's |
|
450 |
// no change. Set_init_state() asserts that state changes make |
|
451 |
// progress, whereas here we might just be spinning in place. |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
452 |
if (old_state != _init_state) |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
453 |
set_init_state(old_state); |
1 | 454 |
} else { |
455 |
// linking successfull, mark class as initialized |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
456 |
set_init_state(fully_initialized); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
457 |
fence_and_clear_init_lock(); |
1 | 458 |
// trace |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38094
diff
changeset
|
459 |
if (log_is_enabled(Info, class, init)) { |
1 | 460 |
ResourceMark rm(THREAD); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
461 |
log_info(class, init)("[Initialized %s without side effects]", external_name()); |
1 | 462 |
} |
463 |
} |
|
464 |
} |
|
465 |
||
466 |
||
467 |
// See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization |
|
468 |
// process. The step comments refers to the procedure described in that section. |
|
469 |
// Note: implementation moved to static method to expose the this pointer. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
470 |
void InstanceKlass::initialize(TRAPS) { |
1 | 471 |
if (this->should_be_initialized()) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
472 |
initialize_impl(CHECK); |
1 | 473 |
// Note: at this point the class may be initialized |
474 |
// OR it may be in the state of being initialized |
|
475 |
// in case of recursive initialization! |
|
476 |
} else { |
|
477 |
assert(is_initialized(), "sanity check"); |
|
478 |
} |
|
479 |
} |
|
480 |
||
481 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
482 |
bool InstanceKlass::verify_code(bool throw_verifyerror, TRAPS) { |
1 | 483 |
// 1) Verify the bytecodes |
484 |
Verifier::Mode mode = |
|
485 |
throw_verifyerror ? Verifier::ThrowException : Verifier::NoException; |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
486 |
return Verifier::verify(this, mode, should_verify_class(), THREAD); |
1 | 487 |
} |
488 |
||
489 |
||
490 |
// Used exclusively by the shared spaces dump mechanism to prevent |
|
491 |
// classes mapped into the shared regions in new VMs from appearing linked. |
|
492 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
493 |
void InstanceKlass::unlink_class() { |
1 | 494 |
assert(is_linked(), "must be linked"); |
495 |
_init_state = loaded; |
|
496 |
} |
|
497 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
498 |
void InstanceKlass::link_class(TRAPS) { |
1 | 499 |
assert(is_loaded(), "must be loaded"); |
500 |
if (!is_linked()) { |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
501 |
link_class_impl(true, CHECK); |
1 | 502 |
} |
503 |
} |
|
504 |
||
505 |
// Called to verify that a class can link during initialization, without |
|
506 |
// throwing a VerifyError. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
507 |
bool InstanceKlass::link_class_or_fail(TRAPS) { |
1 | 508 |
assert(is_loaded(), "must be loaded"); |
509 |
if (!is_linked()) { |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
510 |
link_class_impl(false, CHECK_false); |
1 | 511 |
} |
512 |
return is_linked(); |
|
513 |
} |
|
514 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
515 |
bool InstanceKlass::link_class_impl(bool throw_verifyerror, TRAPS) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
516 |
if (DumpSharedSpaces && is_in_error_state()) { |
42031
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
517 |
// This is for CDS dumping phase only -- we use the in_error_state to indicate that |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
518 |
// the class has failed verification. Throwing the NoClassDefFoundError here is just |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
519 |
// a convenient way to stop repeat attempts to verify the same (bad) class. |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
520 |
// |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
521 |
// Note that the NoClassDefFoundError is not part of the JLS, and should not be thrown |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
522 |
// if we are executing Java code. This is not a problem for CDS dumping phase since |
55dc92f033b9
8166203: NoClassDefFoundError should not be thrown if class is in_error_state at link time
iklam
parents:
41669
diff
changeset
|
523 |
// it doesn't execute any Java code. |
1 | 524 |
ResourceMark rm(THREAD); |
46431
87b0d1afe03e
8056900: Enhance NoClassDefFound exception messaging
hseigel
parents:
46408
diff
changeset
|
525 |
Exceptions::fthrow(THREAD_AND_LOCATION, |
87b0d1afe03e
8056900: Enhance NoClassDefFound exception messaging
hseigel
parents:
46408
diff
changeset
|
526 |
vmSymbols::java_lang_NoClassDefFoundError(), |
87b0d1afe03e
8056900: Enhance NoClassDefFound exception messaging
hseigel
parents:
46408
diff
changeset
|
527 |
"Class %s, or one of its supertypes, failed class initialization", |
87b0d1afe03e
8056900: Enhance NoClassDefFound exception messaging
hseigel
parents:
46408
diff
changeset
|
528 |
external_name()); |
87b0d1afe03e
8056900: Enhance NoClassDefFound exception messaging
hseigel
parents:
46408
diff
changeset
|
529 |
return false; |
1 | 530 |
} |
531 |
// return if already verified |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
532 |
if (is_linked()) { |
1 | 533 |
return true; |
534 |
} |
|
535 |
||
536 |
// Timing |
|
537 |
// timer handles recursion |
|
538 |
assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl"); |
|
539 |
JavaThread* jt = (JavaThread*)THREAD; |
|
540 |
||
541 |
// link super class before linking this class |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
542 |
Klass* super_klass = super(); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
543 |
if (super_klass != NULL) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
544 |
if (super_klass->is_interface()) { // check if super class is an interface |
1 | 545 |
ResourceMark rm(THREAD); |
546 |
Exceptions::fthrow( |
|
547 |
THREAD_AND_LOCATION, |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
548 |
vmSymbols::java_lang_IncompatibleClassChangeError(), |
1 | 549 |
"class %s has interface %s as super class", |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
550 |
external_name(), |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
551 |
super_klass->external_name() |
1 | 552 |
); |
553 |
return false; |
|
554 |
} |
|
555 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
556 |
InstanceKlass* ik_super = InstanceKlass::cast(super_klass); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
557 |
ik_super->link_class_impl(throw_verifyerror, CHECK_false); |
1 | 558 |
} |
559 |
||
560 |
// link all interfaces implemented by this class before linking this class |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
561 |
Array<Klass*>* interfaces = local_interfaces(); |
1 | 562 |
int num_interfaces = interfaces->length(); |
563 |
for (int index = 0; index < num_interfaces; index++) { |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
564 |
InstanceKlass* interk = InstanceKlass::cast(interfaces->at(index)); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
565 |
interk->link_class_impl(throw_verifyerror, CHECK_false); |
1 | 566 |
} |
567 |
||
568 |
// in case the class is linked in the process of linking its superclasses |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
569 |
if (is_linked()) { |
1 | 570 |
return true; |
571 |
} |
|
572 |
||
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
573 |
// trace only the link time for this klass that includes |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
574 |
// the verification time |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
575 |
PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
576 |
ClassLoader::perf_class_link_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
577 |
ClassLoader::perf_classes_linked(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
578 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
579 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
580 |
PerfClassTraceTime::CLASS_LINK); |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
581 |
|
1 | 582 |
// verification & rewriting |
583 |
{ |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
584 |
HandleMark hm(THREAD); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
585 |
Handle h_init_lock(THREAD, init_lock()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
586 |
ObjectLocker ol(h_init_lock, THREAD, init_lock() != NULL); |
1 | 587 |
// rewritten will have been set if loader constraint error found |
588 |
// on an earlier link attempt |
|
589 |
// don't verify or rewrite if already rewritten |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
590 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
591 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
592 |
if (!is_linked()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
593 |
if (!is_rewritten()) { |
1 | 594 |
{ |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
595 |
bool verify_ok = verify_code(throw_verifyerror, THREAD); |
1 | 596 |
if (!verify_ok) { |
597 |
return false; |
|
598 |
} |
|
599 |
} |
|
600 |
||
601 |
// Just in case a side-effect of verify linked this class already |
|
602 |
// (which can sometimes happen since the verifier loads classes |
|
603 |
// using custom class loaders, which are free to initialize things) |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
604 |
if (is_linked()) { |
1 | 605 |
return true; |
606 |
} |
|
607 |
||
608 |
// also sets rewritten |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
609 |
rewrite_class(CHECK_false); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
610 |
} else if (is_shared()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
611 |
SystemDictionaryShared::check_verification_constraints(this, CHECK_false); |
1 | 612 |
} |
613 |
||
9971 | 614 |
// relocate jsrs and link methods after they are all rewritten |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
615 |
link_methods(CHECK_false); |
9971 | 616 |
|
1 | 617 |
// Initialize the vtable and interface table after |
618 |
// methods have been rewritten since rewrite may |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
619 |
// fabricate new Method*s. |
1 | 620 |
// also does loader constraint checking |
39714 | 621 |
// |
622 |
// initialize_vtable and initialize_itable need to be rerun for |
|
623 |
// a shared class if the class is not loaded by the NULL classloader. |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
624 |
ClassLoaderData * loader_data = class_loader_data(); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
625 |
if (!(is_shared() && |
39714 | 626 |
loader_data->is_the_null_class_loader_data())) { |
1 | 627 |
ResourceMark rm(THREAD); |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
628 |
vtable().initialize_vtable(true, CHECK_false); |
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
629 |
itable().initialize_itable(true, CHECK_false); |
1 | 630 |
} |
631 |
#ifdef ASSERT |
|
632 |
else { |
|
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
633 |
vtable().verify(tty, true); |
1 | 634 |
// In case itable verification is ever added. |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
635 |
// itable().verify(tty, true); |
1 | 636 |
} |
637 |
#endif |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
638 |
set_init_state(linked); |
1 | 639 |
if (JvmtiExport::should_post_class_prepare()) { |
640 |
Thread *thread = THREAD; |
|
641 |
assert(thread->is_Java_thread(), "thread->is_Java_thread()"); |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
642 |
JvmtiExport::post_class_prepare((JavaThread *) thread, this); |
1 | 643 |
} |
644 |
} |
|
645 |
} |
|
646 |
return true; |
|
647 |
} |
|
648 |
||
649 |
||
650 |
// Rewrite the byte codes of all of the methods of a class. |
|
651 |
// The rewriter must be called exactly once. Rewriting must happen after |
|
652 |
// verification but before the first method of the class is executed. |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
653 |
void InstanceKlass::rewrite_class(TRAPS) { |
1 | 654 |
assert(is_loaded(), "must be loaded"); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
655 |
if (is_rewritten()) { |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
656 |
assert(is_shared(), "rewriting an unshared class?"); |
1 | 657 |
return; |
658 |
} |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
659 |
Rewriter::rewrite(this, CHECK); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
660 |
set_rewritten(); |
1 | 661 |
} |
662 |
||
9971 | 663 |
// Now relocate and link method entry points after class is rewritten. |
664 |
// This is outside is_rewritten flag. In case of an exception, it can be |
|
665 |
// executed more than once. |
|
15099
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
666 |
void InstanceKlass::link_methods(TRAPS) { |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
667 |
int len = methods()->length(); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
668 |
for (int i = len-1; i >= 0; i--) { |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
669 |
methodHandle m(THREAD, methods()->at(i)); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
670 |
|
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
671 |
// Set up method entry points for compiler and interpreter . |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
672 |
m->link_method(m, CHECK); |
b31d40895bbb
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
15097
diff
changeset
|
673 |
} |
9971 | 674 |
} |
675 |
||
27402
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
676 |
// Eagerly initialize superinterfaces that declare default methods (concrete instance: any access) |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
677 |
void InstanceKlass::initialize_super_interfaces(TRAPS) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
678 |
assert (has_nonstatic_concrete_methods(), "caller should have checked this"); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
679 |
for (int i = 0; i < local_interfaces()->length(); ++i) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
680 |
Klass* iface = local_interfaces()->at(i); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
681 |
InstanceKlass* ik = InstanceKlass::cast(iface); |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
682 |
|
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
683 |
// Initialization is depth first search ie. we start with top of the inheritance tree |
41669
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
684 |
// has_nonstatic_concrete_methods drives searching superinterfaces since it |
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
685 |
// means has_nonstatic_concrete_methods in its superinterface hierarchy |
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
686 |
if (ik->has_nonstatic_concrete_methods()) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
687 |
ik->initialize_super_interfaces(CHECK); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
688 |
} |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
689 |
|
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
690 |
// Only initialize() interfaces that "declare" concrete methods. |
41669
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
691 |
if (ik->should_be_initialized() && ik->declares_nonstatic_concrete_methods()) { |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
692 |
ik->initialize(CHECK); |
27402
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
693 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
694 |
} |
5c4675ddc00c
8043275: Fix interface initialization for default methods.
acorn
parents:
26558
diff
changeset
|
695 |
} |
1 | 696 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
697 |
void InstanceKlass::initialize_impl(TRAPS) { |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
698 |
HandleMark hm(THREAD); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
699 |
|
1 | 700 |
// Make sure klass is linked (verified) before initialization |
701 |
// A class could already be verified, since it has been reflected upon. |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
702 |
link_class(CHECK); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
703 |
|
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
704 |
DTRACE_CLASSINIT_PROBE(required, -1); |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
705 |
|
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
706 |
bool wait = false; |
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
707 |
|
1 | 708 |
// refer to the JVM book page 47 for description of steps |
709 |
// Step 1 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
710 |
{ |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
711 |
Handle h_init_lock(THREAD, init_lock()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
712 |
ObjectLocker ol(h_init_lock, THREAD, init_lock() != NULL); |
1 | 713 |
|
714 |
Thread *self = THREAD; // it's passed the current thread |
|
715 |
||
716 |
// Step 2 |
|
717 |
// If we were to use wait() instead of waitInterruptibly() then |
|
718 |
// we might end up throwing IE from link/symbol resolution sites |
|
719 |
// that aren't expected to throw. This would wreak havoc. See 6320309. |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
720 |
while(is_being_initialized() && !is_reentrant_initialization(self)) { |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
721 |
wait = true; |
1 | 722 |
ol.waitUninterruptibly(CHECK); |
723 |
} |
|
724 |
||
725 |
// Step 3 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
726 |
if (is_being_initialized() && is_reentrant_initialization(self)) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
727 |
DTRACE_CLASSINIT_PROBE_WAIT(recursive, -1, wait); |
1 | 728 |
return; |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
729 |
} |
1 | 730 |
|
731 |
// Step 4 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
732 |
if (is_initialized()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
733 |
DTRACE_CLASSINIT_PROBE_WAIT(concurrent, -1, wait); |
1 | 734 |
return; |
5089
0cce506a0158
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
4584
diff
changeset
|
735 |
} |
1 | 736 |
|
737 |
// Step 5 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
738 |
if (is_in_error_state()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
739 |
DTRACE_CLASSINIT_PROBE_WAIT(erroneous, -1, wait); |
1 | 740 |
ResourceMark rm(THREAD); |
741 |
const char* desc = "Could not initialize class "; |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
742 |
const char* className = external_name(); |
1 | 743 |
size_t msglen = strlen(desc) + strlen(className) + 1; |
6421
7c02a5af38e7
6980262: Memory leak when exception is thrown in static initializer
kamg
parents:
6248
diff
changeset
|
744 |
char* message = NEW_RESOURCE_ARRAY(char, msglen); |
1 | 745 |
if (NULL == message) { |
746 |
// Out of memory: can't create detailed error message |
|
747 |
THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className); |
|
748 |
} else { |
|
749 |
jio_snprintf(message, msglen, "%s%s", desc, className); |
|
750 |
THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message); |
|
751 |
} |
|
752 |
} |
|
753 |
||
754 |
// Step 6 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
755 |
set_init_state(being_initialized); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
756 |
set_init_thread(self); |
1 | 757 |
} |
758 |
||
759 |
// Step 7 |
|
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
760 |
// Next, if C is a class rather than an interface, initialize it's super class and super |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
761 |
// interfaces. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
762 |
if (!is_interface()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
763 |
Klass* super_klass = super(); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
764 |
if (super_klass != NULL && super_klass->should_be_initialized()) { |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
765 |
super_klass->initialize(THREAD); |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
766 |
} |
41669
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
767 |
// If C implements any interface that declares a non-static, concrete method, |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
768 |
// the initialization of C triggers initialization of its super interfaces. |
41669
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
769 |
// Only need to recurse if has_nonstatic_concrete_methods which includes declaring and |
2091069b6851
8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents:
41293
diff
changeset
|
770 |
// having a superinterface that declares, non-static, concrete methods |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
771 |
if (!HAS_PENDING_EXCEPTION && has_nonstatic_concrete_methods()) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
772 |
initialize_super_interfaces(THREAD); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
773 |
} |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
774 |
|
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
775 |
// If any exceptions, complete abruptly, throwing the same exception as above. |
1 | 776 |
if (HAS_PENDING_EXCEPTION) { |
777 |
Handle e(THREAD, PENDING_EXCEPTION); |
|
778 |
CLEAR_PENDING_EXCEPTION; |
|
779 |
{ |
|
780 |
EXCEPTION_MARK; |
|
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
781 |
// Locks object, set state, and notify all waiting threads |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
782 |
set_initialization_state_and_notify(initialization_error, THREAD); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
783 |
CLEAR_PENDING_EXCEPTION; |
1 | 784 |
} |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
785 |
DTRACE_CLASSINIT_PROBE_WAIT(super__failed, -1, wait); |
1 | 786 |
THROW_OOP(e()); |
787 |
} |
|
788 |
} |
|
789 |
||
14385 | 790 |
|
42650 | 791 |
// Look for aot compiled methods for this klass, including class initializer. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
792 |
AOTLoader::load_for_klass(this, THREAD); |
42650 | 793 |
|
1 | 794 |
// Step 8 |
795 |
{ |
|
796 |
assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); |
|
797 |
JavaThread* jt = (JavaThread*)THREAD; |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
798 |
DTRACE_CLASSINIT_PROBE_WAIT(clinit, -1, wait); |
1 | 799 |
// Timer includes any side effects of class initialization (resolution, |
800 |
// etc), but not recursive entry into call_class_initializer(). |
|
3575
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
801 |
PerfClassTraceTime timer(ClassLoader::perf_class_init_time(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
802 |
ClassLoader::perf_class_init_selftime(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
803 |
ClassLoader::perf_classes_inited(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
804 |
jt->get_thread_stat()->perf_recursion_counts_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
805 |
jt->get_thread_stat()->perf_timers_addr(), |
224791e7ecab
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
2343
diff
changeset
|
806 |
PerfClassTraceTime::CLASS_CLINIT); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
807 |
call_class_initializer(THREAD); |
1 | 808 |
} |
809 |
||
810 |
// Step 9 |
|
811 |
if (!HAS_PENDING_EXCEPTION) { |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
812 |
set_initialization_state_and_notify(fully_initialized, CHECK); |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
813 |
{ |
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
814 |
debug_only(vtable().verify(tty, true);) |
1 | 815 |
} |
816 |
} |
|
817 |
else { |
|
818 |
// Step 10 and 11 |
|
819 |
Handle e(THREAD, PENDING_EXCEPTION); |
|
820 |
CLEAR_PENDING_EXCEPTION; |
|
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
821 |
// JVMTI has already reported the pending exception |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
822 |
// JVMTI internal flag reset is needed in order to report ExceptionInInitializerError |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
823 |
JvmtiExport::clear_detected_exception((JavaThread*)THREAD); |
1 | 824 |
{ |
825 |
EXCEPTION_MARK; |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
826 |
set_initialization_state_and_notify(initialization_error, THREAD); |
1 | 827 |
CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below |
22897
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
828 |
// JVMTI has already reported the pending exception |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
829 |
// JVMTI internal flag reset is needed in order to report ExceptionInInitializerError |
77e1024a4a14
4505697: nsk/jdi/ExceptionEvent/_itself_/exevent006 and exevent008 tests fail with InvocationTargetException
jbachorik
parents:
22881
diff
changeset
|
830 |
JvmtiExport::clear_detected_exception((JavaThread*)THREAD); |
1 | 831 |
} |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
832 |
DTRACE_CLASSINIT_PROBE_WAIT(error, -1, wait); |
4571 | 833 |
if (e->is_a(SystemDictionary::Error_klass())) { |
1 | 834 |
THROW_OOP(e()); |
835 |
} else { |
|
836 |
JavaCallArguments args(e); |
|
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
837 |
THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(), |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
838 |
vmSymbols::throwable_void_signature(), |
1 | 839 |
&args); |
840 |
} |
|
841 |
} |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
842 |
DTRACE_CLASSINIT_PROBE_WAIT(end, -1, wait); |
1 | 843 |
} |
844 |
||
845 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
846 |
void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
847 |
Handle h_init_lock(THREAD, init_lock()); |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
848 |
if (init_lock() != NULL) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
849 |
ObjectLocker ol(h_init_lock, THREAD); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
850 |
set_init_state(state); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
851 |
fence_and_clear_init_lock(); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
852 |
ol.notify_all(CHECK); |
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
853 |
} else { |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
854 |
assert(init_lock() != NULL, "The initialization state should never be set twice"); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
855 |
set_init_state(state); |
41293
871b2f487dc0
8163969: Cyclic interface initialization causes JVM crash
coleenp
parents:
41183
diff
changeset
|
856 |
} |
1 | 857 |
} |
858 |
||
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
859 |
// The embedded _implementor field can only record one implementor. |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
860 |
// When there are more than one implementors, the _implementor field |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
861 |
// is set to the interface Klass* itself. Following are the possible |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
862 |
// values for the _implementor field: |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
863 |
// NULL - no implementor |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
864 |
// implementor Klass* - one implementor |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
865 |
// self - more than one implementor |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
866 |
// |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
867 |
// The _implementor field only exists for interfaces. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
868 |
void InstanceKlass::add_implementor(Klass* k) { |
1 | 869 |
assert(Compile_lock->owned_by_self(), ""); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
870 |
assert(is_interface(), "not interface"); |
1 | 871 |
// Filter out my subinterfaces. |
872 |
// (Note: Interfaces are never on the subklass list.) |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
873 |
if (InstanceKlass::cast(k)->is_interface()) return; |
1 | 874 |
|
875 |
// Filter out subclasses whose supers already implement me. |
|
876 |
// (Note: CHA must walk subclasses of direct implementors |
|
877 |
// in order to locate indirect implementors.) |
|
33602 | 878 |
Klass* sk = k->super(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
879 |
if (sk != NULL && InstanceKlass::cast(sk)->implements_interface(this)) |
1 | 880 |
// We only need to check one immediate superclass, since the |
881 |
// implements_interface query looks at transitive_interfaces. |
|
882 |
// Any supers of the super have the same (or fewer) transitive_interfaces. |
|
883 |
return; |
|
884 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
885 |
Klass* ik = implementor(); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
886 |
if (ik == NULL) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
887 |
set_implementor(k); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
888 |
} else if (ik != this) { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
889 |
// There is already an implementor. Use itself as an indicator of |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
890 |
// more than one implementors. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
891 |
set_implementor(this); |
1 | 892 |
} |
893 |
||
894 |
// The implementor also implements the transitive_interfaces |
|
895 |
for (int index = 0; index < local_interfaces()->length(); index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
896 |
InstanceKlass::cast(local_interfaces()->at(index))->add_implementor(k); |
1 | 897 |
} |
898 |
} |
|
899 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
900 |
void InstanceKlass::init_implementor() { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
901 |
if (is_interface()) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
902 |
set_implementor(NULL); |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
903 |
} |
1 | 904 |
} |
905 |
||
906 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
907 |
void InstanceKlass::process_interfaces(Thread *thread) { |
1 | 908 |
// link this class into the implementors list of every interface it implements |
909 |
for (int i = local_interfaces()->length() - 1; i >= 0; i--) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
910 |
assert(local_interfaces()->at(i)->is_klass(), "must be a klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
911 |
InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i)); |
1 | 912 |
assert(interf->is_interface(), "expected interface"); |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
913 |
interf->add_implementor(this); |
1 | 914 |
} |
915 |
} |
|
916 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
917 |
bool InstanceKlass::can_be_primary_super_slow() const { |
1 | 918 |
if (is_interface()) |
919 |
return false; |
|
920 |
else |
|
921 |
return Klass::can_be_primary_super_slow(); |
|
922 |
} |
|
923 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
924 |
GrowableArray<Klass*>* InstanceKlass::compute_secondary_supers(int num_extra_slots) { |
1 | 925 |
// The secondaries are the implemented interfaces. |
33602 | 926 |
Array<Klass*>* interfaces = transitive_interfaces(); |
1 | 927 |
int num_secondaries = num_extra_slots + interfaces->length(); |
928 |
if (num_secondaries == 0) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
929 |
// Must share this for correct bootstrapping! |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
930 |
set_secondary_supers(Universe::the_empty_klass_array()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
931 |
return NULL; |
1 | 932 |
} else if (num_extra_slots == 0) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
933 |
// The secondary super list is exactly the same as the transitive interfaces. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
934 |
// Redefine classes has to be careful not to delete this! |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
935 |
set_secondary_supers(interfaces); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
936 |
return NULL; |
1 | 937 |
} else { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
938 |
// Copy transitive interfaces to a temporary growable array to be constructed |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
939 |
// into the secondary super list with extra slots. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
940 |
GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(interfaces->length()); |
1 | 941 |
for (int i = 0; i < interfaces->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
942 |
secondaries->push(interfaces->at(i)); |
1 | 943 |
} |
944 |
return secondaries; |
|
945 |
} |
|
946 |
} |
|
947 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
948 |
bool InstanceKlass::compute_is_subtype_of(Klass* k) { |
14488 | 949 |
if (k->is_interface()) { |
1 | 950 |
return implements_interface(k); |
951 |
} else { |
|
952 |
return Klass::compute_is_subtype_of(k); |
|
953 |
} |
|
954 |
} |
|
955 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
956 |
bool InstanceKlass::implements_interface(Klass* k) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
957 |
if (this == k) return true; |
14488 | 958 |
assert(k->is_interface(), "should be an interface class"); |
1 | 959 |
for (int i = 0; i < transitive_interfaces()->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
960 |
if (transitive_interfaces()->at(i) == k) { |
1 | 961 |
return true; |
962 |
} |
|
963 |
} |
|
964 |
return false; |
|
965 |
} |
|
966 |
||
21768
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
967 |
bool InstanceKlass::is_same_or_direct_interface(Klass *k) const { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
968 |
// Verify direct super interface |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
969 |
if (this == k) return true; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
970 |
assert(k->is_interface(), "should be an interface class"); |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
971 |
for (int i = 0; i < local_interfaces()->length(); i++) { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
972 |
if (local_interfaces()->at(i) == k) { |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
973 |
return true; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
974 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
975 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
976 |
return false; |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
977 |
} |
b7dba4cde1c6
8026065: InterfaceMethodref for invokespecial must name a direct superinterface
hseigel
parents:
21581
diff
changeset
|
978 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
979 |
objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) { |
1 | 980 |
if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
981 |
if (length > arrayOopDesc::max_array_length(T_OBJECT)) { |
|
3576
4ceec8fb3e18
6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents:
3575
diff
changeset
|
982 |
report_java_out_of_memory("Requested array size exceeds VM limit"); |
12114
9a825a536095
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
11407
diff
changeset
|
983 |
JvmtiExport::post_array_size_exhausted(); |
1 | 984 |
THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
985 |
} |
|
986 |
int size = objArrayOopDesc::object_size(length); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
987 |
Klass* ak = array_klass(n, CHECK_NULL); |
1 | 988 |
objArrayOop o = |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
989 |
(objArrayOop)CollectedHeap::array_allocate(ak, size, length, CHECK_NULL); |
1 | 990 |
return o; |
991 |
} |
|
992 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
993 |
instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) { |
1 | 994 |
if (TraceFinalizerRegistration) { |
995 |
tty->print("Registered "); |
|
996 |
i->print_value_on(tty); |
|
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
997 |
tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", p2i(i)); |
1 | 998 |
} |
999 |
instanceHandle h_i(THREAD, i); |
|
1000 |
// Pass the handle as argument, JavaCalls::call expects oop as jobjects |
|
1001 |
JavaValue result(T_VOID); |
|
1002 |
JavaCallArguments args(h_i); |
|
1003 |
methodHandle mh (THREAD, Universe::finalizer_register_method()); |
|
1004 |
JavaCalls::call(&result, mh, &args, CHECK_NULL); |
|
1005 |
return h_i(); |
|
1006 |
} |
|
1007 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1008 |
instanceOop InstanceKlass::allocate_instance(TRAPS) { |
1 | 1009 |
bool has_finalizer_flag = has_finalizer(); // Query before possible GC |
1010 |
int size = size_helper(); // Query before forming handle. |
|
1011 |
||
1012 |
instanceOop i; |
|
1013 |
||
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1014 |
i = (instanceOop)CollectedHeap::obj_allocate(this, size, CHECK_NULL); |
1 | 1015 |
if (has_finalizer_flag && !RegisterFinalizersAtInit) { |
1016 |
i = register_finalizer(i, CHECK_NULL); |
|
1017 |
} |
|
1018 |
return i; |
|
1019 |
} |
|
1020 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1021 |
void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) { |
1 | 1022 |
if (is_interface() || is_abstract()) { |
1023 |
ResourceMark rm(THREAD); |
|
1024 |
THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError() |
|
1025 |
: vmSymbols::java_lang_InstantiationException(), external_name()); |
|
1026 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1027 |
if (this == SystemDictionary::Class_klass()) { |
1 | 1028 |
ResourceMark rm(THREAD); |
1029 |
THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError() |
|
1030 |
: vmSymbols::java_lang_IllegalAccessException(), external_name()); |
|
1031 |
} |
|
1032 |
} |
|
1033 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1034 |
Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) { |
40887
8d35e19f5548
8158854: Ensure release_store is paired with load_acquire in lock-free code
dholmes
parents:
40655
diff
changeset
|
1035 |
// Need load-acquire for lock-free read |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1036 |
if (array_klasses_acquire() == NULL) { |
1 | 1037 |
if (or_null) return NULL; |
1038 |
||
1039 |
ResourceMark rm; |
|
1040 |
JavaThread *jt = (JavaThread *)THREAD; |
|
1041 |
{ |
|
1042 |
// Atomic creation of array_klasses |
|
1043 |
MutexLocker mc(Compile_lock, THREAD); // for vtables |
|
1044 |
MutexLocker ma(MultiArray_lock, THREAD); |
|
1045 |
||
1046 |
// Check if update has already taken place |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1047 |
if (array_klasses() == NULL) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1048 |
Klass* k = ObjArrayKlass::allocate_objArray_klass(class_loader_data(), 1, this, CHECK_NULL); |
40887
8d35e19f5548
8158854: Ensure release_store is paired with load_acquire in lock-free code
dholmes
parents:
40655
diff
changeset
|
1049 |
// use 'release' to pair with lock-free load |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1050 |
release_set_array_klasses(k); |
1 | 1051 |
} |
1052 |
} |
|
1053 |
} |
|
1054 |
// _this will always be set at this point |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1055 |
ObjArrayKlass* oak = (ObjArrayKlass*)array_klasses(); |
1 | 1056 |
if (or_null) { |
1057 |
return oak->array_klass_or_null(n); |
|
1058 |
} |
|
27680
8ecc0871c18e
8064811: Use THREAD instead of CHECK_NULL in return statements
stefank
parents:
27435
diff
changeset
|
1059 |
return oak->array_klass(n, THREAD); |
1 | 1060 |
} |
1061 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1062 |
Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) { |
1 | 1063 |
return array_klass_impl(or_null, 1, THREAD); |
1064 |
} |
|
1065 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1066 |
static int call_class_initializer_counter = 0; // for debugging |
1 | 1067 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
1068 |
Method* InstanceKlass::class_initializer() const { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1069 |
Method* clinit = find_method( |
8653
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1070 |
vmSymbols::class_initializer_name(), vmSymbols::void_method_signature()); |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1071 |
if (clinit != NULL && clinit->has_valid_initializer_flags()) { |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1072 |
return clinit; |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1073 |
} |
8797d788a4f1
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
8297
diff
changeset
|
1074 |
return NULL; |
1 | 1075 |
} |
1076 |
||
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1077 |
void InstanceKlass::call_class_initializer(TRAPS) { |
14477
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1078 |
if (ReplayCompiles && |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1079 |
(ReplaySuppressInitializers == 1 || |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1080 |
ReplaySuppressInitializers >= 2 && class_loader() != NULL)) { |
14477
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1081 |
// Hide the existence of the initializer for the purpose of replaying the compile |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1082 |
return; |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1083 |
} |
95e66ea71f71
6830717: replay of compilations would help with debugging
minqi
parents:
14385
diff
changeset
|
1084 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1085 |
methodHandle h_method(THREAD, class_initializer()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1086 |
assert(!is_initialized(), "we cannot initialize twice"); |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38094
diff
changeset
|
1087 |
if (log_is_enabled(Info, class, init)) { |
34628
6d08ec72803b
8142976: Reimplement TraceClassInitialization with Unified Logging
mockner
parents:
33638
diff
changeset
|
1088 |
ResourceMark rm; |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38094
diff
changeset
|
1089 |
outputStream* log = Log(class, init)::info_stream(); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1090 |
log->print("%d Initializing ", call_class_initializer_counter++); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1091 |
name()->print_value_on(log); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1092 |
log->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", p2i(this)); |
1 | 1093 |
} |
1094 |
if (h_method() != NULL) { |
|
1095 |
JavaCallArguments args; // No arguments |
|
1096 |
JavaValue result(T_VOID); |
|
1097 |
JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args) |
|
1098 |
} |
|
1099 |
} |
|
1100 |
||
1101 |
||
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33576
diff
changeset
|
1102 |
void InstanceKlass::mask_for(const methodHandle& method, int bci, |
1 | 1103 |
InterpreterOopMap* entry_for) { |
38937
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1104 |
// Lazily create the _oop_map_cache at first request |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1105 |
// Lock-free access requires load_ptr_acquire. |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1106 |
OopMapCache* oop_map_cache = |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1107 |
static_cast<OopMapCache*>(OrderAccess::load_ptr_acquire(&_oop_map_cache)); |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1108 |
if (oop_map_cache == NULL) { |
1 | 1109 |
MutexLocker x(OopMapCacheAlloc_lock); |
38937
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1110 |
// Check if _oop_map_cache was allocated while we were waiting for this lock |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1111 |
if ((oop_map_cache = _oop_map_cache) == NULL) { |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1112 |
oop_map_cache = new OopMapCache(); |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1113 |
// Ensure _oop_map_cache is stable, since it is examined without a lock |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1114 |
OrderAccess::release_store_ptr(&_oop_map_cache, oop_map_cache); |
1 | 1115 |
} |
1116 |
} |
|
38937
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1117 |
// _oop_map_cache is constant after init; lookup below does its own locking. |
2bf3c37c4841
8154750: Add missing OrderAccess operations to ClassLoaderData lock-free data structures
dholmes
parents:
38259
diff
changeset
|
1118 |
oop_map_cache->lookup(method, bci, entry_for); |
1 | 1119 |
} |
1120 |
||
1121 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1122 |
bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1123 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
10546 | 1124 |
Symbol* f_name = fs.name(); |
1125 |
Symbol* f_sig = fs.signature(); |
|
1 | 1126 |
if (f_name == name && f_sig == sig) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1127 |
fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index()); |
1 | 1128 |
return true; |
1129 |
} |
|
1130 |
} |
|
1131 |
return false; |
|
1132 |
} |
|
1133 |
||
1134 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1135 |
Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
1 | 1136 |
const int n = local_interfaces()->length(); |
1137 |
for (int i = 0; i < n; i++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1138 |
Klass* intf1 = local_interfaces()->at(i); |
14488 | 1139 |
assert(intf1->is_interface(), "just checking type"); |
1 | 1140 |
// search for field in current interface |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1141 |
if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) { |
1 | 1142 |
assert(fd->is_static(), "interface field must be static"); |
1143 |
return intf1; |
|
1144 |
} |
|
1145 |
// search for field in direct superinterfaces |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1146 |
Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd); |
1 | 1147 |
if (intf2 != NULL) return intf2; |
1148 |
} |
|
1149 |
// otherwise field lookup fails |
|
1150 |
return NULL; |
|
1151 |
} |
|
1152 |
||
1153 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1154 |
Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
1 | 1155 |
// search order according to newest JVM spec (5.4.3.2, p.167). |
1156 |
// 1) search for field in current klass |
|
1157 |
if (find_local_field(name, sig, fd)) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1158 |
return const_cast<InstanceKlass*>(this); |
1 | 1159 |
} |
1160 |
// 2) search for field recursively in direct superinterfaces |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1161 |
{ Klass* intf = find_interface_field(name, sig, fd); |
1 | 1162 |
if (intf != NULL) return intf; |
1163 |
} |
|
1164 |
// 3) apply field lookup recursively if superclass exists |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1165 |
{ Klass* supr = super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1166 |
if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd); |
1 | 1167 |
} |
1168 |
// 4) otherwise field lookup fails |
|
1169 |
return NULL; |
|
1170 |
} |
|
1171 |
||
1172 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1173 |
Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const { |
1 | 1174 |
// search order according to newest JVM spec (5.4.3.2, p.167). |
1175 |
// 1) search for field in current klass |
|
1176 |
if (find_local_field(name, sig, fd)) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1177 |
if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this); |
1 | 1178 |
} |
1179 |
// 2) search for field recursively in direct superinterfaces |
|
1180 |
if (is_static) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1181 |
Klass* intf = find_interface_field(name, sig, fd); |
1 | 1182 |
if (intf != NULL) return intf; |
1183 |
} |
|
1184 |
// 3) apply field lookup recursively if superclass exists |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1185 |
{ Klass* supr = super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1186 |
if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd); |
1 | 1187 |
} |
1188 |
// 4) otherwise field lookup fails |
|
1189 |
return NULL; |
|
1190 |
} |
|
1191 |
||
1192 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1193 |
bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1194 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
10546 | 1195 |
if (fs.offset() == offset) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1196 |
fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index()); |
1 | 1197 |
if (fd->is_static() == is_static) return true; |
1198 |
} |
|
1199 |
} |
|
1200 |
return false; |
|
1201 |
} |
|
1202 |
||
1203 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1204 |
bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1205 |
Klass* klass = const_cast<InstanceKlass*>(this); |
1 | 1206 |
while (klass != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1207 |
if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) { |
1 | 1208 |
return true; |
1209 |
} |
|
14488 | 1210 |
klass = klass->super(); |
1 | 1211 |
} |
1212 |
return false; |
|
1213 |
} |
|
1214 |
||
1215 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1216 |
void InstanceKlass::methods_do(void f(Method* method)) { |
24658
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1217 |
// Methods aren't stable until they are loaded. This can be read outside |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1218 |
// a lock through the ClassLoaderData for profiling |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1219 |
if (!is_loaded()) { |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1220 |
return; |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1221 |
} |
e41df2fc6e87
8042727: nsk/jdb/unwatch/unwatch001 crash in InstanceKlass::methods_do(void (*)(Method*))
coleenp
parents:
24424
diff
changeset
|
1222 |
|
1 | 1223 |
int len = methods()->length(); |
1224 |
for (int index = 0; index < len; index++) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1225 |
Method* m = methods()->at(index); |
1 | 1226 |
assert(m->is_method(), "must be method"); |
1227 |
f(m); |
|
1228 |
} |
|
1229 |
} |
|
1230 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
1231 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1232 |
void InstanceKlass::do_local_static_fields(FieldClosure* cl) { |
10546 | 1233 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
1234 |
if (fs.access_flags().is_static()) { |
|
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1235 |
fieldDescriptor& fd = fs.field_descriptor(); |
10546 | 1236 |
cl->do_field(&fd); |
1237 |
} |
|
1 | 1238 |
} |
1239 |
} |
|
1240 |
||
1241 |
||
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1242 |
void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, Handle, TRAPS), Handle mirror, TRAPS) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1243 |
for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
10546 | 1244 |
if (fs.access_flags().is_static()) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1245 |
fieldDescriptor& fd = fs.field_descriptor(); |
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
1246 |
f(&fd, mirror, CHECK); |
10546 | 1247 |
} |
1 | 1248 |
} |
1249 |
} |
|
1250 |
||
1251 |
||
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1252 |
static int compare_fields_by_offset(int* a, int* b) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1253 |
return a[0] - b[0]; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1254 |
} |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1255 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1256 |
void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1257 |
InstanceKlass* super = superklass(); |
1 | 1258 |
if (super != NULL) { |
1259 |
super->do_nonstatic_fields(cl); |
|
1260 |
} |
|
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1261 |
fieldDescriptor fd; |
10546 | 1262 |
int length = java_fields_count(); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1263 |
// In DebugInfo nonstatic fields are sorted by offset. |
13195 | 1264 |
int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1265 |
int j = 0; |
10546 | 1266 |
for (int i = 0; i < length; i += 1) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1267 |
fd.reinitialize(this, i); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1268 |
if (!fd.is_static()) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1269 |
fields_sorted[j + 0] = fd.offset(); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1270 |
fields_sorted[j + 1] = i; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1271 |
j += 2; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1272 |
} |
1 | 1273 |
} |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1274 |
if (j > 0) { |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1275 |
length = j; |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1276 |
// _sort_Fn is defined in growableArray.hpp. |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1277 |
qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1278 |
for (int i = 0; i < length; i += 2) { |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
1279 |
fd.reinitialize(this, fields_sorted[i + 1]); |
217
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1280 |
assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields"); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1281 |
cl->do_field(&fd); |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1282 |
} |
c646ef2f5d58
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
1
diff
changeset
|
1283 |
} |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
1284 |
FREE_C_HEAP_ARRAY(int, fields_sorted); |
1 | 1285 |
} |
1286 |
||
1287 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1288 |
void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1289 |
if (array_klasses() != NULL) |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
1290 |
ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1291 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1292 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1293 |
void InstanceKlass::array_klasses_do(void f(Klass* k)) { |
1 | 1294 |
if (array_klasses() != NULL) |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
1295 |
ArrayKlass::cast(array_klasses())->array_klasses_do(f); |
1 | 1296 |
} |
1297 |
||
1298 |
#ifdef ASSERT |
|
34666 | 1299 |
static int linear_search(const Array<Method*>* methods, |
1300 |
const Symbol* name, |
|
1301 |
const Symbol* signature) { |
|
1302 |
const int len = methods->length(); |
|
1 | 1303 |
for (int index = 0; index < len; index++) { |
34666 | 1304 |
const Method* const m = methods->at(index); |
1 | 1305 |
assert(m->is_method(), "must be method"); |
1306 |
if (m->signature() == signature && m->name() == name) { |
|
1307 |
return index; |
|
1308 |
} |
|
1309 |
} |
|
1310 |
return -1; |
|
1311 |
} |
|
1312 |
#endif |
|
1313 |
||
34666 | 1314 |
static int binary_search(const Array<Method*>* methods, const Symbol* name) { |
1 | 1315 |
int len = methods->length(); |
1316 |
// methods are sorted, so do binary search |
|
1317 |
int l = 0; |
|
1318 |
int h = len - 1; |
|
1319 |
while (l <= h) { |
|
1320 |
int mid = (l + h) >> 1; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1321 |
Method* m = methods->at(mid); |
1 | 1322 |
assert(m->is_method(), "must be method"); |
1323 |
int res = m->name()->fast_compare(name); |
|
1324 |
if (res == 0) { |
|
14385 | 1325 |
return mid; |
1 | 1326 |
} else if (res < 0) { |
1327 |
l = mid + 1; |
|
1328 |
} else { |
|
1329 |
h = mid - 1; |
|
1330 |
} |
|
1331 |
} |
|
14385 | 1332 |
return -1; |
1333 |
} |
|
1334 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1335 |
// find_method looks up the name/signature in the local methods array |
34666 | 1336 |
Method* InstanceKlass::find_method(const Symbol* name, |
1337 |
const Symbol* signature) const { |
|
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1338 |
return find_method_impl(name, signature, find_overpass, find_static, find_private); |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1339 |
} |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1340 |
|
34666 | 1341 |
Method* InstanceKlass::find_method_impl(const Symbol* name, |
1342 |
const Symbol* signature, |
|
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1343 |
OverpassLookupMode overpass_mode, |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1344 |
StaticLookupMode static_mode, |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1345 |
PrivateLookupMode private_mode) const { |
34666 | 1346 |
return InstanceKlass::find_method_impl(methods(), |
1347 |
name, |
|
1348 |
signature, |
|
1349 |
overpass_mode, |
|
1350 |
static_mode, |
|
1351 |
private_mode); |
|
14385 | 1352 |
} |
1353 |
||
21913
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1354 |
// find_instance_method looks up the name/signature in the local methods array |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1355 |
// and skips over static methods |
34666 | 1356 |
Method* InstanceKlass::find_instance_method(const Array<Method*>* methods, |
1357 |
const Symbol* name, |
|
1358 |
const Symbol* signature) { |
|
1359 |
Method* const meth = InstanceKlass::find_method_impl(methods, |
|
1360 |
name, |
|
1361 |
signature, |
|
1362 |
find_overpass, |
|
1363 |
skip_static, |
|
1364 |
find_private); |
|
1365 |
assert(((meth == NULL) || !meth->is_static()), |
|
1366 |
"find_instance_method should have skipped statics"); |
|
21913
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1367 |
return meth; |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1368 |
} |
0e2fd7282ac6
8028438: static superclass method masks default methods
acorn
parents:
21768
diff
changeset
|
1369 |
|
28514 | 1370 |
// find_instance_method looks up the name/signature in the local methods array |
1371 |
// and skips over static methods |
|
34666 | 1372 |
Method* InstanceKlass::find_instance_method(const Symbol* name, const Symbol* signature) const { |
1373 |
return InstanceKlass::find_instance_method(methods(), name, signature); |
|
28514 | 1374 |
} |
1375 |
||
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1376 |
// Find looks up the name/signature in the local methods array |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1377 |
// and filters on the overpass, static and private flags |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1378 |
// This returns the first one found |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1379 |
// note that the local methods array can have up to one overpass, one static |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1380 |
// and one instance (private or not) with the same name/signature |
34666 | 1381 |
Method* InstanceKlass::find_local_method(const Symbol* name, |
1382 |
const Symbol* signature, |
|
1383 |
OverpassLookupMode overpass_mode, |
|
1384 |
StaticLookupMode static_mode, |
|
1385 |
PrivateLookupMode private_mode) const { |
|
1386 |
return InstanceKlass::find_method_impl(methods(), |
|
1387 |
name, |
|
1388 |
signature, |
|
1389 |
overpass_mode, |
|
1390 |
static_mode, |
|
1391 |
private_mode); |
|
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1392 |
} |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1393 |
|
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1394 |
// Find looks up the name/signature in the local methods array |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1395 |
// and filters on the overpass, static and private flags |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1396 |
// This returns the first one found |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1397 |
// note that the local methods array can have up to one overpass, one static |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1398 |
// and one instance (private or not) with the same name/signature |
34666 | 1399 |
Method* InstanceKlass::find_local_method(const Array<Method*>* methods, |
1400 |
const Symbol* name, |
|
1401 |
const Symbol* signature, |
|
1402 |
OverpassLookupMode overpass_mode, |
|
1403 |
StaticLookupMode static_mode, |
|
1404 |
PrivateLookupMode private_mode) { |
|
1405 |
return InstanceKlass::find_method_impl(methods, |
|
1406 |
name, |
|
1407 |
signature, |
|
1408 |
overpass_mode, |
|
1409 |
static_mode, |
|
1410 |
private_mode); |
|
1411 |
} |
|
1412 |
||
1413 |
Method* InstanceKlass::find_method(const Array<Method*>* methods, |
|
1414 |
const Symbol* name, |
|
1415 |
const Symbol* signature) { |
|
1416 |
return InstanceKlass::find_method_impl(methods, |
|
1417 |
name, |
|
1418 |
signature, |
|
1419 |
find_overpass, |
|
1420 |
find_static, |
|
1421 |
find_private); |
|
1422 |
} |
|
1423 |
||
1424 |
Method* InstanceKlass::find_method_impl(const Array<Method*>* methods, |
|
1425 |
const Symbol* name, |
|
1426 |
const Symbol* signature, |
|
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1427 |
OverpassLookupMode overpass_mode, |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1428 |
StaticLookupMode static_mode, |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1429 |
PrivateLookupMode private_mode) { |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1430 |
int hit = find_method_index(methods, name, signature, overpass_mode, static_mode, private_mode); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1431 |
return hit >= 0 ? methods->at(hit): NULL; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1432 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1433 |
|
34666 | 1434 |
// true if method matches signature and conforms to skipping_X conditions. |
1435 |
static bool method_matches(const Method* m, |
|
1436 |
const Symbol* signature, |
|
1437 |
bool skipping_overpass, |
|
1438 |
bool skipping_static, |
|
1439 |
bool skipping_private) { |
|
1440 |
return ((m->signature() == signature) && |
|
1441 |
(!skipping_overpass || !m->is_overpass()) && |
|
1442 |
(!skipping_static || !m->is_static()) && |
|
1443 |
(!skipping_private || !m->is_private())); |
|
28514 | 1444 |
} |
1445 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1446 |
// Used directly for default_methods to find the index into the |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1447 |
// default_vtable_indices, and indirectly by find_method |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1448 |
// find_method_index looks in the local methods array to return the index |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1449 |
// of the matching name/signature. If, overpass methods are being ignored, |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1450 |
// the search continues to find a potential non-overpass match. This capability |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1451 |
// is important during method resolution to prefer a static method, for example, |
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1452 |
// over an overpass method. |
32189
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1453 |
// There is the possibility in any _method's array to have the same name/signature |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1454 |
// for a static method, an overpass method and a local instance method |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1455 |
// To correctly catch a given method, the search criteria may need |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1456 |
// to explicitly skip the other two. For local instance methods, it |
5264b560ab1b
8087342: Crash in klassItable::initialize_itable_for_interface
acorn
parents:
31353
diff
changeset
|
1457 |
// is often necessary to skip private methods |
34666 | 1458 |
int InstanceKlass::find_method_index(const Array<Method*>* methods, |
1459 |
const Symbol* name, |
|
1460 |
const Symbol* signature, |
|
1461 |
OverpassLookupMode overpass_mode, |
|
1462 |
StaticLookupMode static_mode, |
|
1463 |
PrivateLookupMode private_mode) { |
|
1464 |
const bool skipping_overpass = (overpass_mode == skip_overpass); |
|
1465 |
const bool skipping_static = (static_mode == skip_static); |
|
1466 |
const bool skipping_private = (private_mode == skip_private); |
|
1467 |
const int hit = binary_search(methods, name); |
|
14385 | 1468 |
if (hit != -1) { |
34666 | 1469 |
const Method* const m = methods->at(hit); |
28514 | 1470 |
|
14385 | 1471 |
// Do linear search to find matching signature. First, quick check |
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1472 |
// for common case, ignoring overpasses if requested. |
34666 | 1473 |
if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) { |
1474 |
return hit; |
|
1475 |
} |
|
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1476 |
|
14385 | 1477 |
// search downwards through overloaded methods |
1478 |
int i; |
|
1479 |
for (i = hit - 1; i >= 0; --i) { |
|
34666 | 1480 |
const Method* const m = methods->at(i); |
14385 | 1481 |
assert(m->is_method(), "must be method"); |
34666 | 1482 |
if (m->name() != name) { |
1483 |
break; |
|
1484 |
} |
|
1485 |
if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) { |
|
1486 |
return i; |
|
1487 |
} |
|
14385 | 1488 |
} |
1489 |
// search upwards |
|
1490 |
for (i = hit + 1; i < methods->length(); ++i) { |
|
34666 | 1491 |
const Method* const m = methods->at(i); |
14385 | 1492 |
assert(m->is_method(), "must be method"); |
34666 | 1493 |
if (m->name() != name) { |
1494 |
break; |
|
1495 |
} |
|
1496 |
if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) { |
|
1497 |
return i; |
|
1498 |
} |
|
14385 | 1499 |
} |
1500 |
// not found |
|
1 | 1501 |
#ifdef ASSERT |
34666 | 1502 |
const int index = (skipping_overpass || skipping_static || skipping_private) ? -1 : |
1503 |
linear_search(methods, name, signature); |
|
1504 |
assert(-1 == index, "binary search should have found entry %d", index); |
|
1 | 1505 |
#endif |
14385 | 1506 |
} |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1507 |
return -1; |
1 | 1508 |
} |
34666 | 1509 |
|
1510 |
int InstanceKlass::find_method_by_name(const Symbol* name, int* end) const { |
|
14385 | 1511 |
return find_method_by_name(methods(), name, end); |
1512 |
} |
|
1513 |
||
34666 | 1514 |
int InstanceKlass::find_method_by_name(const Array<Method*>* methods, |
1515 |
const Symbol* name, |
|
1516 |
int* end_ptr) { |
|
14385 | 1517 |
assert(end_ptr != NULL, "just checking"); |
1518 |
int start = binary_search(methods, name); |
|
1519 |
int end = start + 1; |
|
1520 |
if (start != -1) { |
|
1521 |
while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start; |
|
1522 |
while (end < methods->length() && (methods->at(end))->name() == name) ++end; |
|
1523 |
*end_ptr = end; |
|
1524 |
return start; |
|
1525 |
} |
|
1526 |
return -1; |
|
1527 |
} |
|
1528 |
||
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1529 |
// uncached_lookup_method searches both the local class methods array and all |
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1530 |
// superclasses methods arrays, skipping any overpass methods in superclasses. |
34666 | 1531 |
Method* InstanceKlass::uncached_lookup_method(const Symbol* name, |
1532 |
const Symbol* signature, |
|
1533 |
OverpassLookupMode overpass_mode) const { |
|
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1534 |
OverpassLookupMode overpass_local_mode = overpass_mode; |
34666 | 1535 |
const Klass* klass = this; |
1 | 1536 |
while (klass != NULL) { |
34666 | 1537 |
Method* const method = InstanceKlass::cast(klass)->find_method_impl(name, |
1538 |
signature, |
|
1539 |
overpass_local_mode, |
|
1540 |
find_static, |
|
1541 |
find_private); |
|
23999
22eb7be3d99d
8033150: invokestatic: IncompatibleClassChangeError trying to invoke static method from a parent in presence of conflicting defaults.
lfoltan
parents:
23873
diff
changeset
|
1542 |
if (method != NULL) { |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1543 |
return method; |
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1544 |
} |
33602 | 1545 |
klass = klass->super(); |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1546 |
overpass_local_mode = skip_overpass; // Always ignore overpass methods in superclasses |
1 | 1547 |
} |
1548 |
return NULL; |
|
1549 |
} |
|
1550 |
||
24828
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1551 |
#ifdef ASSERT |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1552 |
// search through class hierarchy and return true if this class or |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1553 |
// one of the superclasses was redefined |
34666 | 1554 |
bool InstanceKlass::has_redefined_this_or_super() const { |
1555 |
const Klass* klass = this; |
|
24828
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1556 |
while (klass != NULL) { |
33602 | 1557 |
if (InstanceKlass::cast(klass)->has_been_redefined()) { |
24828
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1558 |
return true; |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1559 |
} |
33602 | 1560 |
klass = klass->super(); |
24828
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1561 |
} |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1562 |
return false; |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1563 |
} |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1564 |
#endif |
dd5406c950a1
6904403: assert(f == k->has_finalizer(),"inconsistent has_finalizer") with debug VM
dsamersoff
parents:
24658
diff
changeset
|
1565 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1566 |
// lookup a method in the default methods list then in all transitive interfaces |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1567 |
// Do NOT return private or static methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1568 |
Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name, |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1569 |
Symbol* signature) const { |
20396
0ed0e7aa1ed8
8026185: nsk/jvmit/GetMethodDeclaringClass/declcls001 failed
acorn
parents:
20391
diff
changeset
|
1570 |
Method* m = NULL; |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1571 |
if (default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1572 |
m = find_method(default_methods(), name, signature); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1573 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1574 |
// Look up interfaces |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1575 |
if (m == NULL) { |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1576 |
m = lookup_method_in_all_interfaces(name, signature, find_defaults); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1577 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1578 |
return m; |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1579 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
1580 |
|
1 | 1581 |
// lookup a method in all the interfaces that this class implements |
20284
595a25ab9474
8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents:
20282
diff
changeset
|
1582 |
// Do NOT return private or static methods, new in JDK8 which are not externally visible |
595a25ab9474
8011311: Private interface methods. Default conflicts:ICCE. no erased_super_default.
acorn
parents:
20282
diff
changeset
|
1583 |
// They should only be found in the initial InterfaceMethodRef |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1584 |
Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name, |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1585 |
Symbol* signature, |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1586 |
DefaultsLookupMode defaults_mode) const { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1587 |
Array<Klass*>* all_ifs = transitive_interfaces(); |
1 | 1588 |
int num_ifs = all_ifs->length(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1589 |
InstanceKlass *ik = NULL; |
1 | 1590 |
for (int i = 0; i < num_ifs; i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1591 |
ik = InstanceKlass::cast(all_ifs->at(i)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1592 |
Method* m = ik->lookup_method(name, signature); |
22232
26acfad336c0
8027804: JCK resolveMethod test fails expecting AbstractMethodError
hseigel
parents:
22221
diff
changeset
|
1593 |
if (m != NULL && m->is_public() && !m->is_static() && |
28731
f7339cba0a6a
8067480: Crash in klassItable::initialize_itable_for_interface when running vm.runtime.defmeth.StaticMethodsTest.
lfoltan
parents:
28365
diff
changeset
|
1594 |
((defaults_mode != skip_defaults) || !m->is_default_method())) { |
1 | 1595 |
return m; |
1596 |
} |
|
1597 |
} |
|
1598 |
return NULL; |
|
1599 |
} |
|
1600 |
||
1601 |
/* jni_id_for_impl for jfieldIds only */ |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1602 |
JNIid* InstanceKlass::jni_id_for_impl(int offset) { |
1 | 1603 |
MutexLocker ml(JfieldIdCreation_lock); |
1604 |
// Retry lookup after we got the lock |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1605 |
JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset); |
1 | 1606 |
if (probe == NULL) { |
1607 |
// Slow case, allocate new static field identifier |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1608 |
probe = new JNIid(this, offset, jni_ids()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1609 |
set_jni_ids(probe); |
1 | 1610 |
} |
1611 |
return probe; |
|
1612 |
} |
|
1613 |
||
1614 |
||
1615 |
/* jni_id_for for jfieldIds only */ |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1616 |
JNIid* InstanceKlass::jni_id_for(int offset) { |
1 | 1617 |
JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset); |
1618 |
if (probe == NULL) { |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1619 |
probe = jni_id_for_impl(offset); |
1 | 1620 |
} |
1621 |
return probe; |
|
1622 |
} |
|
1623 |
||
34666 | 1624 |
u2 InstanceKlass::enclosing_method_data(int offset) const { |
1625 |
const Array<jushort>* const inner_class_list = inner_classes(); |
|
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1626 |
if (inner_class_list == NULL) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1627 |
return 0; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1628 |
} |
34666 | 1629 |
const int length = inner_class_list->length(); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1630 |
if (length % inner_class_next_offset == 0) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1631 |
return 0; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1632 |
} |
34666 | 1633 |
const int index = length - enclosing_method_attribute_size; |
1634 |
assert(offset < enclosing_method_attribute_size, "invalid offset"); |
|
1635 |
return inner_class_list->at(index + offset); |
|
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1636 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1637 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1638 |
void InstanceKlass::set_enclosing_method_indices(u2 class_index, |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1639 |
u2 method_index) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1640 |
Array<jushort>* inner_class_list = inner_classes(); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1641 |
assert (inner_class_list != NULL, "_inner_classes list is not set up"); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1642 |
int length = inner_class_list->length(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1643 |
if (length % inner_class_next_offset == enclosing_method_attribute_size) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1644 |
int index = length - enclosing_method_attribute_size; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1645 |
inner_class_list->at_put( |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1646 |
index + enclosing_method_class_index_offset, class_index); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1647 |
inner_class_list->at_put( |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1648 |
index + enclosing_method_method_index_offset, method_index); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1649 |
} |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
1650 |
} |
1 | 1651 |
|
1652 |
// Lookup or create a jmethodID. |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1653 |
// This code is called by the VMThread and JavaThreads so the |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1654 |
// locking has to be done very carefully to avoid deadlocks |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1655 |
// and/or other cache consistency problems. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1656 |
// |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1657 |
jmethodID InstanceKlass::get_jmethod_id(const methodHandle& method_h) { |
1 | 1658 |
size_t idnum = (size_t)method_h->method_idnum(); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1659 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
1 | 1660 |
size_t length = 0; |
1661 |
jmethodID id = NULL; |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1662 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1663 |
// We use a double-check locking idiom here because this cache is |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1664 |
// performance sensitive. In the normal system, this cache only |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1665 |
// transitions from NULL to non-NULL which is safe because we use |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1666 |
// release_set_methods_jmethod_ids() to advertise the new cache. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1667 |
// A partially constructed cache should never be seen by a racing |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1668 |
// thread. We also use release_store_ptr() to save a new jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1669 |
// in the cache so a partially constructed jmethodID should never be |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1670 |
// seen either. Cache reads of existing jmethodIDs proceed without a |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1671 |
// lock, but cache writes of a new jmethodID requires uniqueness and |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1672 |
// creation of the cache itself requires no leaks so a lock is |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1673 |
// generally acquired in those two cases. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1674 |
// |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1675 |
// If the RedefineClasses() API has been used, then this cache can |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1676 |
// grow and we'll have transitions from non-NULL to bigger non-NULL. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1677 |
// Cache creation requires no leaks and we require safety between all |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1678 |
// cache accesses and freeing of the old cache so a lock is generally |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1679 |
// acquired when the RedefineClasses() API has been used. |
1 | 1680 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1681 |
if (jmeths != NULL) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1682 |
// the cache already exists |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1683 |
if (!idnum_can_increment()) { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1684 |
// the cache can't grow so we can just get the current values |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1685 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1686 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1687 |
// cache can grow so we have to be more careful |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1688 |
if (Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1689 |
SafepointSynchronize::is_at_safepoint()) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1690 |
// we're single threaded or at a safepoint - no locking needed |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1691 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1692 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1693 |
MutexLocker ml(JmethodIdCreation_lock); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1694 |
get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1695 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1696 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1697 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1698 |
// implied else: |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1699 |
// we need to allocate a cache so default length and id values are good |
1 | 1700 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1701 |
if (jmeths == NULL || // no cache yet |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1702 |
length <= idnum || // cache is too short |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1703 |
id == NULL) { // cache doesn't contain entry |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1704 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1705 |
// This function can be called by the VMThread so we have to do all |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1706 |
// things that might block on a safepoint before grabbing the lock. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1707 |
// Otherwise, we can deadlock with the VMThread or have a cache |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1708 |
// consistency issue. These vars keep track of what we might have |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1709 |
// to free after the lock is dropped. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1710 |
jmethodID to_dealloc_id = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1711 |
jmethodID* to_dealloc_jmeths = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1712 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1713 |
// may not allocate new_jmeths or use it if we allocate it |
1 | 1714 |
jmethodID* new_jmeths = NULL; |
1715 |
if (length <= idnum) { |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1716 |
// allocate a new cache that might be used |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1717 |
size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count()); |
13195 | 1718 |
new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass); |
1 | 1719 |
memset(new_jmeths, 0, (size+1)*sizeof(jmethodID)); |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1720 |
// cache size is stored in element[0], other elements offset by one |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1721 |
new_jmeths[0] = (jmethodID)size; |
1 | 1722 |
} |
1723 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1724 |
// allocate a new jmethodID that might be used |
1 | 1725 |
jmethodID new_id = NULL; |
1726 |
if (method_h->is_old() && !method_h->is_obsolete()) { |
|
1727 |
// The method passed in is old (but not obsolete), we need to use the current version |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1728 |
Method* current_method = method_with_idnum((int)idnum); |
1 | 1729 |
assert(current_method != NULL, "old and but not obsolete, so should exist"); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1730 |
new_id = Method::make_jmethod_id(class_loader_data(), current_method); |
1 | 1731 |
} else { |
1732 |
// It is the current version of the method or an obsolete method, |
|
1733 |
// use the version passed in |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1734 |
new_id = Method::make_jmethod_id(class_loader_data(), method_h()); |
1 | 1735 |
} |
1736 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1737 |
if (Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1738 |
SafepointSynchronize::is_at_safepoint()) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1739 |
// we're single threaded or at a safepoint - no locking needed |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1740 |
id = get_jmethod_id_fetch_or_update(idnum, new_id, new_jmeths, |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1741 |
&to_dealloc_id, &to_dealloc_jmeths); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1742 |
} else { |
1 | 1743 |
MutexLocker ml(JmethodIdCreation_lock); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1744 |
id = get_jmethod_id_fetch_or_update(idnum, new_id, new_jmeths, |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1745 |
&to_dealloc_id, &to_dealloc_jmeths); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1746 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1747 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1748 |
// The lock has been dropped so we can free resources. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1749 |
// Free up either the old cache or the new cache if we allocated one. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1750 |
if (to_dealloc_jmeths != NULL) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1751 |
FreeHeap(to_dealloc_jmeths); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1752 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1753 |
// free up the new ID since it wasn't needed |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1754 |
if (to_dealloc_id != NULL) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1755 |
Method::destroy_jmethod_id(class_loader_data(), to_dealloc_id); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1756 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1757 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1758 |
return id; |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1759 |
} |
1 | 1760 |
|
27478 | 1761 |
// Figure out how many jmethodIDs haven't been allocated, and make |
1762 |
// sure space for them is pre-allocated. This makes getting all |
|
1763 |
// method ids much, much faster with classes with more than 8 |
|
1764 |
// methods, and has a *substantial* effect on performance with jvmti |
|
1765 |
// code that loads all jmethodIDs for all classes. |
|
1766 |
void InstanceKlass::ensure_space_for_methodids(int start_offset) { |
|
1767 |
int new_jmeths = 0; |
|
1768 |
int length = methods()->length(); |
|
1769 |
for (int index = start_offset; index < length; index++) { |
|
1770 |
Method* m = methods()->at(index); |
|
1771 |
jmethodID id = m->find_jmethod_id_or_null(); |
|
1772 |
if (id == NULL) { |
|
1773 |
new_jmeths++; |
|
1774 |
} |
|
1775 |
} |
|
1776 |
if (new_jmeths != 0) { |
|
1777 |
Method::ensure_jmethod_ids(class_loader_data(), new_jmeths); |
|
1778 |
} |
|
1779 |
} |
|
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1780 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1781 |
// Common code to fetch the jmethodID from the cache or update the |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1782 |
// cache with the new jmethodID. This function should never do anything |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1783 |
// that causes the caller to go to a safepoint or we can deadlock with |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1784 |
// the VMThread or have cache consistency issues. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1785 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1786 |
jmethodID InstanceKlass::get_jmethod_id_fetch_or_update( |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1787 |
size_t idnum, jmethodID new_id, |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1788 |
jmethodID* new_jmeths, jmethodID* to_dealloc_id_p, |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1789 |
jmethodID** to_dealloc_jmeths_p) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1790 |
assert(new_id != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1791 |
assert(to_dealloc_id_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1792 |
assert(to_dealloc_jmeths_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1793 |
assert(Threads::number_of_threads() == 0 || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1794 |
SafepointSynchronize::is_at_safepoint() || |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1795 |
JmethodIdCreation_lock->owned_by_self(), "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1796 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1797 |
// reacquire the cache - we are locked, single threaded or at a safepoint |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1798 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1799 |
jmethodID id = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1800 |
size_t length = 0; |
1 | 1801 |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1802 |
if (jmeths == NULL || // no cache yet |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1803 |
(length = (size_t)jmeths[0]) <= idnum) { // cache is too short |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1804 |
if (jmeths != NULL) { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1805 |
// copy any existing entries from the old cache |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1806 |
for (size_t index = 0; index < length; index++) { |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1807 |
new_jmeths[index+1] = jmeths[index+1]; |
1 | 1808 |
} |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1809 |
*to_dealloc_jmeths_p = jmeths; // save old cache for later delete |
1 | 1810 |
} |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
1811 |
release_set_methods_jmethod_ids(jmeths = new_jmeths); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1812 |
} else { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1813 |
// fetch jmethodID (if any) from the existing cache |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1814 |
id = jmeths[idnum+1]; |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1815 |
*to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1816 |
} |
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1817 |
if (id == NULL) { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1818 |
// No matching jmethodID in the existing cache or we have a new |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1819 |
// cache or we just grew the cache. This cache write is done here |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1820 |
// by the first thread to win the foot race because a jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1821 |
// needs to be unique once it is generally available. |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1822 |
id = new_id; |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1823 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1824 |
// The jmethodID cache can be read while unlocked so we have to |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1825 |
// make sure the new jmethodID is complete before installing it |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1826 |
// in the cache. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1827 |
OrderAccess::release_store_ptr(&jmeths[idnum+1], id); |
222
3d1795325749
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
220
diff
changeset
|
1828 |
} else { |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1829 |
*to_dealloc_id_p = new_id; // save new id for later delete |
1 | 1830 |
} |
1831 |
return id; |
|
1832 |
} |
|
1833 |
||
1834 |
||
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1835 |
// Common code to get the jmethodID cache length and the jmethodID |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1836 |
// value at index idnum if there is one. |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1837 |
// |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1838 |
void InstanceKlass::get_jmethod_id_length_value(jmethodID* cache, |
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1839 |
size_t idnum, size_t *length_p, jmethodID* id_p) { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1840 |
assert(cache != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1841 |
assert(length_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1842 |
assert(id_p != NULL, "sanity check"); |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1843 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1844 |
// cache size is stored in element[0], other elements offset by one |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1845 |
*length_p = (size_t)cache[0]; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1846 |
if (*length_p <= idnum) { // cache is too short |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1847 |
*id_p = NULL; |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1848 |
} else { |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1849 |
*id_p = cache[idnum+1]; // fetch jmethodID (if any) |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1850 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1851 |
} |
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1852 |
|
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1853 |
|
1 | 1854 |
// Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1855 |
jmethodID InstanceKlass::jmethod_id_or_null(Method* method) { |
1 | 1856 |
size_t idnum = (size_t)method->method_idnum(); |
1857 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
|
1858 |
size_t length; // length assigned as debugging crumb |
|
1859 |
jmethodID id = NULL; |
|
3824
86e9e4b25bdf
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
3821
diff
changeset
|
1860 |
if (jmeths != NULL && // If there is a cache |
1 | 1861 |
(length = (size_t)jmeths[0]) > idnum) { // and if it is long enough, |
1862 |
id = jmeths[idnum+1]; // Look up the id (may be NULL) |
|
1863 |
} |
|
1864 |
return id; |
|
1865 |
} |
|
1866 |
||
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1867 |
inline DependencyContext InstanceKlass::dependencies() { |
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1868 |
DependencyContext dep_context(&_dep_context); |
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1869 |
return dep_context; |
31037
01a5c5fa5681
8079205: CallSite dependency tracking is broken after sun.misc.Cleaner became automatically cleared
vlivanov
parents:
30227
diff
changeset
|
1870 |
} |
01a5c5fa5681
8079205: CallSite dependency tracking is broken after sun.misc.Cleaner became automatically cleared
vlivanov
parents:
30227
diff
changeset
|
1871 |
|
36300
5b47f168b948
7177745: JSR292: Many Callsite relinkages cause target method to always run in interpreter mode
vlivanov
parents:
35917
diff
changeset
|
1872 |
int InstanceKlass::mark_dependent_nmethods(KlassDepChange& changes) { |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1873 |
return dependencies().mark_dependent_nmethods(changes); |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1874 |
} |
1 | 1875 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1876 |
void InstanceKlass::add_dependent_nmethod(nmethod* nm) { |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1877 |
dependencies().add_dependent_nmethod(nm); |
1 | 1878 |
} |
1879 |
||
33576
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1880 |
void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) { |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1881 |
dependencies().remove_dependent_nmethod(nm, delete_immediately); |
1 | 1882 |
} |
1883 |
||
1884 |
#ifndef PRODUCT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1885 |
void InstanceKlass::print_dependent_nmethods(bool verbose) { |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1886 |
dependencies().print_dependent_nmethods(verbose); |
1 | 1887 |
} |
1888 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1889 |
bool InstanceKlass::is_dependent_nmethod(nmethod* nm) { |
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1890 |
return dependencies().is_dependent_nmethod(nm); |
1 | 1891 |
} |
1892 |
#endif //PRODUCT |
|
1893 |
||
33576
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1894 |
void InstanceKlass::clean_weak_instanceklass_links(BoolObjectClosure* is_alive) { |
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1895 |
clean_implementors_list(is_alive); |
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1896 |
clean_method_data(is_alive); |
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1897 |
|
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1898 |
// Since GC iterates InstanceKlasses sequentially, it is safe to remove stale entries here. |
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1899 |
DependencyContext dep_context(&_dep_context); |
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
1900 |
dep_context.expunge_stale_entries(); |
33576
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1901 |
} |
6dbde58b08a6
8058563: InstanceKlass::_dependencies list isn't cleared from empty nmethodBucket entries
stefank
parents:
33151
diff
changeset
|
1902 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1903 |
void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) { |
25492
d27050bdfb04
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
25491
diff
changeset
|
1904 |
assert(class_loader_data()->is_alive(is_alive), "this klass should be live"); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1905 |
if (is_interface()) { |
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1906 |
if (ClassUnloading) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1907 |
Klass* impl = implementor(); |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1908 |
if (impl != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1909 |
if (!impl->is_loader_alive(is_alive)) { |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1910 |
// remove this guy |
15873
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1911 |
Klass** klass = adr_implementor(); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1912 |
assert(klass != NULL, "null klass"); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1913 |
if (klass != NULL) { |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1914 |
*klass = NULL; |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
1915 |
} |
12369
48fd3da4025c
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
12233
diff
changeset
|
1916 |
} |
1 | 1917 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1918 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1919 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1920 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1921 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1922 |
void InstanceKlass::clean_method_data(BoolObjectClosure* is_alive) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1923 |
for (int m = 0; m < methods()->length(); m++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1924 |
MethodData* mdo = methods()->at(m)->method_data(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1925 |
if (mdo != NULL) { |
22916
582da2ed4dfa
8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents:
22881
diff
changeset
|
1926 |
mdo->clean_method_data(is_alive); |
1 | 1927 |
} |
1928 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1929 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1930 |
|
42650 | 1931 |
bool InstanceKlass::supers_have_passed_fingerprint_checks() { |
1932 |
if (java_super() != NULL && !java_super()->has_passed_fingerprint_check()) { |
|
1933 |
ResourceMark rm; |
|
1934 |
log_trace(class, fingerprint)("%s : super %s not fingerprinted", external_name(), java_super()->external_name()); |
|
1935 |
return false; |
|
1936 |
} |
|
1937 |
||
1938 |
Array<Klass*>* local_interfaces = this->local_interfaces(); |
|
1939 |
if (local_interfaces != NULL) { |
|
1940 |
int length = local_interfaces->length(); |
|
1941 |
for (int i = 0; i < length; i++) { |
|
1942 |
InstanceKlass* intf = InstanceKlass::cast(local_interfaces->at(i)); |
|
1943 |
if (!intf->has_passed_fingerprint_check()) { |
|
1944 |
ResourceMark rm; |
|
1945 |
log_trace(class, fingerprint)("%s : interface %s not fingerprinted", external_name(), intf->external_name()); |
|
1946 |
return false; |
|
1947 |
} |
|
1948 |
} |
|
1949 |
} |
|
1950 |
||
1951 |
return true; |
|
1952 |
} |
|
1953 |
||
1954 |
bool InstanceKlass::should_store_fingerprint() { |
|
1955 |
#if INCLUDE_AOT |
|
1956 |
// We store the fingerprint into the InstanceKlass only in the following 2 cases: |
|
1957 |
if (EnableJVMCI && !UseJVMCICompiler) { |
|
1958 |
// (1) We are running AOT to generate a shared library. |
|
1959 |
return true; |
|
1960 |
} |
|
1961 |
if (DumpSharedSpaces) { |
|
1962 |
// (2) We are running -Xshare:dump to create a shared archive |
|
1963 |
return true; |
|
1964 |
} |
|
1965 |
#endif |
|
1966 |
||
1967 |
// In all other cases we might set the _misc_has_passed_fingerprint_check bit, |
|
1968 |
// but do not store the 64-bit fingerprint to save space. |
|
1969 |
return false; |
|
1970 |
} |
|
1971 |
||
1972 |
bool InstanceKlass::has_stored_fingerprint() const { |
|
1973 |
#if INCLUDE_AOT |
|
1974 |
return should_store_fingerprint() || is_shared(); |
|
1975 |
#else |
|
1976 |
return false; |
|
1977 |
#endif |
|
1978 |
} |
|
1979 |
||
1980 |
uint64_t InstanceKlass::get_stored_fingerprint() const { |
|
1981 |
address adr = adr_fingerprint(); |
|
1982 |
if (adr != NULL) { |
|
1983 |
return (uint64_t)Bytes::get_native_u8(adr); // adr may not be 64-bit aligned |
|
1984 |
} |
|
1985 |
return 0; |
|
1986 |
} |
|
1987 |
||
1988 |
void InstanceKlass::store_fingerprint(uint64_t fingerprint) { |
|
1989 |
address adr = adr_fingerprint(); |
|
1990 |
if (adr != NULL) { |
|
1991 |
Bytes::put_native_u8(adr, (u8)fingerprint); // adr may not be 64-bit aligned |
|
1992 |
||
1993 |
ResourceMark rm; |
|
1994 |
log_trace(class, fingerprint)("stored as " PTR64_FORMAT " for class %s", fingerprint, external_name()); |
|
1995 |
} |
|
1996 |
} |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1997 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1998 |
static void remove_unshareable_in_class(Klass* k) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
1999 |
// remove klass's unshareable info |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2000 |
k->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2001 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2002 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2003 |
void InstanceKlass::remove_unshareable_info() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2004 |
Klass::remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2005 |
// Unlink the class |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2006 |
if (is_linked()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2007 |
unlink_class(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2008 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2009 |
init_implementor(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2010 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2011 |
constants()->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2012 |
|
34195
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
2013 |
assert(_dep_context == DependencyContext::EMPTY, "dependency context is not shareable"); |
89011d12ebd3
8139595: MethodHandles::remove_dependent_nmethod is not MT safe
vlivanov
parents:
33638
diff
changeset
|
2014 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2015 |
for (int i = 0; i < methods()->length(); i++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2016 |
Method* m = methods()->at(i); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2017 |
m->remove_unshareable_info(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2018 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2019 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2020 |
// do array classes also. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2021 |
array_klasses_do(remove_unshareable_in_class); |
1 | 2022 |
} |
2023 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2024 |
static void restore_unshareable_in_class(Klass* k, TRAPS) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2025 |
// Array classes have null protection domain. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2026 |
// --> see ArrayKlass::complete_create_array_klass() |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2027 |
k->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK); |
1 | 2028 |
} |
2029 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2030 |
void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) { |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2031 |
set_package(loader_data, CHECK); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2032 |
Klass::restore_unshareable_info(loader_data, protection_domain, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2033 |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2034 |
Array<Method*>* methods = this->methods(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2035 |
int num_methods = methods->length(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2036 |
for (int index2 = 0; index2 < num_methods; ++index2) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2037 |
methodHandle m(THREAD, methods->at(index2)); |
23872
536c66fc43d3
8028497: SIGSEGV at ClassLoaderData::oops_do(OopClosure*, KlassClosure*, bool)
coleenp
parents:
23515
diff
changeset
|
2038 |
m->restore_unshareable_info(CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2039 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2040 |
if (JvmtiExport::has_redefined_a_class()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2041 |
// Reinitialize vtable because RedefineClasses may have changed some |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2042 |
// entries in this vtable for super classes so the CDS vtable might |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2043 |
// point to old or obsolete entries. RedefineClasses doesn't fix up |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2044 |
// vtables in the shared system dictionary, only the main one. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2045 |
// It also redefines the itable too so fix that too. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2046 |
ResourceMark rm(THREAD); |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
2047 |
vtable().initialize_vtable(false, CHECK); |
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
2048 |
itable().initialize_itable(false, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2049 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2050 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2051 |
// restore constant pool resolved references |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2052 |
constants()->restore_unshareable_info(CHECK); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2053 |
|
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2054 |
array_klasses_do(restore_unshareable_in_class, CHECK); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2055 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2056 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2057 |
// returns true IFF is_in_error_state() has been changed as a result of this call. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2058 |
bool InstanceKlass::check_sharing_error_state() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2059 |
assert(DumpSharedSpaces, "should only be called during dumping"); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2060 |
bool old_state = is_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2061 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2062 |
if (!is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2063 |
bool bad = false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2064 |
for (InstanceKlass* sup = java_super(); sup; sup = sup->java_super()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2065 |
if (sup->is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2066 |
bad = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2067 |
break; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2068 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2069 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2070 |
if (!bad) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2071 |
Array<Klass*>* interfaces = transitive_interfaces(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2072 |
for (int i = 0; i < interfaces->length(); i++) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2073 |
Klass* iface = interfaces->at(i); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2074 |
if (InstanceKlass::cast(iface)->is_in_error_state()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2075 |
bad = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2076 |
break; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2077 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2078 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2079 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2080 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2081 |
if (bad) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2082 |
set_in_error_state(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2083 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2084 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2085 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2086 |
return (old_state != is_in_error_state()); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2087 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25500
diff
changeset
|
2088 |
|
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
2089 |
#if INCLUDE_JVMTI |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2090 |
static void clear_all_breakpoints(Method* m) { |
1 | 2091 |
m->clear_all_breakpoints(); |
2092 |
} |
|
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
2093 |
#endif |
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2094 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2095 |
void InstanceKlass::notify_unload_class(InstanceKlass* ik) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2096 |
// notify the debugger |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2097 |
if (JvmtiExport::should_post_class_unload()) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2098 |
JvmtiExport::post_class_unload(ik); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2099 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2100 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2101 |
// notify ClassLoadingService of class unload |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2102 |
ClassLoadingService::notify_class_unloaded(ik); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2103 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2104 |
|
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2105 |
void InstanceKlass::release_C_heap_structures(InstanceKlass* ik) { |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2106 |
// Clean up C heap |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2107 |
ik->release_C_heap_structures(); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2108 |
ik->constants()->release_C_heap_structures(); |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2109 |
} |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2110 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2111 |
void InstanceKlass::release_C_heap_structures() { |
17075
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2112 |
// Can't release the constant pool here because the constant pool can be |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2113 |
// deallocated separately from the InstanceKlass for default methods and |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2114 |
// redefine classes. |
b53332c50aba
8011803: release_C_heap_structures is never called for anonymous classes.
coleenp
parents:
17029
diff
changeset
|
2115 |
|
1 | 2116 |
// Deallocate oop map cache |
2117 |
if (_oop_map_cache != NULL) { |
|
2118 |
delete _oop_map_cache; |
|
2119 |
_oop_map_cache = NULL; |
|
2120 |
} |
|
2121 |
||
2122 |
// Deallocate JNI identifiers for jfieldIDs |
|
2123 |
JNIid::deallocate(jni_ids()); |
|
2124 |
set_jni_ids(NULL); |
|
2125 |
||
2126 |
jmethodID* jmeths = methods_jmethod_ids_acquire(); |
|
2127 |
if (jmeths != (jmethodID*)NULL) { |
|
2128 |
release_set_methods_jmethod_ids(NULL); |
|
2129 |
FreeHeap(jmeths); |
|
2130 |
} |
|
2131 |
||
17830
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2132 |
// Deallocate MemberNameTable |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2133 |
{ |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2134 |
Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock; |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2135 |
MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2136 |
MemberNameTable* mnt = member_names(); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2137 |
if (mnt != NULL) { |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2138 |
delete mnt; |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2139 |
set_member_names(NULL); |
6bb6155c908a
8013945: CMS fatal error: must own lock MemberNameTable_lock
sspitsyn
parents:
17828
diff
changeset
|
2140 |
} |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2141 |
} |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2142 |
|
34221
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2143 |
// Release dependencies. |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2144 |
// It is desirable to use DC::remove_all_dependents() here, but, unfortunately, |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2145 |
// it is not safe (see JDK-8143408). The problem is that the klass dependency |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2146 |
// context can contain live dependencies, since there's a race between nmethod & |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2147 |
// klass unloading. If the klass is dead when nmethod unloading happens, relevant |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2148 |
// dependencies aren't removed from the context associated with the class (see |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2149 |
// nmethod::flush_dependencies). It ends up during klass unloading as seemingly |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2150 |
// live dependencies pointing to unloaded nmethods and causes a crash in |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2151 |
// DC::remove_all_dependents() when it touches unloaded nmethod. |
3c271ee8fb98
8143408: Crash during InstanceKlass unloading when clearing dependency context
vlivanov
parents:
34195
diff
changeset
|
2152 |
dependencies().wipe(); |
1 | 2153 |
|
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
2154 |
#if INCLUDE_JVMTI |
1 | 2155 |
// Deallocate breakpoint records |
2156 |
if (breakpoints() != 0x0) { |
|
2157 |
methods_do(clear_all_breakpoints); |
|
2158 |
assert(breakpoints() == 0x0, "should have cleared breakpoints"); |
|
2159 |
} |
|
2160 |
||
2161 |
// deallocate the cached class file |
|
43430
a815cfd97cd1
8170959: unloading archived shared class caused crash
iklam
parents:
42650
diff
changeset
|
2162 |
if (_cached_class_file != NULL && !MetaspaceShared::is_in_shared_space(_cached_class_file)) { |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
2163 |
os::free(_cached_class_file); |
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
2164 |
_cached_class_file = NULL; |
1 | 2165 |
} |
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
2166 |
#endif |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2167 |
|
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2168 |
// Decrement symbol reference counts associated with the unloaded class. |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2169 |
if (_name != NULL) _name->decrement_refcount(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2170 |
// unreference array name derived from this class name (arrays of an unloaded |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2171 |
// class can't be referenced anymore). |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2172 |
if (_array_name != NULL) _array_name->decrement_refcount(); |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27674
diff
changeset
|
2173 |
if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension); |
15104
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2174 |
|
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2175 |
assert(_total_instanceKlass_count >= 1, "Sanity check"); |
f5d78994619f
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
14583
diff
changeset
|
2176 |
Atomic::dec(&_total_instanceKlass_count); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2177 |
} |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2178 |
|
34666 | 2179 |
void InstanceKlass::set_source_debug_extension(const char* array, int length) { |
13201
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2180 |
if (array == NULL) { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2181 |
_source_debug_extension = NULL; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2182 |
} else { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2183 |
// Adding one to the attribute length in order to store a null terminator |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2184 |
// character could cause an overflow because the attribute length is |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2185 |
// already coded with an u4 in the classfile, but in practice, it's |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2186 |
// unlikely to happen. |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2187 |
assert((length+1) > length, "Overflow checking"); |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2188 |
char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass); |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2189 |
for (int i = 0; i < length; i++) { |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2190 |
sde[i] = array[i]; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2191 |
} |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2192 |
sde[length] = '\0'; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2193 |
_source_debug_extension = sde; |
69f157caabcc
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
13195
diff
changeset
|
2194 |
} |
1 | 2195 |
} |
2196 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2197 |
address InstanceKlass::static_field_addr(int offset) { |
20282
7f9cbdf89af2
7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents:
20065
diff
changeset
|
2198 |
return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + cast_from_oop<intptr_t>(java_mirror())); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2199 |
} |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2200 |
|
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2201 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2202 |
const char* InstanceKlass::signature_name() const { |
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2203 |
int hash_len = 0; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2204 |
char hash_buf[40]; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2205 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2206 |
// If this is an anonymous class, append a hash to make the name unique |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2207 |
if (is_anonymous()) { |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2208 |
intptr_t hash = (java_mirror() != NULL) ? java_mirror()->identity_hash() : 0; |
27471 | 2209 |
jio_snprintf(hash_buf, sizeof(hash_buf), "/" UINTX_FORMAT, (uintx)hash); |
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2210 |
hash_len = (int)strlen(hash_buf); |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2211 |
} |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2212 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2213 |
// Get the internal name as a c string |
1 | 2214 |
const char* src = (const char*) (name()->as_C_string()); |
2215 |
const int src_length = (int)strlen(src); |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2216 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2217 |
char* dest = NEW_RESOURCE_ARRAY(char, src_length + hash_len + 3); |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2218 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2219 |
// Add L as type indicator |
1 | 2220 |
int dest_index = 0; |
2221 |
dest[dest_index++] = 'L'; |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2222 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2223 |
// Add the actual class name |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2224 |
for (int src_index = 0; src_index < src_length; ) { |
1 | 2225 |
dest[dest_index++] = src[src_index++]; |
2226 |
} |
|
21183
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2227 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2228 |
// If we have a hash, append it |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2229 |
for (int hash_index = 0; hash_index < hash_len; ) { |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2230 |
dest[dest_index++] = hash_buf[hash_index++]; |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2231 |
} |
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2232 |
|
e148e499e5cd
8024423: JVMTI: GetLoadedClasses doesn't enumerate anonymous classes
farvidsson
parents:
21079
diff
changeset
|
2233 |
// Add the semicolon and the NULL |
1 | 2234 |
dest[dest_index++] = ';'; |
2235 |
dest[dest_index] = '\0'; |
|
2236 |
return dest; |
|
2237 |
} |
|
2238 |
||
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2239 |
// Used to obtain the package name from a fully qualified class name. |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2240 |
Symbol* InstanceKlass::package_from_name(const Symbol* name, TRAPS) { |
36508 | 2241 |
if (name == NULL) { |
2242 |
return NULL; |
|
2243 |
} else { |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2244 |
if (name->utf8_length() <= 0) { |
36508 | 2245 |
return NULL; |
2246 |
} |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2247 |
ResourceMark rm; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2248 |
const char* package_name = ClassLoader::package_from_name((const char*) name->as_C_string()); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2249 |
if (package_name == NULL) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2250 |
return NULL; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2251 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2252 |
Symbol* pkg_name = SymbolTable::new_symbol(package_name, THREAD); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2253 |
return pkg_name; |
36508 | 2254 |
} |
2255 |
} |
|
2256 |
||
2257 |
ModuleEntry* InstanceKlass::module() const { |
|
2258 |
if (!in_unnamed_package()) { |
|
2259 |
return _package_entry->module(); |
|
2260 |
} |
|
2261 |
const Klass* host = host_klass(); |
|
2262 |
if (host == NULL) { |
|
46387 | 2263 |
return class_loader_data()->unnamed_module(); |
36508 | 2264 |
} |
46387 | 2265 |
return host->class_loader_data()->unnamed_module(); |
36508 | 2266 |
} |
2267 |
||
2268 |
void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) { |
|
40016 | 2269 |
|
2270 |
// ensure java/ packages only loaded by boot or platform builtin loaders |
|
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
2271 |
Handle class_loader(THREAD, loader_data->class_loader()); |
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
2272 |
check_prohibited_package(name(), class_loader, CHECK); |
40016 | 2273 |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2274 |
TempNewSymbol pkg_name = package_from_name(name(), CHECK); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2275 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2276 |
if (pkg_name != NULL && loader_data != NULL) { |
40016 | 2277 |
|
36508 | 2278 |
// Find in class loader's package entry table. |
2279 |
_package_entry = loader_data->packages()->lookup_only(pkg_name); |
|
2280 |
||
2281 |
// If the package name is not found in the loader's package |
|
2282 |
// entry table, it is an indication that the package has not |
|
2283 |
// been defined. Consider it defined within the unnamed module. |
|
2284 |
if (_package_entry == NULL) { |
|
2285 |
ResourceMark rm; |
|
2286 |
||
2287 |
if (!ModuleEntryTable::javabase_defined()) { |
|
2288 |
// Before java.base is defined during bootstrapping, define all packages in |
|
2289 |
// the java.base module. If a non-java.base package is erroneously placed |
|
2290 |
// in the java.base module it will be caught later when java.base |
|
2291 |
// is defined by ModuleEntryTable::verify_javabase_packages check. |
|
42636
aafc434ba580
8169734: Update uses of string "java.base" to macro
rprotacio
parents:
42031
diff
changeset
|
2292 |
assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL"); |
41183
207b92e69457
8163406: The fixup_module_list must be protected by Module_lock when inserting new entries
lfoltan
parents:
41182
diff
changeset
|
2293 |
_package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry()); |
36508 | 2294 |
} else { |
46387 | 2295 |
assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL"); |
36508 | 2296 |
_package_entry = loader_data->packages()->lookup(pkg_name, |
46387 | 2297 |
loader_data->unnamed_module()); |
36508 | 2298 |
} |
2299 |
||
2300 |
// A package should have been successfully created |
|
2301 |
assert(_package_entry != NULL, "Package entry for class %s not found, loader %s", |
|
2302 |
name()->as_C_string(), loader_data->loader_name()); |
|
2303 |
} |
|
2304 |
||
44993
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2305 |
if (log_is_enabled(Debug, module)) { |
36508 | 2306 |
ResourceMark rm; |
2307 |
ModuleEntry* m = _package_entry->module(); |
|
44993
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2308 |
log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s", |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2309 |
external_name(), |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2310 |
pkg_name->as_C_string(), |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2311 |
loader_data->loader_name(), |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2312 |
(m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE)); |
36508 | 2313 |
} |
2314 |
} else { |
|
2315 |
ResourceMark rm; |
|
44993
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2316 |
log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s", |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2317 |
external_name(), |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2318 |
(loader_data != NULL) ? loader_data->loader_name() : "NULL", |
f61bcd80ec1f
8178380: Module system implementation refresh (5/2017)
alanb
parents:
44326
diff
changeset
|
2319 |
UNNAMED_MODULE); |
36508 | 2320 |
} |
2321 |
} |
|
2322 |
||
2323 |
||
2324 |
// different versions of is_same_class_package |
|
2325 |
||
34666 | 2326 |
bool InstanceKlass::is_same_class_package(const Klass* class2) const { |
36508 | 2327 |
oop classloader1 = this->class_loader(); |
2328 |
PackageEntry* classpkg1 = this->package(); |
|
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2329 |
if (class2->is_objArray_klass()) { |
13952
e3cf184080bc
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
13738
diff
changeset
|
2330 |
class2 = ObjArrayKlass::cast(class2)->bottom_klass(); |
1 | 2331 |
} |
36508 | 2332 |
|
34666 | 2333 |
oop classloader2; |
36508 | 2334 |
PackageEntry* classpkg2; |
34666 | 2335 |
if (class2->is_instance_klass()) { |
36508 | 2336 |
classloader2 = class2->class_loader(); |
38094
46977cd73d86
8152844: JVM InstanceKlass Methods For Obtaining Package/Module Should Be Moved to Klass
rprotacio
parents:
38059
diff
changeset
|
2337 |
classpkg2 = class2->package(); |
34666 | 2338 |
} else { |
2339 |
assert(class2->is_typeArray_klass(), "should be type array"); |
|
2340 |
classloader2 = NULL; |
|
36508 | 2341 |
classpkg2 = NULL; |
34666 | 2342 |
} |
36508 | 2343 |
|
2344 |
// Same package is determined by comparing class loader |
|
2345 |
// and package entries. Both must be the same. This rule |
|
2346 |
// applies even to classes that are defined in the unnamed |
|
2347 |
// package, they still must have the same class loader. |
|
2348 |
if ((classloader1 == classloader2) && (classpkg1 == classpkg2)) { |
|
2349 |
return true; |
|
2350 |
} |
|
2351 |
||
2352 |
return false; |
|
1 | 2353 |
} |
2354 |
||
34666 | 2355 |
bool InstanceKlass::is_same_class_package(oop other_class_loader, |
2356 |
const Symbol* other_class_name) const { |
|
2357 |
oop this_class_loader = class_loader(); |
|
2358 |
const Symbol* const this_class_name = name(); |
|
2359 |
||
2360 |
return InstanceKlass::is_same_class_package(this_class_loader, |
|
2361 |
this_class_name, |
|
2362 |
other_class_loader, |
|
2363 |
other_class_name); |
|
1 | 2364 |
} |
2365 |
||
2366 |
// return true if two classes are in the same package, classloader |
|
2367 |
// and classname information is enough to determine a class's package |
|
34666 | 2368 |
bool InstanceKlass::is_same_class_package(oop class_loader1, const Symbol* class_name1, |
2369 |
oop class_loader2, const Symbol* class_name2) { |
|
1 | 2370 |
if (class_loader1 != class_loader2) { |
2371 |
return false; |
|
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2372 |
} else if (class_name1 == class_name2) { |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2373 |
return true; |
1 | 2374 |
} else { |
2375 |
ResourceMark rm; |
|
2376 |
||
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2377 |
bool bad_class_name = false; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2378 |
const char* name1 = ClassLoader::package_from_name((const char*) class_name1->as_C_string(), &bad_class_name); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2379 |
if (bad_class_name) { |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2380 |
return false; |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2381 |
} |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2382 |
|
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2383 |
const char* name2 = ClassLoader::package_from_name((const char*) class_name2->as_C_string(), &bad_class_name); |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2384 |
if (bad_class_name) { |
36508 | 2385 |
return false; |
2386 |
} |
|
2387 |
||
2388 |
if ((name1 == NULL) || (name2 == NULL)) { |
|
1 | 2389 |
// One of the two doesn't have a package. Only return true |
2390 |
// if the other one also doesn't have a package. |
|
36508 | 2391 |
return name1 == name2; |
1 | 2392 |
} |
36508 | 2393 |
|
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2394 |
// Check that package is identical |
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2395 |
return (strcmp(name1, name2) == 0); |
1 | 2396 |
} |
2397 |
} |
|
2398 |
||
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2399 |
// Returns true iff super_method can be overridden by a method in targetclassname |
39216
40c3d66352ae
8153858: Clean up needed when obtaining the package name from a fully qualified class name
rprotacio
parents:
38937
diff
changeset
|
2400 |
// See JLS 3rd edition 8.4.6.1 |
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2401 |
// Assumes name-signature match |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2402 |
// "this" is InstanceKlass of super_method which must exist |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2403 |
// note that the InstanceKlass of the method in the targetclassname has not always been created yet |
33593
60764a78fa5c
8140274: methodHandles and constantPoolHandles should be passed as const references
coleenp
parents:
33576
diff
changeset
|
2404 |
bool InstanceKlass::is_override(const methodHandle& super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) { |
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2405 |
// Private methods can not be overridden |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2406 |
if (super_method->is_private()) { |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2407 |
return false; |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2408 |
} |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2409 |
// If super method is accessible, then override |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2410 |
if ((super_method->is_protected()) || |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2411 |
(super_method->is_public())) { |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2412 |
return true; |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2413 |
} |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2414 |
// Package-private methods are not inherited outside of package |
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2415 |
assert(super_method->is_package_private(), "must be package private"); |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
2416 |
return(is_same_class_package(targetclassloader(), targetclassname)); |
2264
55d0115a54fe
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
2131
diff
changeset
|
2417 |
} |
1 | 2418 |
|
40016 | 2419 |
// Only boot and platform class loaders can define classes in "java/" packages. |
2420 |
void InstanceKlass::check_prohibited_package(Symbol* class_name, |
|
42307
cefc81dc1d52
8169069: Module system implementation refresh (11/2016)
alanb
parents:
42031
diff
changeset
|
2421 |
Handle class_loader, |
cefc81dc1d52
8169069: Module system implementation refresh (11/2016)
alanb
parents:
42031
diff
changeset
|
2422 |
TRAPS) { |
40016 | 2423 |
if (!class_loader.is_null() && |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
2424 |
!SystemDictionary::is_platform_class_loader(class_loader()) && |
44326
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2425 |
class_name != NULL) { |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2426 |
ResourceMark rm(THREAD); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2427 |
char* name = class_name->as_C_string(); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2428 |
if (strncmp(name, JAVAPKG, JAVAPKG_LEN) == 0 && name[JAVAPKG_LEN] == '/') { |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2429 |
TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2430 |
assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'"); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2431 |
name = pkg_name->as_C_string(); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2432 |
const char* class_loader_name = SystemDictionary::loader_name(class_loader()); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2433 |
StringUtils::replace_no_expand(name, "/", "."); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2434 |
const char* msg_text1 = "Class loader (instance of): "; |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2435 |
const char* msg_text2 = " tried to load prohibited package name: "; |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2436 |
size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1; |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2437 |
char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2438 |
jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2439 |
THROW_MSG(vmSymbols::java_lang_SecurityException(), message); |
6c59cca7ff07
8174823: Module system implementation refresh (3/2017)
alanb
parents:
43929
diff
changeset
|
2440 |
} |
40016 | 2441 |
} |
2442 |
return; |
|
2443 |
} |
|
2444 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2445 |
// tell if two classes have the same enclosing class (at package level) |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2446 |
bool InstanceKlass::is_same_package_member(const Klass* class2, TRAPS) const { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2447 |
if (class2 == this) return true; |
34666 | 2448 |
if (!class2->is_instance_klass()) return false; |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2449 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2450 |
// must be in same package before we try anything else |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2451 |
if (!is_same_class_package(class2)) |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2452 |
return false; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2453 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2454 |
// As long as there is an outer_this.getEnclosingClass, |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2455 |
// shift the search outward. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2456 |
const InstanceKlass* outer_this = this; |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2457 |
for (;;) { |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2458 |
// As we walk along, look for equalities between outer_this and class2. |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2459 |
// Eventually, the walks will terminate as outer_this stops |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2460 |
// at the top-level class around the original class. |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2461 |
bool ignore_inner_is_member; |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2462 |
const Klass* next = outer_this->compute_enclosing_class(&ignore_inner_is_member, |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2463 |
CHECK_false); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2464 |
if (next == NULL) break; |
34666 | 2465 |
if (next == class2) return true; |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2466 |
outer_this = InstanceKlass::cast(next); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2467 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2468 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2469 |
// Now do the same for class2. |
34666 | 2470 |
const InstanceKlass* outer2 = InstanceKlass::cast(class2); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2471 |
for (;;) { |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2472 |
bool ignore_inner_is_member; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2473 |
Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member, |
4496
c5a0b15a8e7d
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
4094
diff
changeset
|
2474 |
CHECK_false); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2475 |
if (next == NULL) break; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2476 |
// Might as well check the new outer against all available values. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2477 |
if (next == this) return true; |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2478 |
if (next == outer_this) return true; |
34666 | 2479 |
outer2 = InstanceKlass::cast(next); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2480 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2481 |
|
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2482 |
// If by this point we have not found an equality between the |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2483 |
// two classes, we know they are in separate package members. |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2484 |
return false; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2485 |
} |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2486 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2487 |
bool InstanceKlass::find_inner_classes_attr(int* ooff, int* noff, TRAPS) const { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2488 |
constantPoolHandle i_cp(THREAD, constants()); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2489 |
for (InnerClassesIterator iter(this); !iter.done(); iter.next()) { |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2490 |
int ioff = iter.inner_class_info_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2491 |
if (ioff != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2492 |
// Check to see if the name matches the class we're looking for |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2493 |
// before attempting to find the class. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2494 |
if (i_cp->klass_name_at_matches(this, ioff)) { |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2495 |
Klass* inner_klass = i_cp->klass_at(ioff, CHECK_false); |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2496 |
if (this == inner_klass) { |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2497 |
*ooff = iter.outer_class_info_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2498 |
*noff = iter.inner_name_index(); |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2499 |
return true; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2500 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2501 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2502 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2503 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2504 |
return false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2505 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2506 |
|
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2507 |
InstanceKlass* InstanceKlass::compute_enclosing_class(bool* inner_is_member, TRAPS) const { |
34666 | 2508 |
InstanceKlass* outer_klass = NULL; |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2509 |
*inner_is_member = false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2510 |
int ooff = 0, noff = 0; |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2511 |
bool has_inner_classes_attr = find_inner_classes_attr(&ooff, &noff, THREAD); |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2512 |
if (has_inner_classes_attr) { |
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2513 |
constantPoolHandle i_cp(THREAD, constants()); |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2514 |
if (ooff != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2515 |
Klass* ok = i_cp->klass_at(ooff, CHECK_NULL); |
34666 | 2516 |
outer_klass = InstanceKlass::cast(ok); |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2517 |
*inner_is_member = true; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2518 |
} |
34666 | 2519 |
if (NULL == outer_klass) { |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2520 |
// It may be anonymous; try for that. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2521 |
int encl_method_class_idx = enclosing_method_class_index(); |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2522 |
if (encl_method_class_idx != 0) { |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2523 |
Klass* ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL); |
34666 | 2524 |
outer_klass = InstanceKlass::cast(ok); |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2525 |
*inner_is_member = false; |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2526 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2527 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2528 |
} |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2529 |
|
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2530 |
// If no inner class attribute found for this class. |
34666 | 2531 |
if (NULL == outer_klass) return NULL; |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2532 |
|
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2533 |
// Throws an exception if outer klass has not declared k as an inner klass |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2534 |
// We need evidence that each klass knows about the other, or else |
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2535 |
// the system could allow a spoof of an inner class to gain access rights. |
46341
4c676683bdb9
8176705: Remove static functions in InstanceKlass
hseigel
parents:
46329
diff
changeset
|
2536 |
Reflection::check_for_inner_class(outer_klass, this, *inner_is_member, CHECK_NULL); |
34666 | 2537 |
return outer_klass; |
30222
bfe6be3c4ef8
8057919: Class.getSimpleName() should work for non-JLS compliant class names
vlivanov
parents:
29792
diff
changeset
|
2538 |
} |
1 | 2539 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2540 |
jint InstanceKlass::compute_modifier_flags(TRAPS) const { |
1 | 2541 |
jint access = access_flags().as_int(); |
2542 |
||
2543 |
// But check if it happens to be member class. |
|
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2544 |
InnerClassesIterator iter(this); |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2545 |
for (; !iter.done(); iter.next()) { |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2546 |
int ioff = iter.inner_class_info_index(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2547 |
// Inner class attribute can be zero, skip it. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2548 |
// Strange but true: JVM spec. allows null inner class refs. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2549 |
if (ioff == 0) continue; |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2550 |
|
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2551 |
// only look at classes that are already loaded |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2552 |
// since we are looking for the flags for our self. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2553 |
Symbol* inner_name = constants()->klass_name_at(ioff); |
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
2554 |
if (name() == inner_name) { |
12231
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2555 |
// This is really a member class. |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2556 |
access = iter.inner_access_flags(); |
6a9cfc59a18a
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
11407
diff
changeset
|
2557 |
break; |
1 | 2558 |
} |
2559 |
} |
|
2560 |
// Remember to strip ACC_SUPER bit |
|
2561 |
return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS; |
|
2562 |
} |
|
2563 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2564 |
jint InstanceKlass::jvmti_class_status() const { |
1 | 2565 |
jint result = 0; |
2566 |
||
2567 |
if (is_linked()) { |
|
2568 |
result |= JVMTI_CLASS_STATUS_VERIFIED | JVMTI_CLASS_STATUS_PREPARED; |
|
2569 |
} |
|
2570 |
||
2571 |
if (is_initialized()) { |
|
2572 |
assert(is_linked(), "Class status is not consistent"); |
|
2573 |
result |= JVMTI_CLASS_STATUS_INITIALIZED; |
|
2574 |
} |
|
2575 |
if (is_in_error_state()) { |
|
2576 |
result |= JVMTI_CLASS_STATUS_ERROR; |
|
2577 |
} |
|
2578 |
return result; |
|
2579 |
} |
|
2580 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2581 |
Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) { |
1 | 2582 |
itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable(); |
2583 |
int method_table_offset_in_words = ioe->offset()/wordSize; |
|
2584 |
int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words()) |
|
2585 |
/ itableOffsetEntry::size(); |
|
2586 |
||
2587 |
for (int cnt = 0 ; ; cnt ++, ioe ++) { |
|
2131 | 2588 |
// If the interface isn't implemented by the receiver class, |
1 | 2589 |
// the VM should throw IncompatibleClassChangeError. |
2590 |
if (cnt >= nof_interfaces) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2591 |
THROW_NULL(vmSymbols::java_lang_IncompatibleClassChangeError()); |
1 | 2592 |
} |
2593 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2594 |
Klass* ik = ioe->interface_klass(); |
1 | 2595 |
if (ik == holder) break; |
2596 |
} |
|
2597 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2598 |
itableMethodEntry* ime = ioe->first_method_entry(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2599 |
Method* m = ime[index].method(); |
1 | 2600 |
if (m == NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2601 |
THROW_NULL(vmSymbols::java_lang_AbstractMethodError()); |
1 | 2602 |
} |
2603 |
return m; |
|
2604 |
} |
|
2605 |
||
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2606 |
|
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2607 |
#if INCLUDE_JVMTI |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2608 |
// update default_methods for redefineclasses for methods that are |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2609 |
// not yet in the vtable due to concurrent subclass define and superinterface |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2610 |
// redefinition |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2611 |
// Note: those in the vtable, should have been updated via adjust_method_entries |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2612 |
void InstanceKlass::adjust_default_methods(InstanceKlass* holder, bool* trace_name_printed) { |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2613 |
// search the default_methods for uses of either obsolete or EMCP methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2614 |
if (default_methods() != NULL) { |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2615 |
for (int index = 0; index < default_methods()->length(); index ++) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2616 |
Method* old_method = default_methods()->at(index); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2617 |
if (old_method == NULL || old_method->method_holder() != holder || !old_method->is_old()) { |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2618 |
continue; // skip uninteresting entries |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2619 |
} |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2620 |
assert(!old_method->is_deleted(), "default methods may not be deleted"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2621 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2622 |
Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum()); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2623 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2624 |
assert(new_method != NULL, "method_with_idnum() should not be NULL"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2625 |
assert(old_method != new_method, "sanity check"); |
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2626 |
|
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2627 |
default_methods()->at_put(index, new_method); |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2628 |
if (log_is_enabled(Info, redefine, class, update)) { |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2629 |
ResourceMark rm; |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2630 |
if (!(*trace_name_printed)) { |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2631 |
log_info(redefine, class, update) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2632 |
("adjust: klassname=%s default methods from name=%s", |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2633 |
external_name(), old_method->method_holder()->external_name()); |
29316
5287df8a8972
8046246: the constantPoolCacheOopDesc::adjust_method_entries() used in RedefineClasses does not scale
sspitsyn
parents:
28738
diff
changeset
|
2634 |
*trace_name_printed = true; |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2635 |
} |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2636 |
log_debug(redefine, class, update, vtables) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2637 |
("default method update: %s(%s) ", |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
2638 |
new_method->name()->as_C_string(), new_method->signature()->as_C_string()); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2639 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2640 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2641 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2642 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2643 |
#endif // INCLUDE_JVMTI |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2644 |
|
1 | 2645 |
// On-stack replacement stuff |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2646 |
void InstanceKlass::add_osr_nmethod(nmethod* n) { |
1 | 2647 |
// only one compilation can be active |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2648 |
{ |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2649 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2650 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2651 |
assert(n->is_osr_method(), "wrong kind of nmethod"); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2652 |
n->set_osr_link(osr_nmethods_head()); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2653 |
set_osr_nmethods_head(n); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2654 |
// Raise the highest osr level if necessary |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2655 |
if (TieredCompilation) { |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2656 |
Method* m = n->method(); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2657 |
m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level())); |
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2658 |
} |
6453 | 2659 |
} |
2660 |
||
2661 |
// Get rid of the osr methods for the same bci that have lower levels. |
|
2662 |
if (TieredCompilation) { |
|
2663 |
for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) { |
|
2664 |
nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true); |
|
2665 |
if (inv != NULL && inv->is_in_use()) { |
|
2666 |
inv->make_not_entrant(); |
|
2667 |
} |
|
2668 |
} |
|
2669 |
} |
|
1 | 2670 |
} |
2671 |
||
36802
18b1db5a7e70
8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents:
36300
diff
changeset
|
2672 |
// Remove osr nmethod from the list. Return true if found and removed. |
18b1db5a7e70
8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents:
36300
diff
changeset
|
2673 |
bool InstanceKlass::remove_osr_nmethod(nmethod* n) { |
1 | 2674 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2675 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
1 | 2676 |
assert(n->is_osr_method(), "wrong kind of nmethod"); |
2677 |
nmethod* last = NULL; |
|
2678 |
nmethod* cur = osr_nmethods_head(); |
|
6453 | 2679 |
int max_level = CompLevel_none; // Find the max comp level excluding n |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2680 |
Method* m = n->method(); |
1 | 2681 |
// Search for match |
36802
18b1db5a7e70
8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents:
36300
diff
changeset
|
2682 |
bool found = false; |
1 | 2683 |
while(cur != NULL && cur != n) { |
22920
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2684 |
if (TieredCompilation && m == cur->method()) { |
6453 | 2685 |
// Find max level before n |
2686 |
max_level = MAX2(max_level, cur->comp_level()); |
|
2687 |
} |
|
1 | 2688 |
last = cur; |
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2689 |
cur = cur->osr_link(); |
1 | 2690 |
} |
6453 | 2691 |
nmethod* next = NULL; |
1 | 2692 |
if (cur == n) { |
36802
18b1db5a7e70
8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents:
36300
diff
changeset
|
2693 |
found = true; |
6453 | 2694 |
next = cur->osr_link(); |
1 | 2695 |
if (last == NULL) { |
2696 |
// Remove first element |
|
6453 | 2697 |
set_osr_nmethods_head(next); |
1 | 2698 |
} else { |
6453 | 2699 |
last->set_osr_link(next); |
1 | 2700 |
} |
2701 |
} |
|
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2702 |
n->set_osr_link(NULL); |
6453 | 2703 |
if (TieredCompilation) { |
2704 |
cur = next; |
|
2705 |
while (cur != NULL) { |
|
2706 |
// Find max level after n |
|
22920
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2707 |
if (m == cur->method()) { |
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2708 |
max_level = MAX2(max_level, cur->comp_level()); |
dd3a135fca38
8034188: OSR methods may not be recompiled at proper compilation level
neliasso
parents:
22916
diff
changeset
|
2709 |
} |
6453 | 2710 |
cur = cur->osr_link(); |
2711 |
} |
|
2712 |
m->set_highest_osr_comp_level(max_level); |
|
2713 |
} |
|
36802
18b1db5a7e70
8023191: OSR nmethods should be flushed to free space in CodeCache
thartmann
parents:
36300
diff
changeset
|
2714 |
return found; |
1 | 2715 |
} |
2716 |
||
27434
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2717 |
int InstanceKlass::mark_osr_nmethods(const Method* m) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2718 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2719 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2720 |
nmethod* osr = osr_nmethods_head(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2721 |
int found = 0; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2722 |
while (osr != NULL) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2723 |
assert(osr->is_osr_method(), "wrong kind of nmethod found in chain"); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2724 |
if (osr->method() == m) { |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2725 |
osr->mark_for_deoptimization(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2726 |
found++; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2727 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2728 |
osr = osr->osr_link(); |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2729 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2730 |
return found; |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2731 |
} |
b4b185d05bb5
8061817: Whitebox.deoptimizeMethod() does not deoptimize all OSR versions of method
thartmann
parents:
27409
diff
changeset
|
2732 |
|
17370
59a0620561fa
8003557: NPG: Klass* const k should be const Klass* k.
minqi
parents:
17078
diff
changeset
|
2733 |
nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_level, bool match_level) const { |
1 | 2734 |
// This is a short non-blocking critical region, so the no safepoint check is ok. |
27409
03622fc45677
8059846: InstanceKlass should use MutexLockerEx to acquire OsrList_lock
thartmann
parents:
26558
diff
changeset
|
2735 |
MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag); |
1 | 2736 |
nmethod* osr = osr_nmethods_head(); |
6453 | 2737 |
nmethod* best = NULL; |
1 | 2738 |
while (osr != NULL) { |
2739 |
assert(osr->is_osr_method(), "wrong kind of nmethod found in chain"); |
|
6453 | 2740 |
// There can be a time when a c1 osr method exists but we are waiting |
2741 |
// for a c2 version. When c2 completes its osr nmethod we will trash |
|
2742 |
// the c1 version and only be able to find the c2 version. However |
|
2743 |
// while we overflow in the c1 code at back branches we don't want to |
|
2744 |
// try and switch to the same code as we are already running |
|
2745 |
||
1 | 2746 |
if (osr->method() == m && |
2747 |
(bci == InvocationEntryBci || osr->osr_entry_bci() == bci)) { |
|
6453 | 2748 |
if (match_level) { |
2749 |
if (osr->comp_level() == comp_level) { |
|
2750 |
// Found a match - return it. |
|
2751 |
return osr; |
|
2752 |
} |
|
2753 |
} else { |
|
2754 |
if (best == NULL || (osr->comp_level() > best->comp_level())) { |
|
2755 |
if (osr->comp_level() == CompLevel_highest_tier) { |
|
2756 |
// Found the best possible - return it. |
|
2757 |
return osr; |
|
2758 |
} |
|
2759 |
best = osr; |
|
2760 |
} |
|
2761 |
} |
|
1 | 2762 |
} |
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3576
diff
changeset
|
2763 |
osr = osr->osr_link(); |
1 | 2764 |
} |
6453 | 2765 |
if (best != NULL && best->comp_level() >= comp_level && match_level == false) { |
2766 |
return best; |
|
2767 |
} |
|
1 | 2768 |
return NULL; |
2769 |
} |
|
2770 |
||
43929
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2771 |
oop InstanceKlass::add_member_name(Handle mem_name, bool intern) { |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2772 |
jweak mem_name_wref = JNIHandles::make_weak_global(mem_name); |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2773 |
MutexLocker ml(MemberNameTable_lock); |
35492
c8c0273e6b91
8146690: Make all classes in GC follow the naming convention.
david
parents:
35061
diff
changeset
|
2774 |
DEBUG_ONLY(NoSafepointVerifier nsv); |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2775 |
|
27674
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2776 |
// Check if method has been redefined while taking out MemberNameTable_lock, if so |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2777 |
// return false. We cannot cache obsolete methods. They will crash when the function |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2778 |
// is called! |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2779 |
Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mem_name()); |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2780 |
if (method->is_obsolete()) { |
43929
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2781 |
return NULL; |
27674
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2782 |
} else if (method->is_old()) { |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2783 |
// Replace method with redefined version |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2784 |
java_lang_invoke_MemberName::set_vmtarget(mem_name(), method_with_idnum(method->method_idnum())); |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2785 |
} |
00cabfc45357
8042235: redefining method used by multiple MethodHandles crashes VM
coleenp
parents:
27478
diff
changeset
|
2786 |
|
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2787 |
if (_member_names == NULL) { |
17828
17131ab4b3b5
8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes
sspitsyn
parents:
17826
diff
changeset
|
2788 |
_member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable(idnum_allocated_count()); |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2789 |
} |
43929
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2790 |
if (intern) { |
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2791 |
return _member_names->find_or_add_member_name(mem_name_wref); |
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2792 |
} else { |
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2793 |
return _member_names->add_member_name(mem_name_wref); |
9a572e758c9b
8162795: [REDO] MemberNameTable doesn't purge stale entries
kevinw
parents:
43430
diff
changeset
|
2794 |
} |
17029
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2795 |
} |
9ff8d7c0ed79
8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition
sspitsyn
parents:
16672
diff
changeset
|
2796 |
|
1 | 2797 |
// ----------------------------------------------------------------------------------------------------- |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2798 |
// Printing |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2799 |
|
1 | 2800 |
#ifndef PRODUCT |
2801 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2802 |
#define BULLET " - " |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2803 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2804 |
static const char* state_names[] = { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2805 |
"allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2806 |
}; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2807 |
|
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2808 |
static void print_vtable(intptr_t* start, int len, outputStream* st) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2809 |
for (int i = 0; i < len; i++) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2810 |
intptr_t e = start[i]; |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2811 |
st->print("%d : " INTPTR_FORMAT, i, e); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2812 |
if (e != 0 && ((Metadata*)e)->is_metaspace_object()) { |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2813 |
st->print(" "); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2814 |
((Metadata*)e)->print_value_on(st); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2815 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2816 |
st->cr(); |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2817 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2818 |
} |
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2819 |
|
35900 | 2820 |
static void print_vtable(vtableEntry* start, int len, outputStream* st) { |
2821 |
return print_vtable(reinterpret_cast<intptr_t*>(start), len, st); |
|
2822 |
} |
|
2823 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2824 |
void InstanceKlass::print_on(outputStream* st) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2825 |
assert(is_klass(), "must be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2826 |
Klass::print_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2827 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2828 |
st->print(BULLET"instance size: %d", size_helper()); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2829 |
st->print(BULLET"klass size: %d", size()); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2830 |
st->print(BULLET"access: "); access_flags().print_on(st); st->cr(); |
24424
2658d7834c6e
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
24351
diff
changeset
|
2831 |
st->print(BULLET"state: "); st->print_cr("%s", state_names[_init_state]); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2832 |
st->print(BULLET"name: "); name()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2833 |
st->print(BULLET"super: "); super()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2834 |
st->print(BULLET"sub: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2835 |
Klass* sub = subklass(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2836 |
int n; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2837 |
for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2838 |
if (n < MaxSubklassPrintSize) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2839 |
sub->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2840 |
st->print(" "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2841 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2842 |
} |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
2843 |
if (n >= MaxSubklassPrintSize) st->print("(" INTX_FORMAT " more klasses...)", n - MaxSubklassPrintSize); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2844 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2845 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2846 |
if (is_interface()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2847 |
st->print_cr(BULLET"nof implementors: %d", nof_implementors()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2848 |
if (nof_implementors() == 1) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2849 |
st->print_cr(BULLET"implementor: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2850 |
st->print(" "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2851 |
implementor()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2852 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2853 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2854 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2855 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2856 |
st->print(BULLET"arrays: "); array_klasses()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2857 |
st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2858 |
if (Verbose || WizardMode) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2859 |
Array<Method*>* method_array = methods(); |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2860 |
for (int i = 0; i < method_array->length(); i++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2861 |
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2862 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2863 |
} |
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2864 |
st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2865 |
st->print(BULLET"default_methods: "); default_methods()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2866 |
if (Verbose && default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2867 |
Array<Method*>* method_array = default_methods(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2868 |
for (int i = 0; i < method_array->length(); i++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2869 |
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2870 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2871 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2872 |
if (default_vtable_indices() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2873 |
st->print(BULLET"default vtable indices: "); default_vtable_indices()->print_value_on(st); st->cr(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
2874 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2875 |
st->print(BULLET"local interfaces: "); local_interfaces()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2876 |
st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2877 |
st->print(BULLET"constants: "); constants()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2878 |
if (class_loader_data() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2879 |
st->print(BULLET"class loader data: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2880 |
class_loader_data()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2881 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2882 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2883 |
st->print(BULLET"host class: "); host_klass()->print_value_on_maybe_null(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2884 |
if (source_file_name() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2885 |
st->print(BULLET"source file: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2886 |
source_file_name()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2887 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2888 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2889 |
if (source_debug_extension() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2890 |
st->print(BULLET"source debug extension: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2891 |
st->print("%s", source_debug_extension()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2892 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2893 |
} |
15601 | 2894 |
st->print(BULLET"class annotations: "); class_annotations()->print_value_on(st); st->cr(); |
2895 |
st->print(BULLET"class type annotations: "); class_type_annotations()->print_value_on(st); st->cr(); |
|
2896 |
st->print(BULLET"field annotations: "); fields_annotations()->print_value_on(st); st->cr(); |
|
2897 |
st->print(BULLET"field type annotations: "); fields_type_annotations()->print_value_on(st); st->cr(); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2898 |
{ |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2899 |
bool have_pv = false; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2900 |
// previous versions are linked together through the InstanceKlass |
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
2901 |
for (InstanceKlass* pv_node = previous_versions(); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2902 |
pv_node != NULL; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2903 |
pv_node = pv_node->previous_versions()) { |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2904 |
if (!have_pv) |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2905 |
st->print(BULLET"previous version: "); |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2906 |
have_pv = true; |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2907 |
pv_node->constants()->print_value_on(st); |
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2908 |
} |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
2909 |
if (have_pv) st->cr(); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
2910 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2911 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2912 |
if (generic_signature() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2913 |
st->print(BULLET"generic signature: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2914 |
generic_signature()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2915 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2916 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2917 |
st->print(BULLET"inner classes: "); inner_classes()->print_value_on(st); st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2918 |
st->print(BULLET"java mirror: "); java_mirror()->print_value_on(st); st->cr(); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
2919 |
st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", vtable_length(), p2i(start_of_vtable())); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2920 |
if (vtable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_vtable(), vtable_length(), st); |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
2921 |
st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", itable_length(), p2i(start_of_itable())); st->cr(); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2922 |
if (itable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_itable(), itable_length(), st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2923 |
st->print_cr(BULLET"---- static fields (%d words):", static_field_size()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2924 |
FieldPrinter print_static_field(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2925 |
((InstanceKlass*)this)->do_local_static_fields(&print_static_field); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2926 |
st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size()); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2927 |
FieldPrinter print_nonstatic_field(st); |
33602 | 2928 |
InstanceKlass* ik = const_cast<InstanceKlass*>(this); |
2929 |
ik->do_nonstatic_fields(&print_nonstatic_field); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2930 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2931 |
st->print(BULLET"non-static oop maps: "); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2932 |
OopMapBlock* map = start_of_nonstatic_oop_maps(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2933 |
OopMapBlock* end_map = map + nonstatic_oop_map_count(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2934 |
while (map < end_map) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2935 |
st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1)); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2936 |
map++; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2937 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2938 |
st->cr(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2939 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2940 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2941 |
#endif //PRODUCT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2942 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2943 |
void InstanceKlass::print_value_on(outputStream* st) const { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2944 |
assert(is_klass(), "must be klass"); |
20017
81eba62e9048
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
19326
diff
changeset
|
2945 |
if (Verbose || WizardMode) access_flags().print_on(st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2946 |
name()->print_value_on(st); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2947 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2948 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2949 |
#ifndef PRODUCT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2950 |
|
1 | 2951 |
void FieldPrinter::do_field(fieldDescriptor* fd) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2952 |
_st->print(BULLET); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2953 |
if (_obj == NULL) { |
1 | 2954 |
fd->print_on(_st); |
2955 |
_st->cr(); |
|
2956 |
} else { |
|
2957 |
fd->print_on_for(_st, _obj); |
|
2958 |
_st->cr(); |
|
2959 |
} |
|
2960 |
} |
|
2961 |
||
2962 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2963 |
void InstanceKlass::oop_print_on(oop obj, outputStream* st) { |
1 | 2964 |
Klass::oop_print_on(obj, st); |
2965 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2966 |
if (this == SystemDictionary::String_klass()) { |
1 | 2967 |
typeArrayOop value = java_lang_String::value(obj); |
2968 |
juint length = java_lang_String::length(obj); |
|
2969 |
if (value != NULL && |
|
2970 |
value->is_typeArray() && |
|
33628 | 2971 |
length <= (juint) value->length()) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2972 |
st->print(BULLET"string: "); |
22907
f978a4a64728
8035648: Don't use Handle in java_lang_String::print
stefank
parents:
22881
diff
changeset
|
2973 |
java_lang_String::print(obj, st); |
1 | 2974 |
st->cr(); |
2975 |
if (!WizardMode) return; // that is enough |
|
2976 |
} |
|
2977 |
} |
|
2978 |
||
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2979 |
st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj)); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2980 |
FieldPrinter print_field(st, obj); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2981 |
do_nonstatic_fields(&print_field); |
1 | 2982 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2983 |
if (this == SystemDictionary::Class_klass()) { |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2984 |
st->print(BULLET"signature: "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2985 |
java_lang_Class::print_signature(obj, st); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2986 |
st->cr(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2987 |
Klass* mirrored_klass = java_lang_Class::as_Klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2988 |
st->print(BULLET"fake entry for mirror: "); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2989 |
mirrored_klass->print_value_on_maybe_null(st); |
1 | 2990 |
st->cr(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2991 |
Klass* array_klass = java_lang_Class::array_klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
2992 |
st->print(BULLET"fake entry for array: "); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2993 |
array_klass->print_value_on_maybe_null(st); |
1 | 2994 |
st->cr(); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2995 |
st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj)); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
2996 |
st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2997 |
Klass* real_klass = java_lang_Class::as_Klass(obj); |
33611
9abd65805e19
8139203: Consistent naming for klass type predicates
coleenp
parents:
33602
diff
changeset
|
2998 |
if (real_klass != NULL && real_klass->is_instance_klass()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
2999 |
InstanceKlass::cast(real_klass)->do_local_static_fields(&print_field); |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
3000 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3001 |
} else if (this == SystemDictionary::MethodType_klass()) { |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
3002 |
st->print(BULLET"signature: "); |
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8653
diff
changeset
|
3003 |
java_lang_invoke_MethodType::print_signature(obj, st); |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
3004 |
st->cr(); |
1 | 3005 |
} |
3006 |
} |
|
3007 |
||
4584
e2a449e8cc6f
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
4573
diff
changeset
|
3008 |
#endif //PRODUCT |
e2a449e8cc6f
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
4573
diff
changeset
|
3009 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3010 |
void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) { |
1 | 3011 |
st->print("a "); |
3012 |
name()->print_value_on(st); |
|
3013 |
obj->print_address_on(st); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3014 |
if (this == SystemDictionary::String_klass() |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3015 |
&& java_lang_String::value(obj) != NULL) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3016 |
ResourceMark rm; |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3017 |
int len = java_lang_String::length(obj); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3018 |
int plen = (len < 24 ? len : 12); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3019 |
char* str = java_lang_String::as_utf8_string(obj, 0, plen); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3020 |
st->print(" = \"%s\"", str); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3021 |
if (len > plen) |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3022 |
st->print("...[%d]", len); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3023 |
} else if (this == SystemDictionary::Class_klass()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3024 |
Klass* k = java_lang_Class::as_Klass(obj); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3025 |
st->print(" = "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3026 |
if (k != NULL) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3027 |
k->print_value_on(st); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3028 |
} else { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3029 |
const char* tname = type2name(java_lang_Class::primitive_type(obj)); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3030 |
st->print("%s", tname ? tname : "type?"); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3031 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3032 |
} else if (this == SystemDictionary::MethodType_klass()) { |
4094
1f424b2b2171
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
3916
diff
changeset
|
3033 |
st->print(" = "); |
8676
9098d4e927e1
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
8653
diff
changeset
|
3034 |
java_lang_invoke_MethodType::print_signature(obj, st); |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3035 |
} else if (java_lang_boxing_object::is_instance(obj)) { |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3036 |
st->print(" = "); |
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3037 |
java_lang_boxing_object::print(obj, st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3038 |
} else if (this == SystemDictionary::LambdaForm_klass()) { |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3039 |
oop vmentry = java_lang_invoke_LambdaForm::vmentry(obj); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3040 |
if (vmentry != NULL) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3041 |
st->print(" => "); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3042 |
vmentry->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3043 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3044 |
} else if (this == SystemDictionary::MemberName_klass()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3045 |
Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(obj); |
13391
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3046 |
if (vmtarget != NULL) { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3047 |
st->print(" = "); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3048 |
vmtarget->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3049 |
} else { |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3050 |
java_lang_invoke_MemberName::clazz(obj)->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3051 |
st->print("."); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3052 |
java_lang_invoke_MemberName::name(obj)->print_value_on(st); |
30245956af37
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
13201
diff
changeset
|
3053 |
} |
2332
5c7b6f4ce0a1
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
2131
diff
changeset
|
3054 |
} |
1 | 3055 |
} |
3056 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3057 |
const char* InstanceKlass::internal_name() const { |
1 | 3058 |
return external_name(); |
3059 |
} |
|
3060 |
||
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3061 |
void InstanceKlass::print_class_load_logging(ClassLoaderData* loader_data, |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3062 |
const char* module_name, |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3063 |
const ClassFileStream* cfs) const { |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3064 |
if (!log_is_enabled(Info, class, load)) { |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3065 |
return; |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3066 |
} |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3067 |
|
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3068 |
ResourceMark rm; |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3069 |
LogMessage(class, load) msg; |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3070 |
stringStream info_stream; |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3071 |
|
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3072 |
// Name and class hierarchy info |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3073 |
info_stream.print("%s", external_name()); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3074 |
|
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3075 |
// Source |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3076 |
if (cfs != NULL) { |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3077 |
if (cfs->source() != NULL) { |
36508 | 3078 |
if (module_name != NULL) { |
39277
460f34bbd0c0
8157490: JCK test vm/jni/DefineClass/dfcl001/dfcl00101m1/dfcl00101m1 crashes when run with -Xlog:classload=info
mockner
parents:
39216
diff
changeset
|
3079 |
if (ClassLoader::is_jrt(cfs->source())) { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3080 |
info_stream.print(" source: jrt:/%s", module_name); |
39277
460f34bbd0c0
8157490: JCK test vm/jni/DefineClass/dfcl001/dfcl00101m1/dfcl00101m1 crashes when run with -Xlog:classload=info
mockner
parents:
39216
diff
changeset
|
3081 |
} else { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3082 |
info_stream.print(" source: %s", cfs->source()); |
39277
460f34bbd0c0
8157490: JCK test vm/jni/DefineClass/dfcl001/dfcl00101m1/dfcl00101m1 crashes when run with -Xlog:classload=info
mockner
parents:
39216
diff
changeset
|
3083 |
} |
36508 | 3084 |
} else { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3085 |
info_stream.print(" source: %s", cfs->source()); |
36508 | 3086 |
} |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3087 |
} else if (loader_data == ClassLoaderData::the_null_class_loader_data()) { |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3088 |
Thread* THREAD = Thread::current(); |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3089 |
Klass* caller = |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3090 |
THREAD->is_Java_thread() |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3091 |
? ((JavaThread*)THREAD)->security_get_caller_class(1) |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3092 |
: NULL; |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3093 |
// caller can be NULL, for example, during a JVMTI VM_Init hook |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3094 |
if (caller != NULL) { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3095 |
info_stream.print(" source: instance of %s", caller->external_name()); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3096 |
} else { |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3097 |
// source is unknown |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3098 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3099 |
} else { |
46271
979ebd346ecf
8169881: Remove implicit Handle conversions oop->Handle
coleenp
parents:
42650
diff
changeset
|
3100 |
oop class_loader = loader_data->class_loader(); |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3101 |
info_stream.print(" source: %s", class_loader->klass()->external_name()); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3102 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3103 |
} else { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3104 |
info_stream.print(" source: shared objects file"); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3105 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3106 |
|
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3107 |
msg.info("%s", info_stream.as_string()); |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3108 |
|
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3109 |
if (log_is_enabled(Debug, class, load)) { |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3110 |
stringStream debug_stream; |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3111 |
|
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3112 |
// Class hierarchy info |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3113 |
debug_stream.print(" klass: " INTPTR_FORMAT " super: " INTPTR_FORMAT, |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3114 |
p2i(this), p2i(superklass())); |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3115 |
|
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3116 |
// Interfaces |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3117 |
if (local_interfaces() != NULL && local_interfaces()->length() > 0) { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3118 |
debug_stream.print(" interfaces:"); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3119 |
int length = local_interfaces()->length(); |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3120 |
for (int i = 0; i < length; i++) { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3121 |
debug_stream.print(" " INTPTR_FORMAT, |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3122 |
p2i(InstanceKlass::cast(local_interfaces()->at(i)))); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3123 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3124 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3125 |
|
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3126 |
// Class loader |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3127 |
debug_stream.print(" loader: ["); |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3128 |
loader_data->print_value_on(&debug_stream); |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3129 |
debug_stream.print("]"); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3130 |
|
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3131 |
// Classfile checksum |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3132 |
if (cfs) { |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3133 |
debug_stream.print(" bytes: %d checksum: %08x", |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3134 |
cfs->length(), |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3135 |
ClassLoader::crc32(0, (const char*)cfs->buffer(), |
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3136 |
cfs->length())); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3137 |
} |
46444
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3138 |
|
677be3444372
8154791: Xlog classload too redundant msgs info/debug
rprotacio
parents:
46431
diff
changeset
|
3139 |
msg.debug("%s", debug_stream.as_string()); |
35917
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3140 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3141 |
} |
463d67f86eaa
8079408: Reimplement TraceClassLoading, TraceClassUnloading, and TraceClassLoaderData with Unified Logging.
mockner
parents:
35900
diff
changeset
|
3142 |
|
15437 | 3143 |
#if INCLUDE_SERVICES |
3144 |
// Size Statistics |
|
3145 |
void InstanceKlass::collect_statistics(KlassSizeStats *sz) const { |
|
3146 |
Klass::collect_statistics(sz); |
|
3147 |
||
35898
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35847
diff
changeset
|
3148 |
sz->_inst_size = wordSize * size_helper(); |
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35847
diff
changeset
|
3149 |
sz->_vtab_bytes = wordSize * vtable_length(); |
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35847
diff
changeset
|
3150 |
sz->_itab_bytes = wordSize * itable_length(); |
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35847
diff
changeset
|
3151 |
sz->_nonstatic_oopmap_bytes = wordSize * nonstatic_oop_map_size(); |
15437 | 3152 |
|
3153 |
int n = 0; |
|
3154 |
n += (sz->_methods_array_bytes = sz->count_array(methods())); |
|
3155 |
n += (sz->_method_ordering_bytes = sz->count_array(method_ordering())); |
|
3156 |
n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces())); |
|
3157 |
n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces())); |
|
3158 |
n += (sz->_fields_bytes = sz->count_array(fields())); |
|
3159 |
n += (sz->_inner_classes_bytes = sz->count_array(inner_classes())); |
|
3160 |
sz->_ro_bytes += n; |
|
3161 |
||
3162 |
const ConstantPool* cp = constants(); |
|
3163 |
if (cp) { |
|
3164 |
cp->collect_statistics(sz); |
|
3165 |
} |
|
3166 |
||
3167 |
const Annotations* anno = annotations(); |
|
3168 |
if (anno) { |
|
3169 |
anno->collect_statistics(sz); |
|
3170 |
} |
|
3171 |
||
3172 |
const Array<Method*>* methods_array = methods(); |
|
3173 |
if (methods()) { |
|
3174 |
for (int i = 0; i < methods_array->length(); i++) { |
|
3175 |
Method* method = methods_array->at(i); |
|
3176 |
if (method) { |
|
3177 |
sz->_method_count ++; |
|
3178 |
method->collect_statistics(sz); |
|
3179 |
} |
|
3180 |
} |
|
3181 |
} |
|
3182 |
} |
|
3183 |
#endif // INCLUDE_SERVICES |
|
3184 |
||
1 | 3185 |
// Verification |
3186 |
||
3187 |
class VerifyFieldClosure: public OopClosure { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3188 |
protected: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3189 |
template <class T> void do_oop_work(T* p) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3190 |
oop obj = oopDesc::load_decode_heap_oop(p); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3191 |
if (!obj->is_oop_or_null()) { |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
3192 |
tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p2i(p), p2i(obj)); |
35061 | 3193 |
Universe::print_on(tty); |
1 | 3194 |
guarantee(false, "boom"); |
3195 |
} |
|
3196 |
} |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3197 |
public: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3198 |
virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); } |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3199 |
virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); } |
1 | 3200 |
}; |
3201 |
||
22794
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3202 |
void InstanceKlass::verify_on(outputStream* st) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3203 |
#ifndef PRODUCT |
18439 | 3204 |
// Avoid redundant verifies, this really should be in product. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3205 |
if (_verify_count == Universe::verify_count()) return; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3206 |
_verify_count = Universe::verify_count(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3207 |
#endif |
18439 | 3208 |
|
3209 |
// Verify Klass |
|
22794
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3210 |
Klass::verify_on(st); |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3211 |
|
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3212 |
// Verify that klass is present in ClassLoaderData |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3213 |
guarantee(class_loader_data()->contains_klass(this), |
f1c014ad3754
8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on
coleenp
parents:
22232
diff
changeset
|
3214 |
"this class isn't found in class loader data"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3215 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3216 |
// Verify vtables |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3217 |
if (is_linked()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3218 |
// $$$ This used to be done only for m/s collections. Doing it |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3219 |
// always seemed a valid generalization. (DLD -- 6/00) |
46408
70aab0c2ea8b
8178350: klassVtable and klassItable should be ValueObj
iklam
parents:
46387
diff
changeset
|
3220 |
vtable().verify(st); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3221 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3222 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3223 |
// Verify first subklass |
23515
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
3224 |
if (subklass() != NULL) { |
f4872ef5df09
8031820: NPG: Fix remaining references to metadata as oops in comments
coleenp
parents:
22929
diff
changeset
|
3225 |
guarantee(subklass()->is_klass(), "should be klass"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3226 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3227 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3228 |
// Verify siblings |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3229 |
Klass* super = this->super(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3230 |
Klass* sib = next_sibling(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3231 |
if (sib != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3232 |
if (sib == this) { |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
33105
diff
changeset
|
3233 |
fatal("subclass points to itself " PTR_FORMAT, p2i(sib)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3234 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3235 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3236 |
guarantee(sib->is_klass(), "should be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3237 |
guarantee(sib->super() == super, "siblings should have same superklass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3238 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3239 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3240 |
// Verify implementor fields |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3241 |
Klass* im = implementor(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3242 |
if (im != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3243 |
guarantee(is_interface(), "only interfaces should have implementor set"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3244 |
guarantee(im->is_klass(), "should be klass"); |
14488 | 3245 |
guarantee(!im->is_interface() || im == this, |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3246 |
"implementors cannot be interfaces"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3247 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3248 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3249 |
// Verify local interfaces |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3250 |
if (local_interfaces()) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3251 |
Array<Klass*>* local_interfaces = this->local_interfaces(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3252 |
for (int j = 0; j < local_interfaces->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3253 |
Klass* e = local_interfaces->at(j); |
14488 | 3254 |
guarantee(e->is_klass() && e->is_interface(), "invalid local interface"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3255 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3256 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3257 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3258 |
// Verify transitive interfaces |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3259 |
if (transitive_interfaces() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3260 |
Array<Klass*>* transitive_interfaces = this->transitive_interfaces(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3261 |
for (int j = 0; j < transitive_interfaces->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3262 |
Klass* e = transitive_interfaces->at(j); |
14488 | 3263 |
guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3264 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3265 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3266 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3267 |
// Verify methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3268 |
if (methods() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3269 |
Array<Method*>* methods = this->methods(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3270 |
for (int j = 0; j < methods->length(); j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3271 |
guarantee(methods->at(j)->is_method(), "non-method in methods array"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3272 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3273 |
for (int j = 0; j < methods->length() - 1; j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3274 |
Method* m1 = methods->at(j); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3275 |
Method* m2 = methods->at(j + 1); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3276 |
guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3277 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3278 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3279 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3280 |
// Verify method ordering |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3281 |
if (method_ordering() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3282 |
Array<int>* method_ordering = this->method_ordering(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3283 |
int length = method_ordering->length(); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3284 |
if (JvmtiExport::can_maintain_original_method_order() || |
16667
f0c0139a2125
8010943: guarantee(length == 0) failed: invalid method ordering length
hseigel
parents:
15935
diff
changeset
|
3285 |
((UseSharedSpaces || DumpSharedSpaces) && length != 0)) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3286 |
guarantee(length == methods()->length(), "invalid method ordering length"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3287 |
jlong sum = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3288 |
for (int j = 0; j < length; j++) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3289 |
int original_index = method_ordering->at(j); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3290 |
guarantee(original_index >= 0, "invalid method ordering index"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3291 |
guarantee(original_index < length, "invalid method ordering index"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3292 |
sum += original_index; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3293 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3294 |
// Verify sum of indices 0,1,...,length-1 |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3295 |
guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3296 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3297 |
guarantee(length == 0, "invalid method ordering length"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3298 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3299 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3300 |
|
20391
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3301 |
// Verify default methods |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3302 |
if (default_methods() != NULL) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3303 |
Array<Method*>* methods = this->default_methods(); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3304 |
for (int j = 0; j < methods->length(); j++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3305 |
guarantee(methods->at(j)->is_method(), "non-method in methods array"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3306 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3307 |
for (int j = 0; j < methods->length() - 1; j++) { |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3308 |
Method* m1 = methods->at(j); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3309 |
Method* m2 = methods->at(j + 1); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3310 |
guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3311 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3312 |
} |
7b146c5ebb18
8009130: Lambda: Fix access controls, loader constraints.
acorn
parents:
20379
diff
changeset
|
3313 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3314 |
// Verify JNI static field identifiers |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3315 |
if (jni_ids() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3316 |
jni_ids()->verify(this); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3317 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3318 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3319 |
// Verify other fields |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3320 |
if (array_klasses() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3321 |
guarantee(array_klasses()->is_klass(), "should be klass"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3322 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3323 |
if (constants() != NULL) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3324 |
guarantee(constants()->is_constantPool(), "should be constant pool"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3325 |
} |
15873
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3326 |
const Klass* host = host_klass(); |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3327 |
if (host != NULL) { |
5ce4f526e0ba
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
15601
diff
changeset
|
3328 |
guarantee(host->is_klass(), "should be klass"); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3329 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3330 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3331 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3332 |
void InstanceKlass::oop_verify_on(oop obj, outputStream* st) { |
1 | 3333 |
Klass::oop_verify_on(obj, st); |
3334 |
VerifyFieldClosure blk; |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3335 |
obj->oop_iterate_no_header(&blk); |
1 | 3336 |
} |
3337 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3338 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3339 |
// JNIid class for jfieldIDs only |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3340 |
// Note to reviewers: |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3341 |
// These JNI functions are just moved over to column 1 and not changed |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3342 |
// in the compressed oops workspace. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3343 |
JNIid::JNIid(Klass* holder, int offset, JNIid* next) { |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3344 |
_holder = holder; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3345 |
_offset = offset; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3346 |
_next = next; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3347 |
debug_only(_is_static_field_id = false;) |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3348 |
} |
1 | 3349 |
|
3350 |
||
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3351 |
JNIid* JNIid::find(int offset) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3352 |
JNIid* current = this; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3353 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3354 |
if (current->offset() == offset) return current; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3355 |
current = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3356 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3357 |
return NULL; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3358 |
} |
1 | 3359 |
|
3360 |
void JNIid::deallocate(JNIid* current) { |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3361 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3362 |
JNIid* next = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3363 |
delete current; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3364 |
current = next; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3365 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3366 |
} |
1 | 3367 |
|
3368 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3369 |
void JNIid::verify(Klass* holder) { |
13738
d67be49a5beb
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
13736
diff
changeset
|
3370 |
int first_field_offset = InstanceMirrorKlass::offset_of_static_fields(); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3371 |
int end_field_offset; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3372 |
end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize); |
1 | 3373 |
|
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3374 |
JNIid* current = this; |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3375 |
while (current != NULL) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3376 |
guarantee(current->holder() == holder, "Invalid klass in JNIid"); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3377 |
#ifdef ASSERT |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3378 |
int o = current->offset(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3379 |
if (current->is_static_field_id()) { |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3380 |
guarantee(o >= first_field_offset && o < end_field_offset, "Invalid static field offset in JNIid"); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3381 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3382 |
#endif |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3383 |
current = current->next(); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3384 |
} |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3385 |
} |
1 | 3386 |
|
3387 |
||
3388 |
#ifdef ASSERT |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3389 |
void InstanceKlass::set_init_state(ClassState state) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3390 |
bool good_state = is_shared() ? (_init_state <= state) |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3391 |
: (_init_state < state); |
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3392 |
assert(good_state || state == allocated, "illegal state transition"); |
11407
5399831730cd
7117052: instanceKlass::_init_state can be u1 type
coleenp
parents:
10739
diff
changeset
|
3393 |
_init_state = (u1)state; |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
225
diff
changeset
|
3394 |
} |
1 | 3395 |
#endif |
3396 |
||
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
3397 |
#if INCLUDE_JVMTI |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3398 |
|
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3399 |
// RedefineClasses() support for previous versions |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3400 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3401 |
// Globally, there is at least one previous version of a class to walk |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3402 |
// during class unloading, which is saved because old methods in the class |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3403 |
// are still running. Otherwise the previous version list is cleaned up. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3404 |
bool InstanceKlass::_has_previous_versions = false; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3405 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3406 |
// Returns true if there are previous versions of a class for class |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3407 |
// unloading only. Also resets the flag to false. purge_previous_version |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3408 |
// will set the flag to true if there are any left, i.e., if there's any |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3409 |
// work to do for next time. This is to avoid the expensive code cache |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3410 |
// walk in CLDG::do_unloading(). |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3411 |
bool InstanceKlass::has_previous_versions_and_reset() { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3412 |
bool ret = _has_previous_versions; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3413 |
log_trace(redefine, class, iklass, purge)("Class unloading: has_previous_versions = %s", |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3414 |
ret ? "true" : "false"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3415 |
_has_previous_versions = false; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3416 |
return ret; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3417 |
} |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3418 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3419 |
// Purge previous versions before adding new previous versions of the class and |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3420 |
// during class unloading. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3421 |
void InstanceKlass::purge_previous_version_list() { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3422 |
assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3423 |
assert(has_been_redefined(), "Should only be called for main class"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3424 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3425 |
// Quick exit. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3426 |
if (previous_versions() == NULL) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3427 |
return; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3428 |
} |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3429 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3430 |
// This klass has previous versions so see what we can cleanup |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3431 |
// while it is safe to do so. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3432 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3433 |
int deleted_count = 0; // leave debugging breadcrumbs |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3434 |
int live_count = 0; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3435 |
ClassLoaderData* loader_data = class_loader_data(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3436 |
assert(loader_data != NULL, "should never be null"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3437 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3438 |
ResourceMark rm; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3439 |
log_trace(redefine, class, iklass, purge)("%s: previous versions", external_name()); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3440 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3441 |
// previous versions are linked together through the InstanceKlass |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3442 |
InstanceKlass* pv_node = previous_versions(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3443 |
InstanceKlass* last = this; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3444 |
int version = 0; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3445 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3446 |
// check the previous versions list |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3447 |
for (; pv_node != NULL; ) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3448 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3449 |
ConstantPool* pvcp = pv_node->constants(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3450 |
assert(pvcp != NULL, "cp ref was unexpectedly cleared"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3451 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3452 |
if (!pvcp->on_stack()) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3453 |
// If the constant pool isn't on stack, none of the methods |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3454 |
// are executing. Unlink this previous_version. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3455 |
// The previous version InstanceKlass is on the ClassLoaderData deallocate list |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3456 |
// so will be deallocated during the next phase of class unloading. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3457 |
log_trace(redefine, class, iklass, purge) |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3458 |
("previous version " INTPTR_FORMAT " is dead.", p2i(pv_node)); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3459 |
// For debugging purposes. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3460 |
pv_node->set_is_scratch_class(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3461 |
// Unlink from previous version list. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3462 |
assert(pv_node->class_loader_data() == loader_data, "wrong loader_data"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3463 |
InstanceKlass* next = pv_node->previous_versions(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3464 |
pv_node->link_previous_versions(NULL); // point next to NULL |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3465 |
last->link_previous_versions(next); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3466 |
// Add to the deallocate list after unlinking |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3467 |
loader_data->add_to_deallocate_list(pv_node); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3468 |
pv_node = next; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3469 |
deleted_count++; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3470 |
version++; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3471 |
continue; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3472 |
} else { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3473 |
log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is alive", p2i(pv_node)); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3474 |
assert(pvcp->pool_holder() != NULL, "Constant pool with no holder"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3475 |
guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3476 |
live_count++; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3477 |
// found a previous version for next time we do class unloading |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3478 |
_has_previous_versions = true; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3479 |
} |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3480 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3481 |
// At least one method is live in this previous version. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3482 |
// Reset dead EMCP methods not to get breakpoints. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3483 |
// All methods are deallocated when all of the methods for this class are no |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3484 |
// longer running. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3485 |
Array<Method*>* method_refs = pv_node->methods(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3486 |
if (method_refs != NULL) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3487 |
log_trace(redefine, class, iklass, purge)("previous methods length=%d", method_refs->length()); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3488 |
for (int j = 0; j < method_refs->length(); j++) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3489 |
Method* method = method_refs->at(j); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3490 |
|
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3491 |
if (!method->on_stack()) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3492 |
// no breakpoints for non-running methods |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3493 |
if (method->is_running_emcp()) { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3494 |
method->set_running_emcp(false); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3495 |
} |
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3496 |
} else { |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3497 |
assert (method->is_obsolete() || method->is_running_emcp(), |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3498 |
"emcp method cannot run after emcp bit is cleared"); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3499 |
log_trace(redefine, class, iklass, purge) |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3500 |
("purge: %s(%s): prev method @%d in version @%d is alive", |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3501 |
method->name()->as_C_string(), method->signature()->as_C_string(), j, version); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3502 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3503 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3504 |
} |
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3505 |
// next previous version |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3506 |
last = pv_node; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3507 |
pv_node = pv_node->previous_versions(); |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3508 |
version++; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3509 |
} |
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3510 |
log_trace(redefine, class, iklass, purge) |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3511 |
("previous version stats: live=%d, deleted=%d", live_count, deleted_count); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3512 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3513 |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3514 |
void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods, |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3515 |
int emcp_method_count) { |
1 | 3516 |
int obsolete_method_count = old_methods->length() - emcp_method_count; |
3517 |
||
3518 |
if (emcp_method_count != 0 && obsolete_method_count != 0 && |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3519 |
_previous_versions != NULL) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3520 |
// We have a mix of obsolete and EMCP methods so we have to |
1 | 3521 |
// clear out any matching EMCP method entries the hard way. |
3522 |
int local_count = 0; |
|
3523 |
for (int i = 0; i < old_methods->length(); i++) { |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3524 |
Method* old_method = old_methods->at(i); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3525 |
if (old_method->is_obsolete()) { |
1 | 3526 |
// only obsolete methods are interesting |
8076
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
3527 |
Symbol* m_name = old_method->name(); |
96d498ec7ae1
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
7397
diff
changeset
|
3528 |
Symbol* m_signature = old_method->signature(); |
1 | 3529 |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3530 |
// previous versions are linked together through the InstanceKlass |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3531 |
int j = 0; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3532 |
for (InstanceKlass* prev_version = _previous_versions; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3533 |
prev_version != NULL; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3534 |
prev_version = prev_version->previous_versions(), j++) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3535 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3536 |
Array<Method*>* method_refs = prev_version->methods(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3537 |
for (int k = 0; k < method_refs->length(); k++) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3538 |
Method* method = method_refs->at(k); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3539 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3540 |
if (!method->is_obsolete() && |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3541 |
method->name() == m_name && |
1 | 3542 |
method->signature() == m_signature) { |
3543 |
// The current RedefineClasses() call has made all EMCP |
|
3544 |
// versions of this method obsolete so mark it as obsolete |
|
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3545 |
log_trace(redefine, class, iklass, add) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3546 |
("%s(%s): flush obsolete method @%d in version @%d", |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3547 |
m_name->as_C_string(), m_signature->as_C_string(), k, j); |
1 | 3548 |
|
3549 |
method->set_is_obsolete(); |
|
3550 |
break; |
|
3551 |
} |
|
3552 |
} |
|
3553 |
||
3554 |
// The previous loop may not find a matching EMCP method, but |
|
3555 |
// that doesn't mean that we can optimize and not go any |
|
3556 |
// further back in the PreviousVersion generations. The EMCP |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3557 |
// method for this generation could have already been made obsolete, |
1 | 3558 |
// but there still may be an older EMCP method that has not |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3559 |
// been made obsolete. |
1 | 3560 |
} |
3561 |
||
3562 |
if (++local_count >= obsolete_method_count) { |
|
3563 |
// no more obsolete methods so bail out now |
|
3564 |
break; |
|
3565 |
} |
|
3566 |
} |
|
3567 |
} |
|
3568 |
} |
|
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3569 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3570 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3571 |
// Save the scratch_class as the previous version if any of the methods are running. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3572 |
// The previous_versions are used to set breakpoints in EMCP methods and they are |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3573 |
// also used to clean MethodData links to redefined methods that are no longer running. |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
3574 |
void InstanceKlass::add_previous_version(InstanceKlass* scratch_class, |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3575 |
int emcp_method_count) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3576 |
assert(Thread::current()->is_VM_thread(), |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3577 |
"only VMThread can add previous versions"); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3578 |
|
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3579 |
ResourceMark rm; |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3580 |
log_trace(redefine, class, iklass, add) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3581 |
("adding previous version ref for %s, EMCP_cnt=%d", scratch_class->external_name(), emcp_method_count); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3582 |
|
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3583 |
// Clean out old previous versions for this class |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3584 |
purge_previous_version_list(); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3585 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3586 |
// Mark newly obsolete methods in remaining previous versions. An EMCP method from |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3587 |
// a previous redefinition may be made obsolete by this redefinition. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3588 |
Array<Method*>* old_methods = scratch_class->methods(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3589 |
mark_newly_obsolete_methods(old_methods, emcp_method_count); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3590 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3591 |
// If the constant pool for this previous version of the class |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3592 |
// is not marked as being on the stack, then none of the methods |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3593 |
// in this previous version of the class are on the stack so |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3594 |
// we don't need to add this as a previous version. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3595 |
ConstantPool* cp_ref = scratch_class->constants(); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3596 |
if (!cp_ref->on_stack()) { |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3597 |
log_trace(redefine, class, iklass, add)("scratch class not added; no methods are running"); |
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3598 |
// For debugging purposes. |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3599 |
scratch_class->set_is_scratch_class(); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
3600 |
scratch_class->class_loader_data()->add_to_deallocate_list(scratch_class); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3601 |
return; |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3602 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3603 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3604 |
if (emcp_method_count != 0) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3605 |
// At least one method is still running, check for EMCP methods |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3606 |
for (int i = 0; i < old_methods->length(); i++) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3607 |
Method* old_method = old_methods->at(i); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3608 |
if (!old_method->is_obsolete() && old_method->on_stack()) { |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3609 |
// if EMCP method (not obsolete) is on the stack, mark as EMCP so that |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3610 |
// we can add breakpoints for it. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3611 |
|
29576
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3612 |
// We set the method->on_stack bit during safepoints for class redefinition |
c223b0a9872e
8061205: MetadataOnStackMark only needs to walk code cache during class redefinition
coleenp
parents:
29316
diff
changeset
|
3613 |
// and use this bit to set the is_running_emcp bit. |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3614 |
// After the safepoint, the on_stack bit is cleared and the running emcp |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3615 |
// method may exit. If so, we would set a breakpoint in a method that |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3616 |
// is never reached, but this won't be noticeable to the programmer. |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3617 |
old_method->set_running_emcp(true); |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3618 |
log_trace(redefine, class, iklass, add) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3619 |
("EMCP method %s is on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method)); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3620 |
} else if (!old_method->is_obsolete()) { |
38259
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3621 |
log_trace(redefine, class, iklass, add) |
b495d1cfe673
8153535: Convert TraceRedefineClasses to Unified Logging
rehn
parents:
38151
diff
changeset
|
3622 |
("EMCP method %s is NOT on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method)); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3623 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3624 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3625 |
} |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3626 |
|
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3627 |
// Add previous version if any methods are still running. |
40927
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3628 |
// Set has_previous_version flag for processing during class unloading. |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3629 |
_has_previous_versions = true; |
59f3c8a69541
8165246: [REDO] InstanceKlass::_previous_version_count goes negative
coleenp
parents:
40909
diff
changeset
|
3630 |
log_trace(redefine, class, iklass, add) ("scratch class added; one of its methods is on_stack."); |
26558
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3631 |
assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version"); |
b7df27df6384
8055008: Clean up code that saves the previous versions of redefined classes
coleenp
parents:
26556
diff
changeset
|
3632 |
scratch_class->link_previous_versions(previous_versions()); |
46329
53ccc37bda19
8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents:
46327
diff
changeset
|
3633 |
link_previous_versions(scratch_class); |
1 | 3634 |
} // end add_previous_version() |
3635 |
||
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
3636 |
#endif // INCLUDE_JVMTI |
1 | 3637 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3638 |
Method* InstanceKlass::method_with_idnum(int idnum) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3639 |
Method* m = NULL; |
1 | 3640 |
if (idnum < methods()->length()) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3641 |
m = methods()->at(idnum); |
1 | 3642 |
} |
3643 |
if (m == NULL || m->method_idnum() != idnum) { |
|
3644 |
for (int index = 0; index < methods()->length(); ++index) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
13391
diff
changeset
|
3645 |
m = methods()->at(index); |
1 | 3646 |
if (m->method_idnum() == idnum) { |
3647 |
return m; |
|
3648 |
} |
|
3649 |
} |
|
20059
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
3650 |
// None found, return null for the caller to handle. |
c26474fd5ac0
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
19326
diff
changeset
|
3651 |
return NULL; |
1 | 3652 |
} |
3653 |
return m; |
|
3654 |
} |
|
3655 |
||
30107
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3656 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3657 |
Method* InstanceKlass::method_with_orig_idnum(int idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3658 |
if (idnum >= methods()->length()) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3659 |
return NULL; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3660 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3661 |
Method* m = methods()->at(idnum); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3662 |
if (m != NULL && m->orig_method_idnum() == idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3663 |
return m; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3664 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3665 |
// Obsolete method idnum does not match the original idnum |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3666 |
for (int index = 0; index < methods()->length(); ++index) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3667 |
m = methods()->at(index); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3668 |
if (m->orig_method_idnum() == idnum) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3669 |
return m; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3670 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3671 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3672 |
// None found, return null for the caller to handle. |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3673 |
return NULL; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3674 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3675 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3676 |
|
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3677 |
Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3678 |
InstanceKlass* holder = get_klass_version(version); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3679 |
if (holder == NULL) { |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3680 |
return NULL; // The version of klass is gone, no method is found |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3681 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3682 |
Method* method = holder->method_with_orig_idnum(idnum); |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3683 |
return method; |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3684 |
} |
e3d259b825a1
8067662: "java.lang.NullPointerException: Method name is null" from StackTraceElement.<init>
sspitsyn
parents:
30104
diff
changeset
|
3685 |
|
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
3686 |
#if INCLUDE_JVMTI |
41182 | 3687 |
JvmtiCachedClassFileData* InstanceKlass::get_cached_class_file() { |
3688 |
if (MetaspaceShared::is_in_shared_space(_cached_class_file)) { |
|
3689 |
// Ignore the archived class stream data |
|
3690 |
return NULL; |
|
3691 |
} else { |
|
3692 |
return _cached_class_file; |
|
3693 |
} |
|
3694 |
} |
|
3695 |
||
18940
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3696 |
jint InstanceKlass::get_cached_class_file_len() { |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3697 |
return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3698 |
} |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3699 |
|
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3700 |
unsigned char * InstanceKlass::get_cached_class_file_bytes() { |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3701 |
return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file); |
d39d4765e6cb
8020309: Eliminate InstanceKlass::_cached_class_file_len.
jiangli
parents:
18687
diff
changeset
|
3702 |
} |
41182 | 3703 |
|
3704 |
#if INCLUDE_CDS |
|
3705 |
JvmtiCachedClassFileData* InstanceKlass::get_archived_class_data() { |
|
3706 |
assert(this->is_shared(), "class should be shared"); |
|
3707 |
if (MetaspaceShared::is_in_shared_space(_cached_class_file)) { |
|
3708 |
return _cached_class_file; |
|
3709 |
} else { |
|
3710 |
return NULL; |
|
3711 |
} |
|
3712 |
} |
|
38059
86ab3f0a9f87
8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents:
37248
diff
changeset
|
3713 |
#endif |
41182 | 3714 |
#endif |