Mercurial > hg > truffle
annotate src/share/vm/oops/instanceKlass.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
author | Bernhard Urban <bernhard.urban@jku.at> |
---|---|
date | Mon, 15 Apr 2013 19:54:58 +0200 |
parents | 89e4d67fdd2a |
children | 836a62f43af9 |
rev | line source |
---|---|
0 | 1 /* |
7956 | 2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1490
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/javaClasses.hpp" | |
27 #include "classfile/systemDictionary.hpp" | |
28 #include "classfile/verifier.hpp" | |
29 #include "classfile/vmSymbols.hpp" | |
30 #include "compiler/compileBroker.hpp" | |
31 #include "gc_implementation/shared/markSweep.inline.hpp" | |
32 #include "gc_interface/collectedHeap.inline.hpp" | |
33 #include "interpreter/oopMapCache.hpp" | |
34 #include "interpreter/rewriter.hpp" | |
35 #include "jvmtifiles/jvmti.h" | |
36 #include "memory/genOopClosures.inline.hpp" | |
7956 | 37 #include "memory/heapInspection.hpp" |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
38 #include "memory/metadataFactory.hpp" |
1972 | 39 #include "memory/oopFactory.hpp" |
3938 | 40 #include "oops/fieldStreams.hpp" |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
41 #include "oops/instanceClassLoaderKlass.hpp" |
1972 | 42 #include "oops/instanceKlass.hpp" |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
43 #include "oops/instanceMirrorKlass.hpp" |
1972 | 44 #include "oops/instanceOop.hpp" |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
45 #include "oops/klass.inline.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
46 #include "oops/method.hpp" |
1972 | 47 #include "oops/oop.inline.hpp" |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
48 #include "oops/symbol.hpp" |
1972 | 49 #include "prims/jvmtiExport.hpp" |
50 #include "prims/jvmtiRedefineClassesTrace.hpp" | |
7459
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
51 #include "prims/methodComparator.hpp" |
1972 | 52 #include "runtime/fieldDescriptor.hpp" |
53 #include "runtime/handles.inline.hpp" | |
54 #include "runtime/javaCalls.hpp" | |
55 #include "runtime/mutexLocker.hpp" | |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6985
diff
changeset
|
56 #include "runtime/thread.inline.hpp" |
1972 | 57 #include "services/threadService.hpp" |
58 #include "utilities/dtrace.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
59 #include "utilities/macros.hpp" |
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
60 #if INCLUDE_ALL_GCS |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
61 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp" |
1972 | 62 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
63 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
64 #include "gc_implementation/g1/g1RemSet.inline.hpp" | |
65 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
66 #include "gc_implementation/parNew/parOopClosures.inline.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
67 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp" |
1972 | 68 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp" |
69 #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp" | |
70 #include "oops/oop.pcgc.inline.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
71 #endif // INCLUDE_ALL_GCS |
1972 | 72 #ifdef COMPILER1 |
73 #include "c1/c1_Compiler.hpp" | |
74 #endif | |
0 | 75 |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
76 #ifdef DTRACE_ENABLED |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
77 |
4006 | 78 #ifndef USDT2 |
79 | |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
80 HS_DTRACE_PROBE_DECL4(hotspot, class__initialization__required, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
81 char*, intptr_t, oop, intptr_t); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
82 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__recursive, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
83 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
84 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__concurrent, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
85 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
86 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__erroneous, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
87 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
88 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__super__failed, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
89 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
90 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__clinit, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
91 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
92 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__error, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
93 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
94 HS_DTRACE_PROBE_DECL5(hotspot, class__initialization__end, |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
95 char*, intptr_t, oop, intptr_t, int); |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
96 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
97 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
98 { \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
99 char* data = NULL; \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
100 int len = 0; \ |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
101 Symbol* name = (clss)->name(); \ |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
102 if (name != NULL) { \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
103 data = (char*)name->bytes(); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
104 len = name->utf8_length(); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
105 } \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
106 HS_DTRACE_PROBE4(hotspot, class__initialization__##type, \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
107 data, len, (clss)->class_loader(), thread_type); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
108 } |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
109 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
110 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
111 { \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
112 char* data = NULL; \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
113 int len = 0; \ |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
114 Symbol* name = (clss)->name(); \ |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
115 if (name != NULL) { \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
116 data = (char*)name->bytes(); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
117 len = name->utf8_length(); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
118 } \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
119 HS_DTRACE_PROBE5(hotspot, class__initialization__##type, \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
120 data, len, (clss)->class_loader(), thread_type, wait); \ |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
121 } |
4006 | 122 #else /* USDT2 */ |
123 | |
124 #define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED | |
125 #define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE | |
126 #define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT | |
127 #define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS | |
128 #define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED | |
129 #define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT | |
130 #define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR | |
131 #define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END | |
132 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) \ | |
133 { \ | |
134 char* data = NULL; \ | |
135 int len = 0; \ | |
136 Symbol* name = (clss)->name(); \ | |
137 if (name != NULL) { \ | |
138 data = (char*)name->bytes(); \ | |
139 len = name->utf8_length(); \ | |
140 } \ | |
141 HOTSPOT_CLASS_INITIALIZATION_##type( \ | |
142 data, len, (clss)->class_loader(), thread_type); \ | |
143 } | |
144 | |
145 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \ | |
146 { \ | |
147 char* data = NULL; \ | |
148 int len = 0; \ | |
149 Symbol* name = (clss)->name(); \ | |
150 if (name != NULL) { \ | |
151 data = (char*)name->bytes(); \ | |
152 len = name->utf8_length(); \ | |
153 } \ | |
154 HOTSPOT_CLASS_INITIALIZATION_##type( \ | |
155 data, len, (clss)->class_loader(), thread_type, wait); \ | |
156 } | |
157 #endif /* USDT2 */ | |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
158 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
159 #else // ndef DTRACE_ENABLED |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
160 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
161 #define DTRACE_CLASSINIT_PROBE(type, clss, thread_type) |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
162 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
163 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
164 #endif // ndef DTRACE_ENABLED |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
165 |
7464
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
166 volatile int InstanceKlass::_total_instanceKlass_count = 0; |
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
167 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
168 InstanceKlass* InstanceKlass::allocate_instance_klass( |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
169 ClassLoaderData* loader_data, |
8031 | 170 int vtable_len, |
171 int itable_len, | |
172 int static_field_size, | |
173 int nonstatic_oop_map_size, | |
174 ReferenceType rt, | |
175 AccessFlags access_flags, | |
176 Symbol* name, | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
177 Klass* super_klass, |
8031 | 178 bool is_anonymous, |
179 TRAPS) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
180 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
181 int size = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size, |
8031 | 182 access_flags.is_interface(), is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
183 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
184 // Allocation |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
185 InstanceKlass* ik; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
186 if (rt == REF_NONE) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
187 if (name == vmSymbols::java_lang_Class()) { |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
188 ik = new (loader_data, size, THREAD) InstanceMirrorKlass( |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
189 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
8031 | 190 access_flags, is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
191 } else if (name == vmSymbols::java_lang_ClassLoader() || |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
192 (SystemDictionary::ClassLoader_klass_loaded() && |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
193 super_klass != NULL && |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
194 super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) { |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
195 ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass( |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
196 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
8031 | 197 access_flags, is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
198 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
199 // normal class |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
200 ik = new (loader_data, size, THREAD) InstanceKlass( |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
201 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
8031 | 202 access_flags, is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
203 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
204 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
205 // reference klass |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
206 ik = new (loader_data, size, THREAD) InstanceRefKlass( |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
207 vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, |
8031 | 208 access_flags, is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
209 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
210 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
211 // Check for pending exception before adding to the loader data and incrementing |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
212 // class count. Can get OOM here. |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
213 if (HAS_PENDING_EXCEPTION) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
214 return NULL; |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
215 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
216 |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
217 // Add all classes to our internal class loader list here, |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
218 // including classes in the bootstrap (NULL) class loader. |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
219 loader_data->add_class(ik); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
220 |
7464
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
221 Atomic::inc(&_total_instanceKlass_count); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
222 return ik; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
223 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
224 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
225 |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
226 // copy method ordering from resource area to Metaspace |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
227 void InstanceKlass::copy_method_ordering(intArray* m, TRAPS) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
228 if (m != NULL) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
229 // allocate a new array and copy contents (memcpy?) |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
230 _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
231 for (int i = 0; i < m->length(); i++) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
232 _method_ordering->at_put(i, m->at(i)); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
233 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
234 } else { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
235 _method_ordering = Universe::the_empty_int_array(); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
236 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
237 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
238 |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
239 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
240 InstanceKlass::InstanceKlass(int vtable_len, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
241 int itable_len, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
242 int static_field_size, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
243 int nonstatic_oop_map_size, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
244 ReferenceType rt, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
245 AccessFlags access_flags, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
246 bool is_anonymous) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
247 No_Safepoint_Verifier no_safepoint; // until k becomes parsable |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
248 |
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
249 int iksize = InstanceKlass::size(vtable_len, itable_len, nonstatic_oop_map_size, |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
250 access_flags.is_interface(), is_anonymous); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
251 |
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
252 set_vtable_length(vtable_len); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
253 set_itable_length(itable_len); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
254 set_static_field_size(static_field_size); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
255 set_nonstatic_oop_map_size(nonstatic_oop_map_size); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
256 set_access_flags(access_flags); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
257 _misc_flags = 0; // initialize to zero |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
258 set_is_anonymous(is_anonymous); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
259 assert(size() == iksize, "wrong size for object"); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
260 |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
261 set_array_klasses(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
262 set_methods(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
263 set_method_ordering(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
264 set_local_interfaces(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
265 set_transitive_interfaces(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
266 init_implementor(); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
267 set_fields(NULL, 0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
268 set_constants(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
269 set_class_loader_data(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
270 set_protection_domain(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
271 set_signers(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
272 set_source_file_name(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
273 set_source_debug_extension(NULL, 0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
274 set_array_name(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
275 set_inner_classes(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
276 set_static_oop_field_count(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
277 set_nonstatic_field_size(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
278 set_is_marked_dependent(false); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
279 set_init_state(InstanceKlass::allocated); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
280 set_init_thread(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
281 set_init_lock(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
282 set_reference_type(rt); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
283 set_oop_map_cache(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
284 set_jni_ids(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
285 set_osr_nmethods_head(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
286 set_breakpoints(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
287 init_previous_versions(); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
288 set_generic_signature(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
289 release_set_methods_jmethod_ids(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
290 release_set_methods_cached_itable_indices(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
291 set_annotations(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
292 set_jvmti_cached_class_field_map(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
293 set_initial_method_idnum(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
294 _dependencies = NULL; |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
295 set_jvmti_cached_class_field_map(NULL); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
296 set_cached_class_file(NULL, 0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
297 set_initial_method_idnum(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
298 set_minor_version(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
299 set_major_version(0); |
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
300 NOT_PRODUCT(_verify_count = 0;) |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
301 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
302 // initialize the non-header words to zero |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
303 intptr_t* p = (intptr_t*)this; |
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
304 for (int index = InstanceKlass::header_size(); index < iksize; index++) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
305 p[index] = NULL_WORD; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
306 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
307 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
308 // Set temporary value until parseClassFile updates it with the real instance |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
309 // size. |
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
310 set_layout_helper(Klass::instance_layout_helper(0, true)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
311 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
312 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
313 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
314 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data, |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
315 Array<Method*>* methods) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
316 if (methods != NULL && methods != Universe::the_empty_method_array()) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
317 for (int i = 0; i < methods->length(); i++) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
318 Method* method = methods->at(i); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
319 if (method == NULL) continue; // maybe null if error processing |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
320 // Only want to delete methods that are not executing for RedefineClasses. |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
321 // The previous version will point to them so they're not totally dangling |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
322 assert (!method->on_stack(), "shouldn't be called with methods on stack"); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
323 MetadataFactory::free_metadata(loader_data, method); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
324 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
325 MetadataFactory::free_array<Method*>(loader_data, methods); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
326 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
327 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
328 |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
329 void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data, |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
330 Klass* super_klass, |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
331 Array<Klass*>* local_interfaces, |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
332 Array<Klass*>* transitive_interfaces) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
333 // Only deallocate transitive interfaces if not empty, same as super class |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
334 // or same as local interfaces. See code in parseClassFile. |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
335 Array<Klass*>* ti = transitive_interfaces; |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
336 if (ti != Universe::the_empty_klass_array() && ti != local_interfaces) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
337 // check that the interfaces don't come from super class |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
338 Array<Klass*>* sti = (super_klass == NULL) ? NULL : |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
339 InstanceKlass::cast(super_klass)->transitive_interfaces(); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
340 if (ti != sti) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
341 MetadataFactory::free_array<Klass*>(loader_data, ti); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
342 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
343 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
344 |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
345 // local interfaces can be empty |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
346 if (local_interfaces != Universe::the_empty_klass_array()) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
347 MetadataFactory::free_array<Klass*>(loader_data, local_interfaces); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
348 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
349 } |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
350 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
351 // This function deallocates the metadata and C heap pointers that the |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
352 // InstanceKlass points to. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
353 void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
354 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
355 // Orphan the mirror first, CMS thinks it's still live. |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
356 if (java_mirror() != NULL) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
357 java_lang_Class::set_klass(java_mirror(), NULL); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
358 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
359 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
360 // Need to take this class off the class loader data list. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
361 loader_data->remove_class(this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
362 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
363 // The array_klass for this class is created later, after error handling. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
364 // For class redefinition, we keep the original class so this scratch class |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
365 // doesn't have an array class. Either way, assert that there is nothing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
366 // to deallocate. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
367 assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
368 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
369 // Release C heap allocated data that this might point to, which includes |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
370 // reference counting symbol names. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
371 release_C_heap_structures(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
372 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
373 deallocate_methods(loader_data, methods()); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
374 set_methods(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
375 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
376 if (method_ordering() != Universe::the_empty_int_array()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
377 MetadataFactory::free_array<int>(loader_data, method_ordering()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
378 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
379 set_method_ordering(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
380 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
381 // This array is in Klass, but remove it with the InstanceKlass since |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
382 // this place would be the only caller and it can share memory with transitive |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
383 // interfaces. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
384 if (secondary_supers() != Universe::the_empty_klass_array() && |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
385 secondary_supers() != transitive_interfaces()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
386 MetadataFactory::free_array<Klass*>(loader_data, secondary_supers()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
387 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
388 set_secondary_supers(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
389 |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
390 deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces()); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
391 set_transitive_interfaces(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
392 set_local_interfaces(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
393 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
394 MetadataFactory::free_array<jushort>(loader_data, fields()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
395 set_fields(NULL, 0); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
396 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
397 // If a method from a redefined class is using this constant pool, don't |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
398 // delete it, yet. The new class's previous version will point to this. |
8719
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
399 if (constants() != NULL) { |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
400 assert (!constants()->on_stack(), "shouldn't be called if anything is onstack"); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
401 MetadataFactory::free_metadata(loader_data, constants()); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
402 set_constants(NULL); |
c8b31b461e1a
8003419: NPG: Clean up metadata created during class loading if failure
coleenp
parents:
8714
diff
changeset
|
403 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
404 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
405 if (inner_classes() != Universe::the_empty_short_array()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
406 MetadataFactory::free_array<jushort>(loader_data, inner_classes()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
407 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
408 set_inner_classes(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
409 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
410 // Null out Java heap objects, although these won't be walked to keep |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
411 // alive once this InstanceKlass is deallocated. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
412 set_protection_domain(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
413 set_signers(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
414 set_init_lock(NULL); |
7457
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
7180
diff
changeset
|
415 |
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
7180
diff
changeset
|
416 // We should deallocate the Annotations instance |
35431a769282
8004823: Add VM support for type annotation reflection
stefank
parents:
7180
diff
changeset
|
417 MetadataFactory::free_metadata(loader_data, annotations()); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
418 set_annotations(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
419 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
420 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
421 volatile oop InstanceKlass::init_lock() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
422 volatile oop lock = _init_lock; // read once |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
423 assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
424 "only fully initialized state can have a null lock"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
425 return lock; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
426 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
427 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
428 // Set the initialization lock to null so the object can be GC'ed. Any racing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
429 // threads to get this lock will see a null lock and will not lock. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
430 // That's okay because they all check for initialized state after getting |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
431 // the lock and return. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
432 void InstanceKlass::fence_and_clear_init_lock() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
433 // make sure previous stores are all done, notably the init_state. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
434 OrderAccess::storestore(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
435 klass_oop_store(&_init_lock, NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
436 assert(!is_not_initialized(), "class must be initialized now"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
437 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
438 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
439 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
440 bool InstanceKlass::should_be_initialized() const { |
0 | 441 return !is_initialized(); |
442 } | |
443 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
444 klassVtable* InstanceKlass::vtable() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
445 return new klassVtable(this, start_of_vtable(), vtable_length() / vtableEntry::size()); |
0 | 446 } |
447 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
448 klassItable* InstanceKlass::itable() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
449 return new klassItable(instanceKlassHandle(this)); |
0 | 450 } |
451 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
452 void InstanceKlass::eager_initialize(Thread *thread) { |
0 | 453 if (!EagerInitialization) return; |
454 | |
455 if (this->is_not_initialized()) { | |
456 // abort if the the class has a class initializer | |
457 if (this->class_initializer() != NULL) return; | |
458 | |
459 // abort if it is java.lang.Object (initialization is handled in genesis) | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
460 Klass* super = this->super(); |
0 | 461 if (super == NULL) return; |
462 | |
463 // abort if the super class should be initialized | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
464 if (!InstanceKlass::cast(super)->is_initialized()) return; |
0 | 465 |
466 // call body to expose the this pointer | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
467 instanceKlassHandle this_oop(thread, this); |
0 | 468 eager_initialize_impl(this_oop); |
469 } | |
470 } | |
471 | |
472 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
473 void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) { |
0 | 474 EXCEPTION_MARK; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
475 volatile oop init_lock = this_oop->init_lock(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
476 ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
0 | 477 |
478 // abort if someone beat us to the initialization | |
479 if (!this_oop->is_not_initialized()) return; // note: not equivalent to is_initialized() | |
480 | |
4739
52b5d32fbfaf
7117052: instanceKlass::_init_state can be u1 type
coleenp
parents:
4006
diff
changeset
|
481 ClassState old_state = this_oop->init_state(); |
0 | 482 link_class_impl(this_oop, true, THREAD); |
483 if (HAS_PENDING_EXCEPTION) { | |
484 CLEAR_PENDING_EXCEPTION; | |
485 // Abort if linking the class throws an exception. | |
486 | |
487 // Use a test to avoid redundantly resetting the state if there's | |
488 // no change. Set_init_state() asserts that state changes make | |
489 // progress, whereas here we might just be spinning in place. | |
490 if( old_state != this_oop->_init_state ) | |
491 this_oop->set_init_state (old_state); | |
492 } else { | |
493 // linking successfull, mark class as initialized | |
494 this_oop->set_init_state (fully_initialized); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
495 this_oop->fence_and_clear_init_lock(); |
0 | 496 // trace |
497 if (TraceClassInitialization) { | |
498 ResourceMark rm(THREAD); | |
499 tty->print_cr("[Initialized %s without side effects]", this_oop->external_name()); | |
500 } | |
501 } | |
502 } | |
503 | |
504 | |
505 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization | |
506 // process. The step comments refers to the procedure described in that section. | |
507 // Note: implementation moved to static method to expose the this pointer. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
508 void InstanceKlass::initialize(TRAPS) { |
0 | 509 if (this->should_be_initialized()) { |
510 HandleMark hm(THREAD); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
511 instanceKlassHandle this_oop(THREAD, this); |
0 | 512 initialize_impl(this_oop, CHECK); |
513 // Note: at this point the class may be initialized | |
514 // OR it may be in the state of being initialized | |
515 // in case of recursive initialization! | |
516 } else { | |
517 assert(is_initialized(), "sanity check"); | |
518 } | |
519 } | |
520 | |
521 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
522 bool InstanceKlass::verify_code( |
0 | 523 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) { |
524 // 1) Verify the bytecodes | |
525 Verifier::Mode mode = | |
526 throw_verifyerror ? Verifier::ThrowException : Verifier::NoException; | |
973
ad6585fd4087
6830542: Performance: JVM_DefineClass already verified.
acorn
parents:
964
diff
changeset
|
527 return Verifier::verify(this_oop, mode, this_oop->should_verify_class(), CHECK_false); |
0 | 528 } |
529 | |
530 | |
531 // Used exclusively by the shared spaces dump mechanism to prevent | |
532 // classes mapped into the shared regions in new VMs from appearing linked. | |
533 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
534 void InstanceKlass::unlink_class() { |
0 | 535 assert(is_linked(), "must be linked"); |
536 _init_state = loaded; | |
537 } | |
538 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
539 void InstanceKlass::link_class(TRAPS) { |
0 | 540 assert(is_loaded(), "must be loaded"); |
541 if (!is_linked()) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
542 HandleMark hm(THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
543 instanceKlassHandle this_oop(THREAD, this); |
0 | 544 link_class_impl(this_oop, true, CHECK); |
545 } | |
546 } | |
547 | |
548 // Called to verify that a class can link during initialization, without | |
549 // throwing a VerifyError. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
550 bool InstanceKlass::link_class_or_fail(TRAPS) { |
0 | 551 assert(is_loaded(), "must be loaded"); |
552 if (!is_linked()) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
553 HandleMark hm(THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
554 instanceKlassHandle this_oop(THREAD, this); |
0 | 555 link_class_impl(this_oop, false, CHECK_false); |
556 } | |
557 return is_linked(); | |
558 } | |
559 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
560 bool InstanceKlass::link_class_impl( |
0 | 561 instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS) { |
562 // check for error state | |
563 if (this_oop->is_in_error_state()) { | |
564 ResourceMark rm(THREAD); | |
565 THROW_MSG_(vmSymbols::java_lang_NoClassDefFoundError(), | |
566 this_oop->external_name(), false); | |
567 } | |
568 // return if already verified | |
569 if (this_oop->is_linked()) { | |
570 return true; | |
571 } | |
572 | |
573 // Timing | |
574 // timer handles recursion | |
575 assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl"); | |
576 JavaThread* jt = (JavaThread*)THREAD; | |
577 | |
578 // link super class before linking this class | |
579 instanceKlassHandle super(THREAD, this_oop->super()); | |
580 if (super.not_null()) { | |
581 if (super->is_interface()) { // check if super class is an interface | |
582 ResourceMark rm(THREAD); | |
583 Exceptions::fthrow( | |
584 THREAD_AND_LOCATION, | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
585 vmSymbols::java_lang_IncompatibleClassChangeError(), |
0 | 586 "class %s has interface %s as super class", |
587 this_oop->external_name(), | |
588 super->external_name() | |
589 ); | |
590 return false; | |
591 } | |
592 | |
593 link_class_impl(super, throw_verifyerror, CHECK_false); | |
594 } | |
595 | |
596 // link all interfaces implemented by this class before linking this class | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
597 Array<Klass*>* interfaces = this_oop->local_interfaces(); |
0 | 598 int num_interfaces = interfaces->length(); |
599 for (int index = 0; index < num_interfaces; index++) { | |
600 HandleMark hm(THREAD); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
601 instanceKlassHandle ih(THREAD, interfaces->at(index)); |
0 | 602 link_class_impl(ih, throw_verifyerror, CHECK_false); |
603 } | |
604 | |
605 // in case the class is linked in the process of linking its superclasses | |
606 if (this_oop->is_linked()) { | |
607 return true; | |
608 } | |
609 | |
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
610 // trace only the link time for this klass that includes |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
611 // the verification time |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
612 PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
613 ClassLoader::perf_class_link_selftime(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
614 ClassLoader::perf_classes_linked(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
615 jt->get_thread_stat()->perf_recursion_counts_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
616 jt->get_thread_stat()->perf_timers_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
617 PerfClassTraceTime::CLASS_LINK); |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
618 |
0 | 619 // verification & rewriting |
620 { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
621 volatile oop init_lock = this_oop->init_lock(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
622 ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
0 | 623 // rewritten will have been set if loader constraint error found |
624 // on an earlier link attempt | |
625 // don't verify or rewrite if already rewritten | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
626 |
0 | 627 if (!this_oop->is_linked()) { |
628 if (!this_oop->is_rewritten()) { | |
629 { | |
630 // Timer includes any side effects of class verification (resolution, | |
631 // etc), but not recursive entry into verify_code(). | |
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
632 PerfClassTraceTime timer(ClassLoader::perf_class_verify_time(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
633 ClassLoader::perf_class_verify_selftime(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
634 ClassLoader::perf_classes_verified(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
635 jt->get_thread_stat()->perf_recursion_counts_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
636 jt->get_thread_stat()->perf_timers_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
637 PerfClassTraceTime::CLASS_VERIFY); |
0 | 638 bool verify_ok = verify_code(this_oop, throw_verifyerror, THREAD); |
639 if (!verify_ok) { | |
640 return false; | |
641 } | |
642 } | |
643 | |
644 // Just in case a side-effect of verify linked this class already | |
645 // (which can sometimes happen since the verifier loads classes | |
646 // using custom class loaders, which are free to initialize things) | |
647 if (this_oop->is_linked()) { | |
648 return true; | |
649 } | |
650 | |
651 // also sets rewritten | |
652 this_oop->rewrite_class(CHECK_false); | |
653 } | |
654 | |
3404 | 655 // relocate jsrs and link methods after they are all rewritten |
7459
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
656 this_oop->link_methods(CHECK_false); |
3404 | 657 |
0 | 658 // Initialize the vtable and interface table after |
659 // methods have been rewritten since rewrite may | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
660 // fabricate new Method*s. |
0 | 661 // also does loader constraint checking |
662 if (!this_oop()->is_shared()) { | |
663 ResourceMark rm(THREAD); | |
664 this_oop->vtable()->initialize_vtable(true, CHECK_false); | |
665 this_oop->itable()->initialize_itable(true, CHECK_false); | |
666 } | |
667 #ifdef ASSERT | |
668 else { | |
669 ResourceMark rm(THREAD); | |
670 this_oop->vtable()->verify(tty, true); | |
671 // In case itable verification is ever added. | |
672 // this_oop->itable()->verify(tty, true); | |
673 } | |
674 #endif | |
675 this_oop->set_init_state(linked); | |
676 if (JvmtiExport::should_post_class_prepare()) { | |
677 Thread *thread = THREAD; | |
678 assert(thread->is_Java_thread(), "thread->is_Java_thread()"); | |
679 JvmtiExport::post_class_prepare((JavaThread *) thread, this_oop()); | |
680 } | |
681 } | |
682 } | |
683 return true; | |
684 } | |
685 | |
686 | |
687 // Rewrite the byte codes of all of the methods of a class. | |
688 // The rewriter must be called exactly once. Rewriting must happen after | |
689 // verification but before the first method of the class is executed. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
690 void InstanceKlass::rewrite_class(TRAPS) { |
0 | 691 assert(is_loaded(), "must be loaded"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
692 instanceKlassHandle this_oop(THREAD, this); |
0 | 693 if (this_oop->is_rewritten()) { |
694 assert(this_oop()->is_shared(), "rewriting an unshared class?"); | |
695 return; | |
696 } | |
3404 | 697 Rewriter::rewrite(this_oop, CHECK); |
0 | 698 this_oop->set_rewritten(); |
699 } | |
700 | |
3404 | 701 // Now relocate and link method entry points after class is rewritten. |
702 // This is outside is_rewritten flag. In case of an exception, it can be | |
703 // executed more than once. | |
7459
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
704 void InstanceKlass::link_methods(TRAPS) { |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
705 int len = methods()->length(); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
706 for (int i = len-1; i >= 0; i--) { |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
707 methodHandle m(THREAD, methods()->at(i)); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
708 |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
709 // Set up method entry points for compiler and interpreter . |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
710 m->link_method(m, CHECK); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
711 |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
712 // This is for JVMTI and unrelated to relocator but the last thing we do |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
713 #ifdef ASSERT |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
714 if (StressMethodComparator) { |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
715 ResourceMark rm(THREAD); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
716 static int nmc = 0; |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
717 for (int j = i; j >= 0 && j >= i-4; j--) { |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
718 if ((++nmc % 1000) == 0) tty->print_cr("Have run MethodComparator %d times...", nmc); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
719 bool z = MethodComparator::methods_EMCP(m(), |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
720 methods()->at(j)); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
721 if (j == i && !z) { |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
722 tty->print("MethodComparator FAIL: "); m->print(); m->print_codes(); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
723 assert(z, "method must compare equal to itself"); |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
724 } |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
725 } |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
726 } |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
727 #endif //ASSERT |
cc6a617fffd2
8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs
coleenp
parents:
7457
diff
changeset
|
728 } |
3404 | 729 } |
730 | |
0 | 731 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
732 void InstanceKlass::initialize_impl(instanceKlassHandle this_oop, TRAPS) { |
0 | 733 // Make sure klass is linked (verified) before initialization |
734 // A class could already be verified, since it has been reflected upon. | |
735 this_oop->link_class(CHECK); | |
736 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
737 DTRACE_CLASSINIT_PROBE(required, InstanceKlass::cast(this_oop()), -1); |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
738 |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
739 bool wait = false; |
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
740 |
0 | 741 // refer to the JVM book page 47 for description of steps |
742 // Step 1 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
743 { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
744 volatile oop init_lock = this_oop->init_lock(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
745 ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
0 | 746 |
747 Thread *self = THREAD; // it's passed the current thread | |
748 | |
749 // Step 2 | |
750 // If we were to use wait() instead of waitInterruptibly() then | |
751 // we might end up throwing IE from link/symbol resolution sites | |
752 // that aren't expected to throw. This would wreak havoc. See 6320309. | |
753 while(this_oop->is_being_initialized() && !this_oop->is_reentrant_initialization(self)) { | |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
754 wait = true; |
0 | 755 ol.waitUninterruptibly(CHECK); |
756 } | |
757 | |
758 // Step 3 | |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
759 if (this_oop->is_being_initialized() && this_oop->is_reentrant_initialization(self)) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
760 DTRACE_CLASSINIT_PROBE_WAIT(recursive, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 761 return; |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
762 } |
0 | 763 |
764 // Step 4 | |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
765 if (this_oop->is_initialized()) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
766 DTRACE_CLASSINIT_PROBE_WAIT(concurrent, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 767 return; |
1324
e392695de029
6935224: Adding new DTrace probes to work with Palantir
fparain
parents:
1155
diff
changeset
|
768 } |
0 | 769 |
770 // Step 5 | |
771 if (this_oop->is_in_error_state()) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
772 DTRACE_CLASSINIT_PROBE_WAIT(erroneous, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 773 ResourceMark rm(THREAD); |
774 const char* desc = "Could not initialize class "; | |
775 const char* className = this_oop->external_name(); | |
776 size_t msglen = strlen(desc) + strlen(className) + 1; | |
1751
2528b5bd749c
6980262: Memory leak when exception is thrown in static initializer
kamg
parents:
1706
diff
changeset
|
777 char* message = NEW_RESOURCE_ARRAY(char, msglen); |
0 | 778 if (NULL == message) { |
779 // Out of memory: can't create detailed error message | |
780 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className); | |
781 } else { | |
782 jio_snprintf(message, msglen, "%s%s", desc, className); | |
783 THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message); | |
784 } | |
785 } | |
786 | |
787 // Step 6 | |
788 this_oop->set_init_state(being_initialized); | |
789 this_oop->set_init_thread(self); | |
790 } | |
791 | |
792 // Step 7 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
793 Klass* super_klass = this_oop->super(); |
6983 | 794 if (super_klass != NULL && !this_oop->is_interface() && super_klass->should_be_initialized()) { |
795 super_klass->initialize(THREAD); | |
0 | 796 |
797 if (HAS_PENDING_EXCEPTION) { | |
798 Handle e(THREAD, PENDING_EXCEPTION); | |
799 CLEAR_PENDING_EXCEPTION; | |
800 { | |
801 EXCEPTION_MARK; | |
802 this_oop->set_initialization_state_and_notify(initialization_error, THREAD); // Locks object, set state, and notify all waiting threads | |
803 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, superclass initialization error is thrown below | |
804 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
805 DTRACE_CLASSINIT_PROBE_WAIT(super__failed, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 806 THROW_OOP(e()); |
807 } | |
808 } | |
809 | |
6934 | 810 if (this_oop->has_default_methods()) { |
811 // Step 7.5: initialize any interfaces which have default methods | |
812 for (int i = 0; i < this_oop->local_interfaces()->length(); ++i) { | |
813 Klass* iface = this_oop->local_interfaces()->at(i); | |
814 InstanceKlass* ik = InstanceKlass::cast(iface); | |
815 if (ik->has_default_methods() && ik->should_be_initialized()) { | |
816 ik->initialize(THREAD); | |
817 | |
818 if (HAS_PENDING_EXCEPTION) { | |
819 Handle e(THREAD, PENDING_EXCEPTION); | |
820 CLEAR_PENDING_EXCEPTION; | |
821 { | |
822 EXCEPTION_MARK; | |
823 // Locks object, set state, and notify all waiting threads | |
824 this_oop->set_initialization_state_and_notify( | |
825 initialization_error, THREAD); | |
826 | |
827 // ignore any exception thrown, superclass initialization error is | |
828 // thrown below | |
829 CLEAR_PENDING_EXCEPTION; | |
830 } | |
831 DTRACE_CLASSINIT_PROBE_WAIT( | |
832 super__failed, InstanceKlass::cast(this_oop()), -1, wait); | |
833 THROW_OOP(e()); | |
834 } | |
835 } | |
836 } | |
837 } | |
838 | |
0 | 839 // Step 8 |
840 { | |
841 assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl"); | |
842 JavaThread* jt = (JavaThread*)THREAD; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
843 DTRACE_CLASSINIT_PROBE_WAIT(clinit, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 844 // Timer includes any side effects of class initialization (resolution, |
845 // etc), but not recursive entry into call_class_initializer(). | |
875
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
846 PerfClassTraceTime timer(ClassLoader::perf_class_init_time(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
847 ClassLoader::perf_class_init_selftime(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
848 ClassLoader::perf_classes_inited(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
849 jt->get_thread_stat()->perf_recursion_counts_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
850 jt->get_thread_stat()->perf_timers_addr(), |
6a93908f268f
6857194: Add hotspot perf counters to aid class loading performance measurement
mchung
parents:
676
diff
changeset
|
851 PerfClassTraceTime::CLASS_CLINIT); |
0 | 852 this_oop->call_class_initializer(THREAD); |
853 } | |
854 | |
855 // Step 9 | |
856 if (!HAS_PENDING_EXCEPTION) { | |
857 this_oop->set_initialization_state_and_notify(fully_initialized, CHECK); | |
858 { ResourceMark rm(THREAD); | |
859 debug_only(this_oop->vtable()->verify(tty, true);) | |
860 } | |
861 } | |
862 else { | |
863 // Step 10 and 11 | |
864 Handle e(THREAD, PENDING_EXCEPTION); | |
865 CLEAR_PENDING_EXCEPTION; | |
866 { | |
867 EXCEPTION_MARK; | |
868 this_oop->set_initialization_state_and_notify(initialization_error, THREAD); | |
869 CLEAR_PENDING_EXCEPTION; // ignore any exception thrown, class initialization error is thrown below | |
870 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
871 DTRACE_CLASSINIT_PROBE_WAIT(error, InstanceKlass::cast(this_oop()), -1,wait); |
1142 | 872 if (e->is_a(SystemDictionary::Error_klass())) { |
0 | 873 THROW_OOP(e()); |
874 } else { | |
875 JavaCallArguments args(e); | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
876 THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
877 vmSymbols::throwable_void_signature(), |
0 | 878 &args); |
879 } | |
880 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
881 DTRACE_CLASSINIT_PROBE_WAIT(end, InstanceKlass::cast(this_oop()), -1,wait); |
0 | 882 } |
883 | |
884 | |
885 // Note: implementation moved to static method to expose the this pointer. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
886 void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
887 instanceKlassHandle kh(THREAD, this); |
0 | 888 set_initialization_state_and_notify_impl(kh, state, CHECK); |
889 } | |
890 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
891 void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
892 volatile oop init_lock = this_oop->init_lock(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
893 ObjectLocker ol(init_lock, THREAD, init_lock != NULL); |
0 | 894 this_oop->set_init_state(state); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
895 this_oop->fence_and_clear_init_lock(); |
0 | 896 ol.notify_all(CHECK); |
897 } | |
898 | |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
899 // The embedded _implementor field can only record one implementor. |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
900 // When there are more than one implementors, the _implementor field |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
901 // is set to the interface Klass* itself. Following are the possible |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
902 // values for the _implementor field: |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
903 // NULL - no implementor |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
904 // implementor Klass* - one implementor |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
905 // self - more than one implementor |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
906 // |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
907 // The _implementor field only exists for interfaces. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
908 void InstanceKlass::add_implementor(Klass* k) { |
0 | 909 assert(Compile_lock->owned_by_self(), ""); |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
910 assert(is_interface(), "not interface"); |
0 | 911 // Filter out my subinterfaces. |
912 // (Note: Interfaces are never on the subklass list.) | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
913 if (InstanceKlass::cast(k)->is_interface()) return; |
0 | 914 |
915 // Filter out subclasses whose supers already implement me. | |
916 // (Note: CHA must walk subclasses of direct implementors | |
917 // in order to locate indirect implementors.) | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
918 Klass* sk = InstanceKlass::cast(k)->super(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
919 if (sk != NULL && InstanceKlass::cast(sk)->implements_interface(this)) |
0 | 920 // We only need to check one immediate superclass, since the |
921 // implements_interface query looks at transitive_interfaces. | |
922 // Any supers of the super have the same (or fewer) transitive_interfaces. | |
923 return; | |
924 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
925 Klass* ik = implementor(); |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
926 if (ik == NULL) { |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
927 set_implementor(k); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
928 } else if (ik != this) { |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
929 // There is already an implementor. Use itself as an indicator of |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
930 // more than one implementors. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
931 set_implementor(this); |
0 | 932 } |
933 | |
934 // The implementor also implements the transitive_interfaces | |
935 for (int index = 0; index < local_interfaces()->length(); index++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
936 InstanceKlass::cast(local_interfaces()->at(index))->add_implementor(k); |
0 | 937 } |
938 } | |
939 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
940 void InstanceKlass::init_implementor() { |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
941 if (is_interface()) { |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
942 set_implementor(NULL); |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
943 } |
0 | 944 } |
945 | |
946 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
947 void InstanceKlass::process_interfaces(Thread *thread) { |
0 | 948 // link this class into the implementors list of every interface it implements |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
949 Klass* this_as_klass_oop = this; |
0 | 950 for (int i = local_interfaces()->length() - 1; i >= 0; i--) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
951 assert(local_interfaces()->at(i)->is_klass(), "must be a klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
952 InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i)); |
0 | 953 assert(interf->is_interface(), "expected interface"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
954 interf->add_implementor(this_as_klass_oop); |
0 | 955 } |
956 } | |
957 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
958 bool InstanceKlass::can_be_primary_super_slow() const { |
0 | 959 if (is_interface()) |
960 return false; | |
961 else | |
962 return Klass::can_be_primary_super_slow(); | |
963 } | |
964 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
965 GrowableArray<Klass*>* InstanceKlass::compute_secondary_supers(int num_extra_slots) { |
0 | 966 // The secondaries are the implemented interfaces. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
967 InstanceKlass* ik = InstanceKlass::cast(this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
968 Array<Klass*>* interfaces = ik->transitive_interfaces(); |
0 | 969 int num_secondaries = num_extra_slots + interfaces->length(); |
970 if (num_secondaries == 0) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
971 // Must share this for correct bootstrapping! |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
972 set_secondary_supers(Universe::the_empty_klass_array()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
973 return NULL; |
0 | 974 } else if (num_extra_slots == 0) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
975 // The secondary super list is exactly the same as the transitive interfaces. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
976 // Redefine classes has to be careful not to delete this! |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
977 set_secondary_supers(interfaces); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
978 return NULL; |
0 | 979 } else { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
980 // Copy transitive interfaces to a temporary growable array to be constructed |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
981 // into the secondary super list with extra slots. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
982 GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(interfaces->length()); |
0 | 983 for (int i = 0; i < interfaces->length(); i++) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
984 secondaries->push(interfaces->at(i)); |
0 | 985 } |
986 return secondaries; | |
987 } | |
988 } | |
989 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
990 bool InstanceKlass::compute_is_subtype_of(Klass* k) { |
6983 | 991 if (k->is_interface()) { |
0 | 992 return implements_interface(k); |
993 } else { | |
994 return Klass::compute_is_subtype_of(k); | |
995 } | |
996 } | |
997 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
998 bool InstanceKlass::implements_interface(Klass* k) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
999 if (this == k) return true; |
6983 | 1000 assert(k->is_interface(), "should be an interface class"); |
0 | 1001 for (int i = 0; i < transitive_interfaces()->length(); i++) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1002 if (transitive_interfaces()->at(i) == k) { |
0 | 1003 return true; |
1004 } | |
1005 } | |
1006 return false; | |
1007 } | |
1008 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1009 objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) { |
0 | 1010 if (length < 0) THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
1011 if (length > arrayOopDesc::max_array_length(T_OBJECT)) { | |
876
1413494da700
6850957: Honor -XX:OnOutOfMemoryError when array size exceeds VM limit
martin
parents:
875
diff
changeset
|
1012 report_java_out_of_memory("Requested array size exceeds VM limit"); |
5935
a735aec54ea4
7123170: JCK vm/jvmti/ResourceExhausted/resexh001/resexh00101/ tests fails since 7u4 b02
sspitsyn
parents:
4739
diff
changeset
|
1013 JvmtiExport::post_array_size_exhausted(); |
0 | 1014 THROW_OOP_0(Universe::out_of_memory_error_array_size()); |
1015 } | |
1016 int size = objArrayOopDesc::object_size(length); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1017 Klass* ak = array_klass(n, CHECK_NULL); |
0 | 1018 KlassHandle h_ak (THREAD, ak); |
1019 objArrayOop o = | |
1020 (objArrayOop)CollectedHeap::array_allocate(h_ak, size, length, CHECK_NULL); | |
1021 return o; | |
1022 } | |
1023 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1024 instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) { |
0 | 1025 if (TraceFinalizerRegistration) { |
1026 tty->print("Registered "); | |
1027 i->print_value_on(tty); | |
1028 tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", (address)i); | |
1029 } | |
1030 instanceHandle h_i(THREAD, i); | |
1031 // Pass the handle as argument, JavaCalls::call expects oop as jobjects | |
1032 JavaValue result(T_VOID); | |
1033 JavaCallArguments args(h_i); | |
1034 methodHandle mh (THREAD, Universe::finalizer_register_method()); | |
1035 JavaCalls::call(&result, mh, &args, CHECK_NULL); | |
1036 return h_i(); | |
1037 } | |
1038 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1039 instanceOop InstanceKlass::allocate_instance(TRAPS) { |
0 | 1040 bool has_finalizer_flag = has_finalizer(); // Query before possible GC |
1041 int size = size_helper(); // Query before forming handle. | |
1042 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1043 KlassHandle h_k(THREAD, this); |
0 | 1044 |
1045 instanceOop i; | |
1046 | |
1047 i = (instanceOop)CollectedHeap::obj_allocate(h_k, size, CHECK_NULL); | |
1048 if (has_finalizer_flag && !RegisterFinalizersAtInit) { | |
1049 i = register_finalizer(i, CHECK_NULL); | |
1050 } | |
1051 return i; | |
1052 } | |
1053 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1054 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) { |
0 | 1055 if (is_interface() || is_abstract()) { |
1056 ResourceMark rm(THREAD); | |
1057 THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError() | |
1058 : vmSymbols::java_lang_InstantiationException(), external_name()); | |
1059 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1060 if (this == SystemDictionary::Class_klass()) { |
0 | 1061 ResourceMark rm(THREAD); |
1062 THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError() | |
1063 : vmSymbols::java_lang_IllegalAccessException(), external_name()); | |
1064 } | |
1065 } | |
1066 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1067 Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1068 instanceKlassHandle this_oop(THREAD, this); |
0 | 1069 return array_klass_impl(this_oop, or_null, n, THREAD); |
1070 } | |
1071 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1072 Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_null, int n, TRAPS) { |
0 | 1073 if (this_oop->array_klasses() == NULL) { |
1074 if (or_null) return NULL; | |
1075 | |
1076 ResourceMark rm; | |
1077 JavaThread *jt = (JavaThread *)THREAD; | |
1078 { | |
1079 // Atomic creation of array_klasses | |
1080 MutexLocker mc(Compile_lock, THREAD); // for vtables | |
1081 MutexLocker ma(MultiArray_lock, THREAD); | |
1082 | |
1083 // Check if update has already taken place | |
1084 if (this_oop->array_klasses() == NULL) { | |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6735
diff
changeset
|
1085 Klass* k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL); |
0 | 1086 this_oop->set_array_klasses(k); |
1087 } | |
1088 } | |
1089 } | |
1090 // _this will always be set at this point | |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6735
diff
changeset
|
1091 ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses(); |
0 | 1092 if (or_null) { |
1093 return oak->array_klass_or_null(n); | |
1094 } | |
1095 return oak->array_klass(n, CHECK_NULL); | |
1096 } | |
1097 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1098 Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) { |
0 | 1099 return array_klass_impl(or_null, 1, THREAD); |
1100 } | |
1101 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1102 void InstanceKlass::call_class_initializer(TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1103 instanceKlassHandle ik (THREAD, this); |
0 | 1104 call_class_initializer_impl(ik, THREAD); |
1105 } | |
1106 | |
1107 static int call_class_initializer_impl_counter = 0; // for debugging | |
1108 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1109 Method* InstanceKlass::class_initializer() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1110 Method* clinit = find_method( |
2334
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2227
diff
changeset
|
1111 vmSymbols::class_initializer_name(), vmSymbols::void_method_signature()); |
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2227
diff
changeset
|
1112 if (clinit != NULL && clinit->has_valid_initializer_flags()) { |
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2227
diff
changeset
|
1113 return clinit; |
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2227
diff
changeset
|
1114 } |
dbad0519a1c4
6845426: non-static <clinit> method with no args is called during the class initialization process
kamg
parents:
2227
diff
changeset
|
1115 return NULL; |
0 | 1116 } |
1117 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1118 void InstanceKlass::call_class_initializer_impl(instanceKlassHandle this_oop, TRAPS) { |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1119 if (ReplayCompiles && |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1120 (ReplaySuppressInitializers == 1 || |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1121 ReplaySuppressInitializers >= 2 && this_oop->class_loader() != NULL)) { |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1122 // Hide the existence of the initializer for the purpose of replaying the compile |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1123 return; |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1124 } |
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6934
diff
changeset
|
1125 |
0 | 1126 methodHandle h_method(THREAD, this_oop->class_initializer()); |
1127 assert(!this_oop->is_initialized(), "we cannot initialize twice"); | |
1128 if (TraceClassInitialization) { | |
1129 tty->print("%d Initializing ", call_class_initializer_impl_counter++); | |
1130 this_oop->name()->print_value(); | |
1131 tty->print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", (address)this_oop()); | |
1132 } | |
1133 if (h_method() != NULL) { | |
1134 JavaCallArguments args; // No arguments | |
1135 JavaValue result(T_VOID); | |
1136 JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args) | |
1137 } | |
1138 } | |
1139 | |
1140 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1141 void InstanceKlass::mask_for(methodHandle method, int bci, |
0 | 1142 InterpreterOopMap* entry_for) { |
1143 // Dirty read, then double-check under a lock. | |
1144 if (_oop_map_cache == NULL) { | |
1145 // Otherwise, allocate a new one. | |
1146 MutexLocker x(OopMapCacheAlloc_lock); | |
1147 // First time use. Allocate a cache in C heap | |
1148 if (_oop_map_cache == NULL) { | |
1149 _oop_map_cache = new OopMapCache(); | |
1150 } | |
1151 } | |
1152 // _oop_map_cache is constant after init; lookup below does is own locking. | |
1153 _oop_map_cache->lookup(method, bci, entry_for); | |
1154 } | |
1155 | |
1156 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1157 bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1158 for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
3938 | 1159 Symbol* f_name = fs.name(); |
1160 Symbol* f_sig = fs.signature(); | |
0 | 1161 if (f_name == name && f_sig == sig) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1162 fd->initialize(const_cast<InstanceKlass*>(this), fs.index()); |
0 | 1163 return true; |
1164 } | |
1165 } | |
1166 return false; | |
1167 } | |
1168 | |
1169 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1170 Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
0 | 1171 const int n = local_interfaces()->length(); |
1172 for (int i = 0; i < n; i++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1173 Klass* intf1 = local_interfaces()->at(i); |
6983 | 1174 assert(intf1->is_interface(), "just checking type"); |
0 | 1175 // search for field in current interface |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1176 if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) { |
0 | 1177 assert(fd->is_static(), "interface field must be static"); |
1178 return intf1; | |
1179 } | |
1180 // search for field in direct superinterfaces | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1181 Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd); |
0 | 1182 if (intf2 != NULL) return intf2; |
1183 } | |
1184 // otherwise field lookup fails | |
1185 return NULL; | |
1186 } | |
1187 | |
1188 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1189 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const { |
0 | 1190 // search order according to newest JVM spec (5.4.3.2, p.167). |
1191 // 1) search for field in current klass | |
1192 if (find_local_field(name, sig, fd)) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1193 return const_cast<InstanceKlass*>(this); |
0 | 1194 } |
1195 // 2) search for field recursively in direct superinterfaces | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1196 { Klass* intf = find_interface_field(name, sig, fd); |
0 | 1197 if (intf != NULL) return intf; |
1198 } | |
1199 // 3) apply field lookup recursively if superclass exists | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1200 { Klass* supr = super(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1201 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd); |
0 | 1202 } |
1203 // 4) otherwise field lookup fails | |
1204 return NULL; | |
1205 } | |
1206 | |
1207 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1208 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const { |
0 | 1209 // search order according to newest JVM spec (5.4.3.2, p.167). |
1210 // 1) search for field in current klass | |
1211 if (find_local_field(name, sig, fd)) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1212 if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this); |
0 | 1213 } |
1214 // 2) search for field recursively in direct superinterfaces | |
1215 if (is_static) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1216 Klass* intf = find_interface_field(name, sig, fd); |
0 | 1217 if (intf != NULL) return intf; |
1218 } | |
1219 // 3) apply field lookup recursively if superclass exists | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1220 { Klass* supr = super(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1221 if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd); |
0 | 1222 } |
1223 // 4) otherwise field lookup fails | |
1224 return NULL; | |
1225 } | |
1226 | |
1227 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1228 bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1229 for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
3938 | 1230 if (fs.offset() == offset) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1231 fd->initialize(const_cast<InstanceKlass*>(this), fs.index()); |
0 | 1232 if (fd->is_static() == is_static) return true; |
1233 } | |
1234 } | |
1235 return false; | |
1236 } | |
1237 | |
1238 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1239 bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1240 Klass* klass = const_cast<InstanceKlass*>(this); |
0 | 1241 while (klass != NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1242 if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) { |
0 | 1243 return true; |
1244 } | |
6983 | 1245 klass = klass->super(); |
0 | 1246 } |
1247 return false; | |
1248 } | |
1249 | |
1250 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1251 void InstanceKlass::methods_do(void f(Method* method)) { |
0 | 1252 int len = methods()->length(); |
1253 for (int index = 0; index < len; index++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1254 Method* m = methods()->at(index); |
0 | 1255 assert(m->is_method(), "must be method"); |
1256 f(m); | |
1257 } | |
1258 } | |
1259 | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
1260 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1261 void InstanceKlass::do_local_static_fields(FieldClosure* cl) { |
3938 | 1262 for (JavaFieldStream fs(this); !fs.done(); fs.next()) { |
1263 if (fs.access_flags().is_static()) { | |
1264 fieldDescriptor fd; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1265 fd.initialize(this, fs.index()); |
3938 | 1266 cl->do_field(&fd); |
1267 } | |
0 | 1268 } |
1269 } | |
1270 | |
1271 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1272 void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1273 instanceKlassHandle h_this(THREAD, this); |
0 | 1274 do_local_static_fields_impl(h_this, f, CHECK); |
1275 } | |
1276 | |
1277 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1278 void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) { |
3938 | 1279 for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) { |
1280 if (fs.access_flags().is_static()) { | |
1281 fieldDescriptor fd; | |
1282 fd.initialize(this_oop(), fs.index()); | |
1283 f(&fd, CHECK); | |
1284 } | |
0 | 1285 } |
1286 } | |
1287 | |
1288 | |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1289 static int compare_fields_by_offset(int* a, int* b) { |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1290 return a[0] - b[0]; |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1291 } |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1292 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1293 void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1294 InstanceKlass* super = superklass(); |
0 | 1295 if (super != NULL) { |
1296 super->do_nonstatic_fields(cl); | |
1297 } | |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1298 fieldDescriptor fd; |
3938 | 1299 int length = java_fields_count(); |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1300 // In DebugInfo nonstatic fields are sorted by offset. |
6197 | 1301 int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass); |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1302 int j = 0; |
3938 | 1303 for (int i = 0; i < length; i += 1) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1304 fd.initialize(this, i); |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1305 if (!fd.is_static()) { |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1306 fields_sorted[j + 0] = fd.offset(); |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1307 fields_sorted[j + 1] = i; |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1308 j += 2; |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1309 } |
0 | 1310 } |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1311 if (j > 0) { |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1312 length = j; |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1313 // _sort_Fn is defined in growableArray.hpp. |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1314 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset); |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1315 for (int i = 0; i < length; i += 2) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1316 fd.initialize(this, fields_sorted[i + 1]); |
44
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1317 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields"); |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1318 cl->do_field(&fd); |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1319 } |
52fed2ec0afb
6667620: (Escape Analysis) fix deoptimization for scalar replaced objects
kvn
parents:
0
diff
changeset
|
1320 } |
6197 | 1321 FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass); |
0 | 1322 } |
1323 | |
1324 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1325 void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1326 if (array_klasses() != NULL) |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6735
diff
changeset
|
1327 ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1328 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1329 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1330 void InstanceKlass::array_klasses_do(void f(Klass* k)) { |
0 | 1331 if (array_klasses() != NULL) |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6735
diff
changeset
|
1332 ArrayKlass::cast(array_klasses())->array_klasses_do(f); |
0 | 1333 } |
1334 | |
1335 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1336 void InstanceKlass::with_array_klasses_do(void f(Klass* k)) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1337 f(this); |
0 | 1338 array_klasses_do(f); |
1339 } | |
1340 | |
1341 #ifdef ASSERT | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1342 static int linear_search(Array<Method*>* methods, Symbol* name, Symbol* signature) { |
0 | 1343 int len = methods->length(); |
1344 for (int index = 0; index < len; index++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1345 Method* m = methods->at(index); |
0 | 1346 assert(m->is_method(), "must be method"); |
1347 if (m->signature() == signature && m->name() == name) { | |
1348 return index; | |
1349 } | |
1350 } | |
1351 return -1; | |
1352 } | |
1353 #endif | |
1354 | |
6934 | 1355 static int binary_search(Array<Method*>* methods, Symbol* name) { |
0 | 1356 int len = methods->length(); |
1357 // methods are sorted, so do binary search | |
1358 int l = 0; | |
1359 int h = len - 1; | |
1360 while (l <= h) { | |
1361 int mid = (l + h) >> 1; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1362 Method* m = methods->at(mid); |
0 | 1363 assert(m->is_method(), "must be method"); |
1364 int res = m->name()->fast_compare(name); | |
1365 if (res == 0) { | |
6934 | 1366 return mid; |
0 | 1367 } else if (res < 0) { |
1368 l = mid + 1; | |
1369 } else { | |
1370 h = mid - 1; | |
1371 } | |
1372 } | |
6934 | 1373 return -1; |
1374 } | |
1375 | |
1376 Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const { | |
1377 return InstanceKlass::find_method(methods(), name, signature); | |
1378 } | |
1379 | |
1380 Method* InstanceKlass::find_method( | |
1381 Array<Method*>* methods, Symbol* name, Symbol* signature) { | |
1382 int hit = binary_search(methods, name); | |
1383 if (hit != -1) { | |
1384 Method* m = methods->at(hit); | |
1385 // Do linear search to find matching signature. First, quick check | |
1386 // for common case | |
1387 if (m->signature() == signature) return m; | |
1388 // search downwards through overloaded methods | |
1389 int i; | |
1390 for (i = hit - 1; i >= 0; --i) { | |
1391 Method* m = methods->at(i); | |
1392 assert(m->is_method(), "must be method"); | |
1393 if (m->name() != name) break; | |
1394 if (m->signature() == signature) return m; | |
1395 } | |
1396 // search upwards | |
1397 for (i = hit + 1; i < methods->length(); ++i) { | |
1398 Method* m = methods->at(i); | |
1399 assert(m->is_method(), "must be method"); | |
1400 if (m->name() != name) break; | |
1401 if (m->signature() == signature) return m; | |
1402 } | |
1403 // not found | |
0 | 1404 #ifdef ASSERT |
6934 | 1405 int index = linear_search(methods, name, signature); |
1406 assert(index == -1, err_msg("binary search should have found entry %d", index)); | |
0 | 1407 #endif |
6934 | 1408 } |
0 | 1409 return NULL; |
1410 } | |
1411 | |
6934 | 1412 int InstanceKlass::find_method_by_name(Symbol* name, int* end) { |
1413 return find_method_by_name(methods(), name, end); | |
1414 } | |
1415 | |
1416 int InstanceKlass::find_method_by_name( | |
1417 Array<Method*>* methods, Symbol* name, int* end_ptr) { | |
1418 assert(end_ptr != NULL, "just checking"); | |
1419 int start = binary_search(methods, name); | |
1420 int end = start + 1; | |
1421 if (start != -1) { | |
1422 while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start; | |
1423 while (end < methods->length() && (methods->at(end))->name() == name) ++end; | |
1424 *end_ptr = end; | |
1425 return start; | |
1426 } | |
1427 return -1; | |
1428 } | |
1429 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1430 Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1431 Klass* klass = const_cast<InstanceKlass*>(this); |
0 | 1432 while (klass != NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1433 Method* method = InstanceKlass::cast(klass)->find_method(name, signature); |
0 | 1434 if (method != NULL) return method; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1435 klass = InstanceKlass::cast(klass)->super(); |
0 | 1436 } |
1437 return NULL; | |
1438 } | |
1439 | |
1440 // lookup a method in all the interfaces that this class implements | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1441 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name, |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
1442 Symbol* signature) const { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1443 Array<Klass*>* all_ifs = transitive_interfaces(); |
0 | 1444 int num_ifs = all_ifs->length(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1445 InstanceKlass *ik = NULL; |
0 | 1446 for (int i = 0; i < num_ifs; i++) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1447 ik = InstanceKlass::cast(all_ifs->at(i)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1448 Method* m = ik->lookup_method(name, signature); |
0 | 1449 if (m != NULL) { |
1450 return m; | |
1451 } | |
1452 } | |
1453 return NULL; | |
1454 } | |
1455 | |
1456 /* jni_id_for_impl for jfieldIds only */ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1457 JNIid* InstanceKlass::jni_id_for_impl(instanceKlassHandle this_oop, int offset) { |
0 | 1458 MutexLocker ml(JfieldIdCreation_lock); |
1459 // Retry lookup after we got the lock | |
1460 JNIid* probe = this_oop->jni_ids() == NULL ? NULL : this_oop->jni_ids()->find(offset); | |
1461 if (probe == NULL) { | |
1462 // Slow case, allocate new static field identifier | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1463 probe = new JNIid(this_oop(), offset, this_oop->jni_ids()); |
0 | 1464 this_oop->set_jni_ids(probe); |
1465 } | |
1466 return probe; | |
1467 } | |
1468 | |
1469 | |
1470 /* jni_id_for for jfieldIds only */ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1471 JNIid* InstanceKlass::jni_id_for(int offset) { |
0 | 1472 JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset); |
1473 if (probe == NULL) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1474 probe = jni_id_for_impl(this, offset); |
0 | 1475 } |
1476 return probe; | |
1477 } | |
1478 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1479 u2 InstanceKlass::enclosing_method_data(int offset) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1480 Array<jushort>* inner_class_list = inner_classes(); |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1481 if (inner_class_list == NULL) { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1482 return 0; |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1483 } |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1484 int length = inner_class_list->length(); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1485 if (length % inner_class_next_offset == 0) { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1486 return 0; |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1487 } else { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1488 int index = length - enclosing_method_attribute_size; |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1489 assert(offset < enclosing_method_attribute_size, "invalid offset"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1490 return inner_class_list->at(index + offset); |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1491 } |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1492 } |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1493 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1494 void InstanceKlass::set_enclosing_method_indices(u2 class_index, |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1495 u2 method_index) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1496 Array<jushort>* inner_class_list = inner_classes(); |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1497 assert (inner_class_list != NULL, "_inner_classes list is not set up"); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1498 int length = inner_class_list->length(); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1499 if (length % inner_class_next_offset == enclosing_method_attribute_size) { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1500 int index = length - enclosing_method_attribute_size; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1501 inner_class_list->at_put( |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1502 index + enclosing_method_class_index_offset, class_index); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1503 inner_class_list->at_put( |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1504 index + enclosing_method_method_index_offset, method_index); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1505 } |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
1506 } |
0 | 1507 |
1508 // Lookup or create a jmethodID. | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1509 // This code is called by the VMThread and JavaThreads so the |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1510 // locking has to be done very carefully to avoid deadlocks |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1511 // and/or other cache consistency problems. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1512 // |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1513 jmethodID InstanceKlass::get_jmethod_id(instanceKlassHandle ik_h, methodHandle method_h) { |
0 | 1514 size_t idnum = (size_t)method_h->method_idnum(); |
1515 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); | |
1516 size_t length = 0; | |
1517 jmethodID id = NULL; | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1518 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1519 // We use a double-check locking idiom here because this cache is |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1520 // performance sensitive. In the normal system, this cache only |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1521 // transitions from NULL to non-NULL which is safe because we use |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1522 // release_set_methods_jmethod_ids() to advertise the new cache. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1523 // A partially constructed cache should never be seen by a racing |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1524 // thread. We also use release_store_ptr() to save a new jmethodID |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1525 // in the cache so a partially constructed jmethodID should never be |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1526 // seen either. Cache reads of existing jmethodIDs proceed without a |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1527 // lock, but cache writes of a new jmethodID requires uniqueness and |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1528 // creation of the cache itself requires no leaks so a lock is |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1529 // generally acquired in those two cases. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1530 // |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1531 // If the RedefineClasses() API has been used, then this cache can |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1532 // grow and we'll have transitions from non-NULL to bigger non-NULL. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1533 // Cache creation requires no leaks and we require safety between all |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1534 // cache accesses and freeing of the old cache so a lock is generally |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1535 // acquired when the RedefineClasses() API has been used. |
0 | 1536 |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1537 if (jmeths != NULL) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1538 // the cache already exists |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1539 if (!ik_h->idnum_can_increment()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1540 // the cache can't grow so we can just get the current values |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1541 get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1542 } else { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1543 // cache can grow so we have to be more careful |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1544 if (Threads::number_of_threads() == 0 || |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1545 SafepointSynchronize::is_at_safepoint()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1546 // we're single threaded or at a safepoint - no locking needed |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1547 get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1548 } else { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1549 MutexLocker ml(JmethodIdCreation_lock); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1550 get_jmethod_id_length_value(jmeths, idnum, &length, &id); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1551 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1552 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1553 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1554 // implied else: |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1555 // we need to allocate a cache so default length and id values are good |
0 | 1556 |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1557 if (jmeths == NULL || // no cache yet |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1558 length <= idnum || // cache is too short |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1559 id == NULL) { // cache doesn't contain entry |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1560 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1561 // This function can be called by the VMThread so we have to do all |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1562 // things that might block on a safepoint before grabbing the lock. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1563 // Otherwise, we can deadlock with the VMThread or have a cache |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1564 // consistency issue. These vars keep track of what we might have |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1565 // to free after the lock is dropped. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1566 jmethodID to_dealloc_id = NULL; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1567 jmethodID* to_dealloc_jmeths = NULL; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1568 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1569 // may not allocate new_jmeths or use it if we allocate it |
0 | 1570 jmethodID* new_jmeths = NULL; |
1571 if (length <= idnum) { | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1572 // allocate a new cache that might be used |
0 | 1573 size_t size = MAX2(idnum+1, (size_t)ik_h->idnum_allocated_count()); |
6197 | 1574 new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass); |
0 | 1575 memset(new_jmeths, 0, (size+1)*sizeof(jmethodID)); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1576 // cache size is stored in element[0], other elements offset by one |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1577 new_jmeths[0] = (jmethodID)size; |
0 | 1578 } |
1579 | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1580 // allocate a new jmethodID that might be used |
0 | 1581 jmethodID new_id = NULL; |
1582 if (method_h->is_old() && !method_h->is_obsolete()) { | |
1583 // The method passed in is old (but not obsolete), we need to use the current version | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1584 Method* current_method = ik_h->method_with_idnum((int)idnum); |
0 | 1585 assert(current_method != NULL, "old and but not obsolete, so should exist"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1586 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), current_method); |
0 | 1587 } else { |
1588 // It is the current version of the method or an obsolete method, | |
1589 // use the version passed in | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1590 new_id = Method::make_jmethod_id(ik_h->class_loader_data(), method_h()); |
0 | 1591 } |
1592 | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1593 if (Threads::number_of_threads() == 0 || |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1594 SafepointSynchronize::is_at_safepoint()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1595 // we're single threaded or at a safepoint - no locking needed |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1596 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1597 &to_dealloc_id, &to_dealloc_jmeths); |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1598 } else { |
0 | 1599 MutexLocker ml(JmethodIdCreation_lock); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1600 id = get_jmethod_id_fetch_or_update(ik_h, idnum, new_id, new_jmeths, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1601 &to_dealloc_id, &to_dealloc_jmeths); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1602 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1603 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1604 // The lock has been dropped so we can free resources. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1605 // Free up either the old cache or the new cache if we allocated one. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1606 if (to_dealloc_jmeths != NULL) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1607 FreeHeap(to_dealloc_jmeths); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1608 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1609 // free up the new ID since it wasn't needed |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1610 if (to_dealloc_id != NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1611 Method::destroy_jmethod_id(ik_h->class_loader_data(), to_dealloc_id); |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1612 } |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1613 } |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1614 return id; |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1615 } |
0 | 1616 |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1617 |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1618 // Common code to fetch the jmethodID from the cache or update the |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1619 // cache with the new jmethodID. This function should never do anything |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1620 // that causes the caller to go to a safepoint or we can deadlock with |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1621 // the VMThread or have cache consistency issues. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1622 // |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1623 jmethodID InstanceKlass::get_jmethod_id_fetch_or_update( |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1624 instanceKlassHandle ik_h, size_t idnum, jmethodID new_id, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1625 jmethodID* new_jmeths, jmethodID* to_dealloc_id_p, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1626 jmethodID** to_dealloc_jmeths_p) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1627 assert(new_id != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1628 assert(to_dealloc_id_p != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1629 assert(to_dealloc_jmeths_p != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1630 assert(Threads::number_of_threads() == 0 || |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1631 SafepointSynchronize::is_at_safepoint() || |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1632 JmethodIdCreation_lock->owned_by_self(), "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1633 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1634 // reacquire the cache - we are locked, single threaded or at a safepoint |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1635 jmethodID* jmeths = ik_h->methods_jmethod_ids_acquire(); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1636 jmethodID id = NULL; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1637 size_t length = 0; |
0 | 1638 |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1639 if (jmeths == NULL || // no cache yet |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1640 (length = (size_t)jmeths[0]) <= idnum) { // cache is too short |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1641 if (jmeths != NULL) { |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1642 // copy any existing entries from the old cache |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1643 for (size_t index = 0; index < length; index++) { |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1644 new_jmeths[index+1] = jmeths[index+1]; |
0 | 1645 } |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1646 *to_dealloc_jmeths_p = jmeths; // save old cache for later delete |
0 | 1647 } |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1648 ik_h->release_set_methods_jmethod_ids(jmeths = new_jmeths); |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1649 } else { |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1650 // fetch jmethodID (if any) from the existing cache |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1651 id = jmeths[idnum+1]; |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1652 *to_dealloc_jmeths_p = new_jmeths; // save new cache for later delete |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1653 } |
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1654 if (id == NULL) { |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1655 // No matching jmethodID in the existing cache or we have a new |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1656 // cache or we just grew the cache. This cache write is done here |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1657 // by the first thread to win the foot race because a jmethodID |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1658 // needs to be unique once it is generally available. |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1659 id = new_id; |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1660 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1661 // The jmethodID cache can be read while unlocked so we have to |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1662 // make sure the new jmethodID is complete before installing it |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1663 // in the cache. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1664 OrderAccess::release_store_ptr(&jmeths[idnum+1], id); |
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
47
diff
changeset
|
1665 } else { |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1666 *to_dealloc_id_p = new_id; // save new id for later delete |
0 | 1667 } |
1668 return id; | |
1669 } | |
1670 | |
1671 | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1672 // Common code to get the jmethodID cache length and the jmethodID |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1673 // value at index idnum if there is one. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1674 // |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1675 void InstanceKlass::get_jmethod_id_length_value(jmethodID* cache, |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1676 size_t idnum, size_t *length_p, jmethodID* id_p) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1677 assert(cache != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1678 assert(length_p != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1679 assert(id_p != NULL, "sanity check"); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1680 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1681 // cache size is stored in element[0], other elements offset by one |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1682 *length_p = (size_t)cache[0]; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1683 if (*length_p <= idnum) { // cache is too short |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1684 *id_p = NULL; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1685 } else { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1686 *id_p = cache[idnum+1]; // fetch jmethodID (if any) |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1687 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1688 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1689 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1690 |
0 | 1691 // Lookup a jmethodID, NULL if not found. Do no blocking, no allocations, no handles |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1692 jmethodID InstanceKlass::jmethod_id_or_null(Method* method) { |
0 | 1693 size_t idnum = (size_t)method->method_idnum(); |
1694 jmethodID* jmeths = methods_jmethod_ids_acquire(); | |
1695 size_t length; // length assigned as debugging crumb | |
1696 jmethodID id = NULL; | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1697 if (jmeths != NULL && // If there is a cache |
0 | 1698 (length = (size_t)jmeths[0]) > idnum) { // and if it is long enough, |
1699 id = jmeths[idnum+1]; // Look up the id (may be NULL) | |
1700 } | |
1701 return id; | |
1702 } | |
1703 | |
1704 | |
1705 // Cache an itable index | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1706 void InstanceKlass::set_cached_itable_index(size_t idnum, int index) { |
0 | 1707 int* indices = methods_cached_itable_indices_acquire(); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1708 int* to_dealloc_indices = NULL; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1709 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1710 // We use a double-check locking idiom here because this cache is |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1711 // performance sensitive. In the normal system, this cache only |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1712 // transitions from NULL to non-NULL which is safe because we use |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1713 // release_set_methods_cached_itable_indices() to advertise the |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1714 // new cache. A partially constructed cache should never be seen |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1715 // by a racing thread. Cache reads and writes proceed without a |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1716 // lock, but creation of the cache itself requires no leaks so a |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1717 // lock is generally acquired in that case. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1718 // |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1719 // If the RedefineClasses() API has been used, then this cache can |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1720 // grow and we'll have transitions from non-NULL to bigger non-NULL. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1721 // Cache creation requires no leaks and we require safety between all |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1722 // cache accesses and freeing of the old cache so a lock is generally |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1723 // acquired when the RedefineClasses() API has been used. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1724 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1725 if (indices == NULL || idnum_can_increment()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1726 // we need a cache or the cache can grow |
0 | 1727 MutexLocker ml(JNICachedItableIndex_lock); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1728 // reacquire the cache to see if another thread already did the work |
0 | 1729 indices = methods_cached_itable_indices_acquire(); |
1730 size_t length = 0; | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1731 // cache size is stored in element[0], other elements offset by one |
0 | 1732 if (indices == NULL || (length = (size_t)indices[0]) <= idnum) { |
1733 size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count()); | |
6197 | 1734 int* new_indices = NEW_C_HEAP_ARRAY(int, size+1, mtClass); |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1735 new_indices[0] = (int)size; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1736 // copy any existing entries |
0 | 1737 size_t i; |
1738 for (i = 0; i < length; i++) { | |
1739 new_indices[i+1] = indices[i+1]; | |
1740 } | |
1741 // Set all the rest to -1 | |
1742 for (i = length; i < size; i++) { | |
1743 new_indices[i+1] = -1; | |
1744 } | |
1745 if (indices != NULL) { | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1746 // We have an old cache to delete so save it for after we |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1747 // drop the lock. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1748 to_dealloc_indices = indices; |
0 | 1749 } |
1750 release_set_methods_cached_itable_indices(indices = new_indices); | |
1751 } | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1752 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1753 if (idnum_can_increment()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1754 // this cache can grow so we have to write to it safely |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1755 indices[idnum+1] = index; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1756 } |
0 | 1757 } else { |
1758 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); | |
1759 } | |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1760 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1761 if (!idnum_can_increment()) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1762 // The cache cannot grow and this JNI itable index value does not |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1763 // have to be unique like a jmethodID. If there is a race to set it, |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1764 // it doesn't matter. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1765 indices[idnum+1] = index; |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1766 } |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1767 |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1768 if (to_dealloc_indices != NULL) { |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1769 // we allocated a new cache so free the old one |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1770 FreeHeap(to_dealloc_indices); |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
1771 } |
0 | 1772 } |
1773 | |
1774 | |
1775 // Retrieve a cached itable index | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1776 int InstanceKlass::cached_itable_index(size_t idnum) { |
0 | 1777 int* indices = methods_cached_itable_indices_acquire(); |
1778 if (indices != NULL && ((size_t)indices[0]) > idnum) { | |
1779 // indices exist and are long enough, retrieve possible cached | |
1780 return indices[idnum+1]; | |
1781 } | |
1782 return -1; | |
1783 } | |
1784 | |
1785 | |
1786 // | |
1787 // Walk the list of dependent nmethods searching for nmethods which | |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3404
diff
changeset
|
1788 // are dependent on the changes that were passed in and mark them for |
0 | 1789 // deoptimization. Returns the number of nmethods found. |
1790 // | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1791 int InstanceKlass::mark_dependent_nmethods(DepChange& changes) { |
0 | 1792 assert_locked_or_safepoint(CodeCache_lock); |
1793 int found = 0; | |
1794 nmethodBucket* b = _dependencies; | |
1795 while (b != NULL) { | |
1796 nmethod* nm = b->get_nmethod(); | |
1797 // since dependencies aren't removed until an nmethod becomes a zombie, | |
1798 // the dependency list may contain nmethods which aren't alive. | |
1799 if (nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) { | |
1800 if (TraceDependencies) { | |
1801 ResourceMark rm; | |
1802 tty->print_cr("Marked for deoptimization"); | |
1803 tty->print_cr(" context = %s", this->external_name()); | |
1804 changes.print(); | |
1805 nm->print(); | |
1806 nm->print_dependencies(); | |
1807 } | |
1808 nm->mark_for_deoptimization(); | |
1809 found++; | |
1810 } | |
1811 b = b->next(); | |
1812 } | |
1813 return found; | |
1814 } | |
1815 | |
1816 | |
1817 // | |
1818 // Add an nmethodBucket to the list of dependencies for this nmethod. | |
1819 // It's possible that an nmethod has multiple dependencies on this klass | |
1820 // so a count is kept for each bucket to guarantee that creation and | |
1821 // deletion of dependencies is consistent. | |
1822 // | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1823 void InstanceKlass::add_dependent_nmethod(nmethod* nm) { |
0 | 1824 assert_locked_or_safepoint(CodeCache_lock); |
1825 nmethodBucket* b = _dependencies; | |
1826 nmethodBucket* last = NULL; | |
1827 while (b != NULL) { | |
1828 if (nm == b->get_nmethod()) { | |
1829 b->increment(); | |
1830 return; | |
1831 } | |
1832 b = b->next(); | |
1833 } | |
1834 _dependencies = new nmethodBucket(nm, _dependencies); | |
1835 } | |
1836 | |
1837 | |
1838 // | |
1839 // Decrement count of the nmethod in the dependency list and remove | |
1840 // the bucket competely when the count goes to 0. This method must | |
1841 // find a corresponding bucket otherwise there's a bug in the | |
1842 // recording of dependecies. | |
1843 // | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1844 void InstanceKlass::remove_dependent_nmethod(nmethod* nm) { |
0 | 1845 assert_locked_or_safepoint(CodeCache_lock); |
1846 nmethodBucket* b = _dependencies; | |
1847 nmethodBucket* last = NULL; | |
1848 while (b != NULL) { | |
1849 if (nm == b->get_nmethod()) { | |
1850 if (b->decrement() == 0) { | |
1851 if (last == NULL) { | |
1852 _dependencies = b->next(); | |
1853 } else { | |
1854 last->set_next(b->next()); | |
1855 } | |
1856 delete b; | |
1857 } | |
1858 return; | |
1859 } | |
1860 last = b; | |
1861 b = b->next(); | |
1862 } | |
1863 #ifdef ASSERT | |
1864 tty->print_cr("### %s can't find dependent nmethod:", this->external_name()); | |
1865 nm->print(); | |
1866 #endif // ASSERT | |
1867 ShouldNotReachHere(); | |
1868 } | |
1869 | |
1870 | |
1871 #ifndef PRODUCT | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1872 void InstanceKlass::print_dependent_nmethods(bool verbose) { |
0 | 1873 nmethodBucket* b = _dependencies; |
1874 int idx = 0; | |
1875 while (b != NULL) { | |
1876 nmethod* nm = b->get_nmethod(); | |
1877 tty->print("[%d] count=%d { ", idx++, b->count()); | |
1878 if (!verbose) { | |
1879 nm->print_on(tty, "nmethod"); | |
1880 tty->print_cr(" } "); | |
1881 } else { | |
1882 nm->print(); | |
1883 nm->print_dependencies(); | |
1884 tty->print_cr("--- } "); | |
1885 } | |
1886 b = b->next(); | |
1887 } | |
1888 } | |
1889 | |
1890 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1891 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) { |
0 | 1892 nmethodBucket* b = _dependencies; |
1893 while (b != NULL) { | |
1894 if (nm == b->get_nmethod()) { | |
1895 return true; | |
1896 } | |
1897 b = b->next(); | |
1898 } | |
1899 return false; | |
1900 } | |
1901 #endif //PRODUCT | |
1902 | |
1903 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1904 // Garbage collection |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1905 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1906 void InstanceKlass::oops_do(OopClosure* cl) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1907 Klass::oops_do(cl); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1908 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1909 cl->do_oop(adr_protection_domain()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1910 cl->do_oop(adr_signers()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1911 cl->do_oop(adr_init_lock()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1912 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1913 // Don't walk the arrays since they are walked from the ClassLoaderData objects. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1914 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1915 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1916 #ifdef ASSERT |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1917 template <class T> void assert_is_in(T *p) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1918 T heap_oop = oopDesc::load_heap_oop(p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1919 if (!oopDesc::is_null(heap_oop)) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1920 oop o = oopDesc::decode_heap_oop_not_null(heap_oop); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1921 assert(Universe::heap()->is_in(o), "should be in heap"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1922 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1923 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1924 template <class T> void assert_is_in_closed_subset(T *p) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1925 T heap_oop = oopDesc::load_heap_oop(p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1926 if (!oopDesc::is_null(heap_oop)) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1927 oop o = oopDesc::decode_heap_oop_not_null(heap_oop); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1928 assert(Universe::heap()->is_in_closed_subset(o), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
1929 err_msg("should be in closed *p " INTPTR_FORMAT " " INTPTR_FORMAT, (address)p, (address)o)); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1930 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1931 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1932 template <class T> void assert_is_in_reserved(T *p) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1933 T heap_oop = oopDesc::load_heap_oop(p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1934 if (!oopDesc::is_null(heap_oop)) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1935 oop o = oopDesc::decode_heap_oop_not_null(heap_oop); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1936 assert(Universe::heap()->is_in_reserved(o), "should be in reserved"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1937 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1938 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1939 template <class T> void assert_nothing(T *p) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1940 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1941 #else |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1942 template <class T> void assert_is_in(T *p) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1943 template <class T> void assert_is_in_closed_subset(T *p) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1944 template <class T> void assert_is_in_reserved(T *p) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1945 template <class T> void assert_nothing(T *p) {} |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1946 #endif // ASSERT |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1947 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1948 // |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1949 // Macros that iterate over areas of oops which are specialized on type of |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1950 // oop pointer either narrow or wide, depending on UseCompressedOops |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1951 // |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1952 // Parameters are: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1953 // T - type of oop to point to (either oop or narrowOop) |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1954 // start_p - starting pointer for region to iterate over |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1955 // count - number of oops or narrowOops to iterate over |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1956 // do_oop - action to perform on each oop (it's arbitrary C code which |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1957 // makes it more efficient to put in a macro rather than making |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1958 // it a template function) |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1959 // assert_fn - assert function which is template function because performance |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1960 // doesn't matter when enabled. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1961 #define InstanceKlass_SPECIALIZED_OOP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1962 T, start_p, count, do_oop, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1963 assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1964 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1965 T* p = (T*)(start_p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1966 T* const end = p + (count); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1967 while (p < end) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1968 (assert_fn)(p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1969 do_oop; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1970 ++p; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1971 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1972 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1973 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1974 #define InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1975 T, start_p, count, do_oop, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1976 assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1977 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1978 T* const start = (T*)(start_p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1979 T* p = start + (count); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1980 while (start < p) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1981 --p; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1982 (assert_fn)(p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1983 do_oop; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1984 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1985 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1986 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1987 #define InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1988 T, start_p, count, low, high, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1989 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1990 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1991 T* const l = (T*)(low); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1992 T* const h = (T*)(high); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1993 assert(mask_bits((intptr_t)l, sizeof(T)-1) == 0 && \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1994 mask_bits((intptr_t)h, sizeof(T)-1) == 0, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1995 "bounded region must be properly aligned"); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1996 T* p = (T*)(start_p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1997 T* end = p + (count); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1998 if (p < l) p = l; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
1999 if (end > h) end = h; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2000 while (p < end) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2001 (assert_fn)(p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2002 do_oop; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2003 ++p; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2004 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2005 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2006 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2007 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2008 // The following macros call specialized macros, passing either oop or |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2009 // narrowOop as the specialization type. These test the UseCompressedOops |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2010 // flag. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2011 #define InstanceKlass_OOP_MAP_ITERATE(obj, do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2012 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2013 /* Compute oopmap block range. The common case \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2014 is nonstatic_oop_map_size == 1. */ \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2015 OopMapBlock* map = start_of_nonstatic_oop_maps(); \ |
938 | 2016 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2017 if (UseCompressedOops) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2018 while (map < end_map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2019 InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \ |
938 | 2020 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2021 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2022 ++map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2023 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2024 } else { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2025 while (map < end_map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2026 InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \ |
938 | 2027 obj->obj_field_addr<oop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2028 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2029 ++map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2030 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2031 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2032 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2033 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2034 #define InstanceKlass_OOP_MAP_REVERSE_ITERATE(obj, do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2035 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2036 OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \ |
938 | 2037 OopMapBlock* map = start_map + nonstatic_oop_map_count(); \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2038 if (UseCompressedOops) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2039 while (start_map < map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2040 --map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2041 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \ |
938 | 2042 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2043 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2044 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2045 } else { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2046 while (start_map < map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2047 --map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2048 InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \ |
938 | 2049 obj->obj_field_addr<oop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2050 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2051 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2052 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2053 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2054 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2055 #define InstanceKlass_BOUNDED_OOP_MAP_ITERATE(obj, low, high, do_oop, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2056 assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2057 { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2058 /* Compute oopmap block range. The common case is \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2059 nonstatic_oop_map_size == 1, so we accept the \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2060 usually non-existent extra overhead of examining \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2061 all the maps. */ \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2062 OopMapBlock* map = start_of_nonstatic_oop_maps(); \ |
938 | 2063 OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2064 if (UseCompressedOops) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2065 while (map < end_map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2066 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \ |
938 | 2067 obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2068 low, high, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2069 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2070 ++map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2071 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2072 } else { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2073 while (map < end_map) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2074 InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \ |
938 | 2075 obj->obj_field_addr<oop>(map->offset()), map->count(), \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2076 low, high, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2077 do_oop, assert_fn) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2078 ++map; \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2079 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2080 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2081 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2082 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2083 void InstanceKlass::oop_follow_contents(oop obj) { |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2084 assert(obj != NULL, "can't follow the content of NULL object"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2085 MarkSweep::follow_klass(obj->klass()); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2086 InstanceKlass_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2087 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2088 MarkSweep::mark_and_push(p), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2089 assert_is_in_closed_subset) |
0 | 2090 } |
2091 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2092 #if INCLUDE_ALL_GCS |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2093 void InstanceKlass::oop_follow_contents(ParCompactionManager* cm, |
0 | 2094 oop obj) { |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2095 assert(obj != NULL, "can't follow the content of NULL object"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2096 PSParallelCompact::follow_klass(cm, obj->klass()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2097 // Only mark the header and let the scan of the meta-data mark |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2098 // everything else. |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2099 InstanceKlass_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2100 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2101 PSParallelCompact::mark_and_push(cm, p), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2102 assert_is_in) |
0 | 2103 } |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2104 #endif // INCLUDE_ALL_GCS |
0 | 2105 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2106 // closure's do_metadata() method dictates whether the given closure should be |
0 | 2107 // applied to the klass ptr in the object header. |
2108 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2109 #define if_do_metadata_checked(closure, nv_suffix) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2110 /* Make sure the non-virtual and the virtual versions match. */ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2111 assert(closure->do_metadata##nv_suffix() == closure->do_metadata(), \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2112 "Inconsistency in do_metadata"); \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2113 if (closure->do_metadata##nv_suffix()) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2114 |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2115 #define InstanceKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2116 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2117 int InstanceKlass::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2118 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2119 /* header */ \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2120 if_do_metadata_checked(closure, nv_suffix) { \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2121 closure->do_klass##nv_suffix(obj->klass()); \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2122 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2123 InstanceKlass_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2124 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2125 SpecializationStats:: \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2126 record_do_oop_call##nv_suffix(SpecializationStats::ik); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2127 (closure)->do_oop##nv_suffix(p), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2128 assert_is_in_closed_subset) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2129 return size_helper(); \ |
0 | 2130 } |
2131 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2132 #if INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2133 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2134 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2135 int InstanceKlass::oop_oop_iterate_backwards##nv_suffix(oop obj, \ |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2136 OopClosureType* closure) { \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2137 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik); \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2138 /* header */ \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2139 if_do_metadata_checked(closure, nv_suffix) { \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2140 closure->do_klass##nv_suffix(obj->klass()); \ |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2141 } \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2142 /* instance variables */ \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2143 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2144 obj, \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2145 SpecializationStats::record_do_oop_call##nv_suffix(SpecializationStats::ik);\ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2146 (closure)->do_oop##nv_suffix(p), \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2147 assert_is_in_closed_subset) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2148 return size_helper(); \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2149 } |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2150 #endif // INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2151 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2152 #define InstanceKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2153 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2154 int InstanceKlass::oop_oop_iterate##nv_suffix##_m(oop obj, \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2155 OopClosureType* closure, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2156 MemRegion mr) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2157 SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::ik);\ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2158 if_do_metadata_checked(closure, nv_suffix) { \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2159 if (mr.contains(obj)) { \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2160 closure->do_klass##nv_suffix(obj->klass()); \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2161 } \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2162 } \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2163 InstanceKlass_BOUNDED_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2164 obj, mr.start(), mr.end(), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2165 (closure)->do_oop##nv_suffix(p), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2166 assert_is_in_closed_subset) \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2167 return size_helper(); \ |
0 | 2168 } |
2169 | |
2170 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN) | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2171 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN) |
0 | 2172 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN_m) |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2173 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN_m) |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2174 #if INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2175 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
2176 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN) |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2177 #endif // INCLUDE_ALL_GCS |
0 | 2178 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2179 int InstanceKlass::oop_adjust_pointers(oop obj) { |
0 | 2180 int size = size_helper(); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2181 InstanceKlass_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2182 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2183 MarkSweep::adjust_pointer(p), \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2184 assert_is_in) |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2185 MarkSweep::adjust_klass(obj->klass()); |
0 | 2186 return size; |
2187 } | |
2188 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2189 #if INCLUDE_ALL_GCS |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2190 void InstanceKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2191 InstanceKlass_OOP_MAP_REVERSE_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2192 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2193 if (PSScavenge::should_scavenge(p)) { \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2194 pm->claim_or_forward_depth(p); \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2195 }, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2196 assert_nothing ) |
0 | 2197 } |
2198 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2199 int InstanceKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2200 int size = size_helper(); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2201 InstanceKlass_OOP_MAP_ITERATE( \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2202 obj, \ |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
2203 PSParallelCompact::adjust_pointer(p), \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2204 assert_is_in) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2205 obj->update_header(cm); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2206 return size; |
0 | 2207 } |
2208 | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7610
diff
changeset
|
2209 #endif // INCLUDE_ALL_GCS |
0 | 2210 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2211 void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2212 assert(is_loader_alive(is_alive), "this klass should be live"); |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
2213 if (is_interface()) { |
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
2214 if (ClassUnloading) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2215 Klass* impl = implementor(); |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
2216 if (impl != NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2217 if (!impl->is_loader_alive(is_alive)) { |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
2218 // remove this guy |
8693
872b3feace55
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
8031
diff
changeset
|
2219 Klass** klass = adr_implementor(); |
872b3feace55
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
8031
diff
changeset
|
2220 assert(klass != NULL, "null klass"); |
872b3feace55
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
8031
diff
changeset
|
2221 if (klass != NULL) { |
872b3feace55
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
8031
diff
changeset
|
2222 *klass = NULL; |
872b3feace55
8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp
morris
parents:
8031
diff
changeset
|
2223 } |
5998
49036505ab5f
7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass.
jiangli
parents:
5969
diff
changeset
|
2224 } |
0 | 2225 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2226 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2227 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2228 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2229 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2230 void InstanceKlass::clean_method_data(BoolObjectClosure* is_alive) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2231 for (int m = 0; m < methods()->length(); m++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2232 MethodData* mdo = methods()->at(m)->method_data(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2233 if (mdo != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2234 for (ProfileData* data = mdo->first_data(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2235 mdo->is_valid(data); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2236 data = mdo->next_data(data)) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2237 data->clean_weak_klass_links(is_alive); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2238 } |
0 | 2239 } |
2240 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2241 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2242 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2243 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2244 static void remove_unshareable_in_class(Klass* k) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2245 // remove klass's unshareable info |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2246 k->remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2247 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2248 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2249 void InstanceKlass::remove_unshareable_info() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2250 Klass::remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2251 // Unlink the class |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2252 if (is_linked()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2253 unlink_class(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2254 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2255 init_implementor(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2256 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2257 constants()->remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2258 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2259 for (int i = 0; i < methods()->length(); i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2260 Method* m = methods()->at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2261 m->remove_unshareable_info(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2262 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2263 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2264 // Need to reinstate when reading back the class. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2265 set_init_lock(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2266 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2267 // do array classes also. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2268 array_klasses_do(remove_unshareable_in_class); |
0 | 2269 } |
2270 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2271 void restore_unshareable_in_class(Klass* k, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2272 k->restore_unshareable_info(CHECK); |
0 | 2273 } |
2274 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2275 void InstanceKlass::restore_unshareable_info(TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2276 Klass::restore_unshareable_info(CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2277 instanceKlassHandle ik(THREAD, this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2278 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2279 Array<Method*>* methods = ik->methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2280 int num_methods = methods->length(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2281 for (int index2 = 0; index2 < num_methods; ++index2) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2282 methodHandle m(THREAD, methods->at(index2)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2283 m()->link_method(m, CHECK); |
6733
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
2284 // restore method's vtable by calling a virtual function |
fa6e618671d7
7195867: NPG: SAJDI tests fail with sun.jvm.hotspot.types.WrongTypeException: No suitable match for type
coleenp
parents:
6725
diff
changeset
|
2285 m->restore_vtable(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2286 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2287 if (JvmtiExport::has_redefined_a_class()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2288 // Reinitialize vtable because RedefineClasses may have changed some |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2289 // entries in this vtable for super classes so the CDS vtable might |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2290 // point to old or obsolete entries. RedefineClasses doesn't fix up |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2291 // vtables in the shared system dictionary, only the main one. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2292 // It also redefines the itable too so fix that too. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2293 ResourceMark rm(THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2294 ik->vtable()->initialize_vtable(false, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2295 ik->itable()->initialize_itable(false, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2296 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2297 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2298 // Allocate a simple java object for a lock. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2299 // This needs to be a java object because during class initialization |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2300 // it can be held across a java call. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2301 typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2302 Handle h(THREAD, (oop)r); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2303 ik->set_init_lock(h()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2304 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2305 // restore constant pool resolved references |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2306 ik->constants()->restore_unshareable_info(CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2307 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2308 ik->array_klasses_do(restore_unshareable_in_class, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2309 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2310 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2311 static void clear_all_breakpoints(Method* m) { |
0 | 2312 m->clear_all_breakpoints(); |
2313 } | |
2314 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2315 void InstanceKlass::release_C_heap_structures() { |
0 | 2316 // Deallocate oop map cache |
2317 if (_oop_map_cache != NULL) { | |
2318 delete _oop_map_cache; | |
2319 _oop_map_cache = NULL; | |
2320 } | |
2321 | |
2322 // Deallocate JNI identifiers for jfieldIDs | |
2323 JNIid::deallocate(jni_ids()); | |
2324 set_jni_ids(NULL); | |
2325 | |
2326 jmethodID* jmeths = methods_jmethod_ids_acquire(); | |
2327 if (jmeths != (jmethodID*)NULL) { | |
2328 release_set_methods_jmethod_ids(NULL); | |
2329 FreeHeap(jmeths); | |
2330 } | |
2331 | |
2332 int* indices = methods_cached_itable_indices_acquire(); | |
2333 if (indices != (int*)NULL) { | |
2334 release_set_methods_cached_itable_indices(NULL); | |
2335 FreeHeap(indices); | |
2336 } | |
2337 | |
2338 // release dependencies | |
2339 nmethodBucket* b = _dependencies; | |
2340 _dependencies = NULL; | |
2341 while (b != NULL) { | |
2342 nmethodBucket* next = b->next(); | |
2343 delete b; | |
2344 b = next; | |
2345 } | |
2346 | |
2347 // Deallocate breakpoint records | |
2348 if (breakpoints() != 0x0) { | |
2349 methods_do(clear_all_breakpoints); | |
2350 assert(breakpoints() == 0x0, "should have cleared breakpoints"); | |
2351 } | |
2352 | |
2353 // deallocate information about previous versions | |
2354 if (_previous_versions != NULL) { | |
2355 for (int i = _previous_versions->length() - 1; i >= 0; i--) { | |
2356 PreviousVersionNode * pv_node = _previous_versions->at(i); | |
2357 delete pv_node; | |
2358 } | |
2359 delete _previous_versions; | |
2360 _previous_versions = NULL; | |
2361 } | |
2362 | |
2363 // deallocate the cached class file | |
2364 if (_cached_class_file_bytes != NULL) { | |
6197 | 2365 os::free(_cached_class_file_bytes, mtClass); |
0 | 2366 _cached_class_file_bytes = NULL; |
2367 _cached_class_file_len = 0; | |
2368 } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2369 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2370 // Decrement symbol reference counts associated with the unloaded class. |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2371 if (_name != NULL) _name->decrement_refcount(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2372 // unreference array name derived from this class name (arrays of an unloaded |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2373 // class can't be referenced anymore). |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2374 if (_array_name != NULL) _array_name->decrement_refcount(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2375 if (_source_file_name != NULL) _source_file_name->decrement_refcount(); |
6203
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2376 if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension, mtClass); |
7464
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
2377 |
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
2378 assert(_total_instanceKlass_count >= 1, "Sanity check"); |
ecd24264898b
8005048: NMT: #loaded classes needs to just show the # defined classes
zgu
parents:
7180
diff
changeset
|
2379 Atomic::dec(&_total_instanceKlass_count); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2380 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2381 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2382 void InstanceKlass::set_source_file_name(Symbol* n) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2383 _source_file_name = n; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2384 if (_source_file_name != NULL) _source_file_name->increment_refcount(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2385 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2386 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2387 void InstanceKlass::set_source_debug_extension(char* array, int length) { |
6203
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2388 if (array == NULL) { |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2389 _source_debug_extension = NULL; |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2390 } else { |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2391 // Adding one to the attribute length in order to store a null terminator |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2392 // character could cause an overflow because the attribute length is |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2393 // already coded with an u4 in the classfile, but in practice, it's |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2394 // unlikely to happen. |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2395 assert((length+1) > length, "Overflow checking"); |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2396 char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass); |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2397 for (int i = 0; i < length; i++) { |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2398 sde[i] = array[i]; |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2399 } |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2400 sde[length] = '\0'; |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2401 _source_debug_extension = sde; |
04ade88d9712
6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K
fparain
parents:
6197
diff
changeset
|
2402 } |
0 | 2403 } |
2404 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2405 address InstanceKlass::static_field_addr(int offset) { |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
2406 return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror()); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2407 } |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2408 |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2409 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2410 const char* InstanceKlass::signature_name() const { |
0 | 2411 const char* src = (const char*) (name()->as_C_string()); |
2412 const int src_length = (int)strlen(src); | |
2413 char* dest = NEW_RESOURCE_ARRAY(char, src_length + 3); | |
2414 int src_index = 0; | |
2415 int dest_index = 0; | |
2416 dest[dest_index++] = 'L'; | |
2417 while (src_index < src_length) { | |
2418 dest[dest_index++] = src[src_index++]; | |
2419 } | |
2420 dest[dest_index++] = ';'; | |
2421 dest[dest_index] = '\0'; | |
2422 return dest; | |
2423 } | |
2424 | |
2425 // different verisons of is_same_class_package | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2426 bool InstanceKlass::is_same_class_package(Klass* class2) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2427 Klass* class1 = this; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2428 oop classloader1 = InstanceKlass::cast(class1)->class_loader(); |
6983 | 2429 Symbol* classname1 = class1->name(); |
2430 | |
2431 if (class2->oop_is_objArray()) { | |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6735
diff
changeset
|
2432 class2 = ObjArrayKlass::cast(class2)->bottom_klass(); |
0 | 2433 } |
2434 oop classloader2; | |
6983 | 2435 if (class2->oop_is_instance()) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2436 classloader2 = InstanceKlass::cast(class2)->class_loader(); |
0 | 2437 } else { |
6983 | 2438 assert(class2->oop_is_typeArray(), "should be type array"); |
0 | 2439 classloader2 = NULL; |
2440 } | |
6983 | 2441 Symbol* classname2 = class2->name(); |
0 | 2442 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2443 return InstanceKlass::is_same_class_package(classloader1, classname1, |
0 | 2444 classloader2, classname2); |
2445 } | |
2446 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2447 bool InstanceKlass::is_same_class_package(oop classloader2, Symbol* classname2) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2448 Klass* class1 = this; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2449 oop classloader1 = InstanceKlass::cast(class1)->class_loader(); |
6983 | 2450 Symbol* classname1 = class1->name(); |
0 | 2451 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2452 return InstanceKlass::is_same_class_package(classloader1, classname1, |
0 | 2453 classloader2, classname2); |
2454 } | |
2455 | |
2456 // return true if two classes are in the same package, classloader | |
2457 // and classname information is enough to determine a class's package | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2458 bool InstanceKlass::is_same_class_package(oop class_loader1, Symbol* class_name1, |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2459 oop class_loader2, Symbol* class_name2) { |
0 | 2460 if (class_loader1 != class_loader2) { |
2461 return false; | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2462 } else if (class_name1 == class_name2) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2463 return true; // skip painful bytewise comparison |
0 | 2464 } else { |
2465 ResourceMark rm; | |
2466 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2467 // The Symbol*'s are in UTF8 encoding. Since we only need to check explicitly |
0 | 2468 // for ASCII characters ('/', 'L', '['), we can keep them in UTF8 encoding. |
2469 // Otherwise, we just compare jbyte values between the strings. | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2470 const jbyte *name1 = class_name1->base(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2471 const jbyte *name2 = class_name2->base(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2472 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2473 const jbyte *last_slash1 = UTF8::strrchr(name1, class_name1->utf8_length(), '/'); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2474 const jbyte *last_slash2 = UTF8::strrchr(name2, class_name2->utf8_length(), '/'); |
0 | 2475 |
2476 if ((last_slash1 == NULL) || (last_slash2 == NULL)) { | |
2477 // One of the two doesn't have a package. Only return true | |
2478 // if the other one also doesn't have a package. | |
2479 return last_slash1 == last_slash2; | |
2480 } else { | |
2481 // Skip over '['s | |
2482 if (*name1 == '[') { | |
2483 do { | |
2484 name1++; | |
2485 } while (*name1 == '['); | |
2486 if (*name1 != 'L') { | |
2487 // Something is terribly wrong. Shouldn't be here. | |
2488 return false; | |
2489 } | |
2490 } | |
2491 if (*name2 == '[') { | |
2492 do { | |
2493 name2++; | |
2494 } while (*name2 == '['); | |
2495 if (*name2 != 'L') { | |
2496 // Something is terribly wrong. Shouldn't be here. | |
2497 return false; | |
2498 } | |
2499 } | |
2500 | |
2501 // Check that package part is identical | |
2502 int length1 = last_slash1 - name1; | |
2503 int length2 = last_slash2 - name2; | |
2504 | |
2505 return UTF8::equal(name1, length1, name2, length2); | |
2506 } | |
2507 } | |
2508 } | |
2509 | |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2510 // Returns true iff super_method can be overridden by a method in targetclassname |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2511 // See JSL 3rd edition 8.4.6.1 |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2512 // Assumes name-signature match |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2513 // "this" is InstanceKlass of super_method which must exist |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2514 // note that the InstanceKlass of the method in the targetclassname has not always been created yet |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2515 bool InstanceKlass::is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) { |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2516 // Private methods can not be overridden |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2517 if (super_method->is_private()) { |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2518 return false; |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2519 } |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2520 // If super method is accessible, then override |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2521 if ((super_method->is_protected()) || |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2522 (super_method->is_public())) { |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2523 return true; |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2524 } |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2525 // Package-private methods are not inherited outside of package |
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2526 assert(super_method->is_package_private(), "must be package private"); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2527 return(is_same_class_package(targetclassloader(), targetclassname)); |
652
4aaa9f5e02a8
4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242.
acorn
parents:
605
diff
changeset
|
2528 } |
0 | 2529 |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2530 /* defined for now in jvm.cpp, for historical reasons *-- |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2531 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle self, |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
2532 Symbol*& simple_name_result, TRAPS) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2533 ... |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2534 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2535 */ |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2536 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2537 // tell if two classes have the same enclosing class (at package level) |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2538 bool InstanceKlass::is_same_package_member_impl(instanceKlassHandle class1, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2539 Klass* class2_oop, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2540 if (class2_oop == class1()) return true; |
6983 | 2541 if (!class2_oop->oop_is_instance()) return false; |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2542 instanceKlassHandle class2(THREAD, class2_oop); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2543 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2544 // must be in same package before we try anything else |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2545 if (!class1->is_same_class_package(class2->class_loader(), class2->name())) |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2546 return false; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2547 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2548 // As long as there is an outer1.getEnclosingClass, |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2549 // shift the search outward. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2550 instanceKlassHandle outer1 = class1; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2551 for (;;) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2552 // As we walk along, look for equalities between outer1 and class2. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2553 // Eventually, the walks will terminate as outer1 stops |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2554 // at the top-level class around the original class. |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
2555 bool ignore_inner_is_member; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2556 Klass* next = outer1->compute_enclosing_class(&ignore_inner_is_member, |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
2557 CHECK_false); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2558 if (next == NULL) break; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2559 if (next == class2()) return true; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2560 outer1 = instanceKlassHandle(THREAD, next); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2561 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2562 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2563 // Now do the same for class2. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2564 instanceKlassHandle outer2 = class2; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2565 for (;;) { |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
2566 bool ignore_inner_is_member; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2567 Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member, |
1126
933a3e806ce6
6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build
xlu
parents:
1039
diff
changeset
|
2568 CHECK_false); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2569 if (next == NULL) break; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2570 // Might as well check the new outer against all available values. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2571 if (next == class1()) return true; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2572 if (next == outer1()) return true; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2573 outer2 = instanceKlassHandle(THREAD, next); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2574 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2575 |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2576 // If by this point we have not found an equality between the |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2577 // two classes, we know they are in separate package members. |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2578 return false; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2579 } |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2580 |
0 | 2581 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2582 jint InstanceKlass::compute_modifier_flags(TRAPS) const { |
0 | 2583 jint access = access_flags().as_int(); |
2584 | |
2585 // But check if it happens to be member class. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2586 instanceKlassHandle ik(THREAD, this); |
5967
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2587 InnerClassesIterator iter(ik); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2588 for (; !iter.done(); iter.next()) { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2589 int ioff = iter.inner_class_info_index(); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2590 // Inner class attribute can be zero, skip it. |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2591 // Strange but true: JVM spec. allows null inner class refs. |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2592 if (ioff == 0) continue; |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2593 |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2594 // only look at classes that are already loaded |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2595 // since we are looking for the flags for our self. |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2596 Symbol* inner_name = ik->constants()->klass_name_at(ioff); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2597 if ((ik->name() == inner_name)) { |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2598 // This is really a member class. |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2599 access = iter.inner_access_flags(); |
f7c4174b33ba
7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field.
jiangli
parents:
4739
diff
changeset
|
2600 break; |
0 | 2601 } |
2602 } | |
2603 // Remember to strip ACC_SUPER bit | |
2604 return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS; | |
2605 } | |
2606 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2607 jint InstanceKlass::jvmti_class_status() const { |
0 | 2608 jint result = 0; |
2609 | |
2610 if (is_linked()) { | |
2611 result |= JVMTI_CLASS_STATUS_VERIFIED | JVMTI_CLASS_STATUS_PREPARED; | |
2612 } | |
2613 | |
2614 if (is_initialized()) { | |
2615 assert(is_linked(), "Class status is not consistent"); | |
2616 result |= JVMTI_CLASS_STATUS_INITIALIZED; | |
2617 } | |
2618 if (is_in_error_state()) { | |
2619 result |= JVMTI_CLASS_STATUS_ERROR; | |
2620 } | |
2621 return result; | |
2622 } | |
2623 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2624 Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) { |
0 | 2625 itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable(); |
2626 int method_table_offset_in_words = ioe->offset()/wordSize; | |
2627 int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words()) | |
2628 / itableOffsetEntry::size(); | |
2629 | |
2630 for (int cnt = 0 ; ; cnt ++, ioe ++) { | |
605 | 2631 // If the interface isn't implemented by the receiver class, |
0 | 2632 // the VM should throw IncompatibleClassChangeError. |
2633 if (cnt >= nof_interfaces) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2634 THROW_NULL(vmSymbols::java_lang_IncompatibleClassChangeError()); |
0 | 2635 } |
2636 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2637 Klass* ik = ioe->interface_klass(); |
0 | 2638 if (ik == holder) break; |
2639 } | |
2640 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2641 itableMethodEntry* ime = ioe->first_method_entry(this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2642 Method* m = ime[index].method(); |
0 | 2643 if (m == NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2644 THROW_NULL(vmSymbols::java_lang_AbstractMethodError()); |
0 | 2645 } |
2646 return m; | |
2647 } | |
2648 | |
2649 // On-stack replacement stuff | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2650 void InstanceKlass::add_osr_nmethod(nmethod* n) { |
0 | 2651 // only one compilation can be active |
2652 NEEDS_CLEANUP | |
2653 // This is a short non-blocking critical region, so the no safepoint check is ok. | |
2654 OsrList_lock->lock_without_safepoint_check(); | |
2655 assert(n->is_osr_method(), "wrong kind of nmethod"); | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
876
diff
changeset
|
2656 n->set_osr_link(osr_nmethods_head()); |
0 | 2657 set_osr_nmethods_head(n); |
1783 | 2658 // Raise the highest osr level if necessary |
2659 if (TieredCompilation) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2660 Method* m = n->method(); |
1783 | 2661 m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level())); |
2662 } | |
0 | 2663 // Remember to unlock again |
2664 OsrList_lock->unlock(); | |
1783 | 2665 |
2666 // Get rid of the osr methods for the same bci that have lower levels. | |
2667 if (TieredCompilation) { | |
2668 for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) { | |
2669 nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true); | |
2670 if (inv != NULL && inv->is_in_use()) { | |
2671 inv->make_not_entrant(); | |
2672 } | |
2673 } | |
2674 } | |
0 | 2675 } |
2676 | |
2677 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2678 void InstanceKlass::remove_osr_nmethod(nmethod* n) { |
0 | 2679 // This is a short non-blocking critical region, so the no safepoint check is ok. |
2680 OsrList_lock->lock_without_safepoint_check(); | |
2681 assert(n->is_osr_method(), "wrong kind of nmethod"); | |
2682 nmethod* last = NULL; | |
2683 nmethod* cur = osr_nmethods_head(); | |
1783 | 2684 int max_level = CompLevel_none; // Find the max comp level excluding n |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2685 Method* m = n->method(); |
0 | 2686 // Search for match |
2687 while(cur != NULL && cur != n) { | |
1783 | 2688 if (TieredCompilation) { |
2689 // Find max level before n | |
2690 max_level = MAX2(max_level, cur->comp_level()); | |
2691 } | |
0 | 2692 last = cur; |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
876
diff
changeset
|
2693 cur = cur->osr_link(); |
0 | 2694 } |
1783 | 2695 nmethod* next = NULL; |
0 | 2696 if (cur == n) { |
1783 | 2697 next = cur->osr_link(); |
0 | 2698 if (last == NULL) { |
2699 // Remove first element | |
1783 | 2700 set_osr_nmethods_head(next); |
0 | 2701 } else { |
1783 | 2702 last->set_osr_link(next); |
0 | 2703 } |
2704 } | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
876
diff
changeset
|
2705 n->set_osr_link(NULL); |
1783 | 2706 if (TieredCompilation) { |
2707 cur = next; | |
2708 while (cur != NULL) { | |
2709 // Find max level after n | |
2710 max_level = MAX2(max_level, cur->comp_level()); | |
2711 cur = cur->osr_link(); | |
2712 } | |
2713 m->set_highest_osr_comp_level(max_level); | |
2714 } | |
0 | 2715 // Remember to unlock again |
2716 OsrList_lock->unlock(); | |
2717 } | |
2718 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2719 nmethod* InstanceKlass::lookup_osr_nmethod(Method* const m, int bci, int comp_level, bool match_level) const { |
0 | 2720 // This is a short non-blocking critical region, so the no safepoint check is ok. |
2721 OsrList_lock->lock_without_safepoint_check(); | |
2722 nmethod* osr = osr_nmethods_head(); | |
1783 | 2723 nmethod* best = NULL; |
0 | 2724 while (osr != NULL) { |
2725 assert(osr->is_osr_method(), "wrong kind of nmethod found in chain"); | |
1783 | 2726 // There can be a time when a c1 osr method exists but we are waiting |
2727 // for a c2 version. When c2 completes its osr nmethod we will trash | |
2728 // the c1 version and only be able to find the c2 version. However | |
2729 // while we overflow in the c1 code at back branches we don't want to | |
2730 // try and switch to the same code as we are already running | |
2731 | |
0 | 2732 if (osr->method() == m && |
2733 (bci == InvocationEntryBci || osr->osr_entry_bci() == bci)) { | |
1783 | 2734 if (match_level) { |
2735 if (osr->comp_level() == comp_level) { | |
2736 // Found a match - return it. | |
2737 OsrList_lock->unlock(); | |
2738 return osr; | |
2739 } | |
2740 } else { | |
2741 if (best == NULL || (osr->comp_level() > best->comp_level())) { | |
2742 if (osr->comp_level() == CompLevel_highest_tier) { | |
2743 // Found the best possible - return it. | |
2744 OsrList_lock->unlock(); | |
2745 return osr; | |
2746 } | |
2747 best = osr; | |
2748 } | |
2749 } | |
0 | 2750 } |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
876
diff
changeset
|
2751 osr = osr->osr_link(); |
0 | 2752 } |
2753 OsrList_lock->unlock(); | |
1783 | 2754 if (best != NULL && best->comp_level() >= comp_level && match_level == false) { |
2755 return best; | |
2756 } | |
0 | 2757 return NULL; |
2758 } | |
2759 | |
2760 // ----------------------------------------------------------------------------------------------------- | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2761 // Printing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2762 |
0 | 2763 #ifndef PRODUCT |
2764 | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2765 #define BULLET " - " |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2766 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2767 static const char* state_names[] = { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2768 "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2769 }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2770 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2771 void InstanceKlass::print_on(outputStream* st) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2772 assert(is_klass(), "must be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2773 Klass::print_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2774 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2775 st->print(BULLET"instance size: %d", size_helper()); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2776 st->print(BULLET"klass size: %d", size()); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2777 st->print(BULLET"access: "); access_flags().print_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2778 st->print(BULLET"state: "); st->print_cr(state_names[_init_state]); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2779 st->print(BULLET"name: "); name()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2780 st->print(BULLET"super: "); super()->print_value_on_maybe_null(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2781 st->print(BULLET"sub: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2782 Klass* sub = subklass(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2783 int n; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2784 for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2785 if (n < MaxSubklassPrintSize) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2786 sub->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2787 st->print(" "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2788 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2789 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2790 if (n >= MaxSubklassPrintSize) st->print("(%d more klasses...)", n - MaxSubklassPrintSize); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2791 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2792 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2793 if (is_interface()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2794 st->print_cr(BULLET"nof implementors: %d", nof_implementors()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2795 if (nof_implementors() == 1) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2796 st->print_cr(BULLET"implementor: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2797 st->print(" "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2798 implementor()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2799 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2800 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2801 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2802 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2803 st->print(BULLET"arrays: "); array_klasses()->print_value_on_maybe_null(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2804 st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2805 if (Verbose) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2806 Array<Method*>* method_array = methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2807 for(int i = 0; i < method_array->length(); i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2808 st->print("%d : ", i); method_array->at(i)->print_value(); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2809 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2810 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2811 st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2812 st->print(BULLET"local interfaces: "); local_interfaces()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2813 st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2814 st->print(BULLET"constants: "); constants()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2815 if (class_loader_data() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2816 st->print(BULLET"class loader data: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2817 class_loader_data()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2818 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2819 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2820 st->print(BULLET"protection domain: "); ((InstanceKlass*)this)->protection_domain()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2821 st->print(BULLET"host class: "); host_klass()->print_value_on_maybe_null(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2822 st->print(BULLET"signers: "); signers()->print_value_on(st); st->cr(); |
8712
3efdfd6ddbf2
8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents:
8031
diff
changeset
|
2823 st->print(BULLET"init_lock: "); ((oop)_init_lock)->print_value_on(st); st->cr(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2824 if (source_file_name() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2825 st->print(BULLET"source file: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2826 source_file_name()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2827 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2828 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2829 if (source_debug_extension() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2830 st->print(BULLET"source debug extension: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2831 st->print("%s", source_debug_extension()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2832 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2833 } |
8031 | 2834 st->print(BULLET"class annotations: "); class_annotations()->print_value_on(st); st->cr(); |
2835 st->print(BULLET"class type annotations: "); class_type_annotations()->print_value_on(st); st->cr(); | |
2836 st->print(BULLET"field annotations: "); fields_annotations()->print_value_on(st); st->cr(); | |
2837 st->print(BULLET"field type annotations: "); fields_type_annotations()->print_value_on(st); st->cr(); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2838 { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2839 ResourceMark rm; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2840 // PreviousVersionInfo objects returned via PreviousVersionWalker |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2841 // contain a GrowableArray of handles. We have to clean up the |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2842 // GrowableArray _after_ the PreviousVersionWalker destructor |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2843 // has destroyed the handles. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2844 { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2845 bool have_pv = false; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2846 PreviousVersionWalker pvw((InstanceKlass*)this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2847 for (PreviousVersionInfo * pv_info = pvw.next_previous_version(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2848 pv_info != NULL; pv_info = pvw.next_previous_version()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2849 if (!have_pv) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2850 st->print(BULLET"previous version: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2851 have_pv = true; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2852 pv_info->prev_constant_pool_handle()()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2853 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2854 if (have_pv) st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2855 } // pvw is cleaned up |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2856 } // rm is cleaned up |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2857 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2858 if (generic_signature() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2859 st->print(BULLET"generic signature: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2860 generic_signature()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2861 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2862 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2863 st->print(BULLET"inner classes: "); inner_classes()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2864 st->print(BULLET"java mirror: "); java_mirror()->print_value_on(st); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2865 st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", vtable_length(), start_of_vtable()); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2866 st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", itable_length(), start_of_itable()); st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2867 st->print_cr(BULLET"---- static fields (%d words):", static_field_size()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2868 FieldPrinter print_static_field(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2869 ((InstanceKlass*)this)->do_local_static_fields(&print_static_field); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2870 st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2871 FieldPrinter print_nonstatic_field(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2872 ((InstanceKlass*)this)->do_nonstatic_fields(&print_nonstatic_field); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2873 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2874 st->print(BULLET"non-static oop maps: "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2875 OopMapBlock* map = start_of_nonstatic_oop_maps(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2876 OopMapBlock* end_map = map + nonstatic_oop_map_count(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2877 while (map < end_map) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2878 st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2879 map++; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2880 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2881 st->cr(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2882 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2883 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2884 #endif //PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2885 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2886 void InstanceKlass::print_value_on(outputStream* st) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2887 assert(is_klass(), "must be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2888 name()->print_value_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2889 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2890 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2891 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2892 |
0 | 2893 void FieldPrinter::do_field(fieldDescriptor* fd) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2894 _st->print(BULLET); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2895 if (_obj == NULL) { |
0 | 2896 fd->print_on(_st); |
2897 _st->cr(); | |
2898 } else { | |
2899 fd->print_on_for(_st, _obj); | |
2900 _st->cr(); | |
2901 } | |
2902 } | |
2903 | |
2904 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2905 void InstanceKlass::oop_print_on(oop obj, outputStream* st) { |
0 | 2906 Klass::oop_print_on(obj, st); |
2907 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2908 if (this == SystemDictionary::String_klass()) { |
0 | 2909 typeArrayOop value = java_lang_String::value(obj); |
2910 juint offset = java_lang_String::offset(obj); | |
2911 juint length = java_lang_String::length(obj); | |
2912 if (value != NULL && | |
2913 value->is_typeArray() && | |
2914 offset <= (juint) value->length() && | |
2915 offset + length <= (juint) value->length()) { | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2916 st->print(BULLET"string: "); |
0 | 2917 Handle h_obj(obj); |
2918 java_lang_String::print(h_obj, st); | |
2919 st->cr(); | |
2920 if (!WizardMode) return; // that is enough | |
2921 } | |
2922 } | |
2923 | |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2924 st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj)); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2925 FieldPrinter print_field(st, obj); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2926 do_nonstatic_fields(&print_field); |
0 | 2927 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2928 if (this == SystemDictionary::Class_klass()) { |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2929 st->print(BULLET"signature: "); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2930 java_lang_Class::print_signature(obj, st); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2931 st->cr(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2932 Klass* mirrored_klass = java_lang_Class::as_Klass(obj); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2933 st->print(BULLET"fake entry for mirror: "); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2934 mirrored_klass->print_value_on_maybe_null(st); |
0 | 2935 st->cr(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2936 Klass* array_klass = java_lang_Class::array_klass(obj); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2937 st->print(BULLET"fake entry for array: "); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2938 array_klass->print_value_on_maybe_null(st); |
0 | 2939 st->cr(); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2940 st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj)); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2941 st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2942 Klass* real_klass = java_lang_Class::as_Klass(obj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2943 if (real_klass != NULL && real_klass->oop_is_instance()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2944 InstanceKlass::cast(real_klass)->do_local_static_fields(&print_field); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
2945 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2946 } else if (this == SystemDictionary::MethodType_klass()) { |
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
997
diff
changeset
|
2947 st->print(BULLET"signature: "); |
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2334
diff
changeset
|
2948 java_lang_invoke_MethodType::print_signature(obj, st); |
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
997
diff
changeset
|
2949 st->cr(); |
0 | 2950 } |
2951 } | |
2952 | |
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1144
diff
changeset
|
2953 #endif //PRODUCT |
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1144
diff
changeset
|
2954 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2955 void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) { |
0 | 2956 st->print("a "); |
2957 name()->print_value_on(st); | |
2958 obj->print_address_on(st); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2959 if (this == SystemDictionary::String_klass() |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2960 && java_lang_String::value(obj) != NULL) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2961 ResourceMark rm; |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2962 int len = java_lang_String::length(obj); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2963 int plen = (len < 24 ? len : 12); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2964 char* str = java_lang_String::as_utf8_string(obj, 0, plen); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2965 st->print(" = \"%s\"", str); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2966 if (len > plen) |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2967 st->print("...[%d]", len); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2968 } else if (this == SystemDictionary::Class_klass()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2969 Klass* k = java_lang_Class::as_Klass(obj); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2970 st->print(" = "); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2971 if (k != NULL) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2972 k->print_value_on(st); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2973 } else { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2974 const char* tname = type2name(java_lang_Class::primitive_type(obj)); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2975 st->print("%s", tname ? tname : "type?"); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2976 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2977 } else if (this == SystemDictionary::MethodType_klass()) { |
1039
987e948ebbc8
6815692: method handle code needs some cleanup (post-6655638)
jrose
parents:
997
diff
changeset
|
2978 st->print(" = "); |
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2334
diff
changeset
|
2979 java_lang_invoke_MethodType::print_signature(obj, st); |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2980 } else if (java_lang_boxing_object::is_instance(obj)) { |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2981 st->print(" = "); |
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2982 java_lang_boxing_object::print(obj, st); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2983 } else if (this == SystemDictionary::LambdaForm_klass()) { |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2984 oop vmentry = java_lang_invoke_LambdaForm::vmentry(obj); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2985 if (vmentry != NULL) { |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2986 st->print(" => "); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2987 vmentry->print_value_on(st); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2988 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2989 } else if (this == SystemDictionary::MemberName_klass()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
2990 Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(obj); |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2991 if (vmtarget != NULL) { |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2992 st->print(" = "); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2993 vmtarget->print_value_on(st); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2994 } else { |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2995 java_lang_invoke_MemberName::clazz(obj)->print_value_on(st); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2996 st->print("."); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2997 java_lang_invoke_MemberName::name(obj)->print_value_on(st); |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6203
diff
changeset
|
2998 } |
665
c89f86385056
6814659: separable cleanups and subroutines for 6655638
jrose
parents:
605
diff
changeset
|
2999 } |
0 | 3000 } |
3001 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3002 const char* InstanceKlass::internal_name() const { |
0 | 3003 return external_name(); |
3004 } | |
3005 | |
7956 | 3006 #if INCLUDE_SERVICES |
3007 // Size Statistics | |
3008 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const { | |
3009 Klass::collect_statistics(sz); | |
3010 | |
3011 sz->_inst_size = HeapWordSize * size_helper(); | |
3012 sz->_vtab_bytes = HeapWordSize * align_object_offset(vtable_length()); | |
3013 sz->_itab_bytes = HeapWordSize * align_object_offset(itable_length()); | |
3014 sz->_nonstatic_oopmap_bytes = HeapWordSize * | |
3015 ((is_interface() || is_anonymous()) ? | |
3016 align_object_offset(nonstatic_oop_map_size()) : | |
3017 nonstatic_oop_map_size()); | |
3018 | |
3019 int n = 0; | |
3020 n += (sz->_methods_array_bytes = sz->count_array(methods())); | |
3021 n += (sz->_method_ordering_bytes = sz->count_array(method_ordering())); | |
3022 n += (sz->_local_interfaces_bytes = sz->count_array(local_interfaces())); | |
3023 n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces())); | |
3024 n += (sz->_signers_bytes = sz->count_array(signers())); | |
3025 n += (sz->_fields_bytes = sz->count_array(fields())); | |
3026 n += (sz->_inner_classes_bytes = sz->count_array(inner_classes())); | |
3027 sz->_ro_bytes += n; | |
3028 | |
3029 const ConstantPool* cp = constants(); | |
3030 if (cp) { | |
3031 cp->collect_statistics(sz); | |
3032 } | |
3033 | |
3034 const Annotations* anno = annotations(); | |
3035 if (anno) { | |
3036 anno->collect_statistics(sz); | |
3037 } | |
3038 | |
3039 const Array<Method*>* methods_array = methods(); | |
3040 if (methods()) { | |
3041 for (int i = 0; i < methods_array->length(); i++) { | |
3042 Method* method = methods_array->at(i); | |
3043 if (method) { | |
3044 sz->_method_count ++; | |
3045 method->collect_statistics(sz); | |
3046 } | |
3047 } | |
3048 } | |
3049 } | |
3050 #endif // INCLUDE_SERVICES | |
3051 | |
0 | 3052 // Verification |
3053 | |
3054 class VerifyFieldClosure: public OopClosure { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3055 protected: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3056 template <class T> void do_oop_work(T* p) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3057 oop obj = oopDesc::load_decode_heap_oop(p); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3058 if (!obj->is_oop_or_null()) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3059 tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p, (address)obj); |
0 | 3060 Universe::print(); |
3061 guarantee(false, "boom"); | |
3062 } | |
3063 } | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3064 public: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3065 virtual void do_oop(oop* p) { VerifyFieldClosure::do_oop_work(p); } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3066 virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); } |
0 | 3067 }; |
3068 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3069 void InstanceKlass::verify_on(outputStream* st) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3070 Klass::verify_on(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3071 Thread *thread = Thread::current(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3072 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3073 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3074 // Avoid redundant verifies |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3075 if (_verify_count == Universe::verify_count()) return; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3076 _verify_count = Universe::verify_count(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3077 #endif |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3078 // Verify that klass is present in SystemDictionary |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3079 if (is_loaded() && !is_anonymous()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3080 Symbol* h_name = name(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3081 SystemDictionary::verify_obj_klass_present(h_name, class_loader_data()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3082 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3083 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3084 // Verify static fields |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3085 VerifyFieldClosure blk; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3086 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3087 // Verify vtables |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3088 if (is_linked()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3089 ResourceMark rm(thread); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3090 // $$$ This used to be done only for m/s collections. Doing it |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3091 // always seemed a valid generalization. (DLD -- 6/00) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3092 vtable()->verify(st); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3093 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3094 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3095 // Verify first subklass |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3096 if (subklass_oop() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3097 guarantee(subklass_oop()->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3098 guarantee(subklass_oop()->is_klass(), "should be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3099 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3100 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3101 // Verify siblings |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3102 Klass* super = this->super(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3103 Klass* sib = next_sibling(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3104 if (sib != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3105 if (sib == this) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3106 fatal(err_msg("subclass points to itself " PTR_FORMAT, sib)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3107 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3108 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3109 guarantee(sib->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3110 guarantee(sib->is_klass(), "should be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3111 guarantee(sib->super() == super, "siblings should have same superklass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3112 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3113 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3114 // Verify implementor fields |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3115 Klass* im = implementor(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3116 if (im != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3117 guarantee(is_interface(), "only interfaces should have implementor set"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3118 guarantee(im->is_klass(), "should be klass"); |
6983 | 3119 guarantee(!im->is_interface() || im == this, |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3120 "implementors cannot be interfaces"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3121 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3122 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3123 // Verify local interfaces |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3124 if (local_interfaces()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3125 Array<Klass*>* local_interfaces = this->local_interfaces(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3126 for (int j = 0; j < local_interfaces->length(); j++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3127 Klass* e = local_interfaces->at(j); |
6983 | 3128 guarantee(e->is_klass() && e->is_interface(), "invalid local interface"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3129 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3130 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3131 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3132 // Verify transitive interfaces |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3133 if (transitive_interfaces() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3134 Array<Klass*>* transitive_interfaces = this->transitive_interfaces(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3135 for (int j = 0; j < transitive_interfaces->length(); j++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3136 Klass* e = transitive_interfaces->at(j); |
6983 | 3137 guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3138 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3139 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3140 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3141 // Verify methods |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3142 if (methods() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3143 Array<Method*>* methods = this->methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3144 for (int j = 0; j < methods->length(); j++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3145 guarantee(methods->at(j)->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3146 guarantee(methods->at(j)->is_method(), "non-method in methods array"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3147 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3148 for (int j = 0; j < methods->length() - 1; j++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3149 Method* m1 = methods->at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3150 Method* m2 = methods->at(j + 1); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3151 guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3152 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3153 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3154 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3155 // Verify method ordering |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3156 if (method_ordering() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3157 Array<int>* method_ordering = this->method_ordering(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3158 int length = method_ordering->length(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3159 if (JvmtiExport::can_maintain_original_method_order() || |
9057
8554c55669b0
8010943: guarantee(length == 0) failed: invalid method ordering length
hseigel
parents:
8719
diff
changeset
|
3160 ((UseSharedSpaces || DumpSharedSpaces) && length != 0)) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3161 guarantee(length == methods()->length(), "invalid method ordering length"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3162 jlong sum = 0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3163 for (int j = 0; j < length; j++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3164 int original_index = method_ordering->at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3165 guarantee(original_index >= 0, "invalid method ordering index"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3166 guarantee(original_index < length, "invalid method ordering index"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3167 sum += original_index; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3168 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3169 // Verify sum of indices 0,1,...,length-1 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3170 guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3171 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3172 guarantee(length == 0, "invalid method ordering length"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3173 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3174 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3175 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3176 // Verify JNI static field identifiers |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3177 if (jni_ids() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3178 jni_ids()->verify(this); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3179 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3180 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3181 // Verify other fields |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3182 if (array_klasses() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3183 guarantee(array_klasses()->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3184 guarantee(array_klasses()->is_klass(), "should be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3185 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3186 if (constants() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3187 guarantee(constants()->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3188 guarantee(constants()->is_constantPool(), "should be constant pool"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3189 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3190 if (protection_domain() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3191 guarantee(protection_domain()->is_oop(), "should be oop"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3192 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3193 if (host_klass() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3194 guarantee(host_klass()->is_metadata(), "should be in metaspace"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3195 guarantee(host_klass()->is_klass(), "should be klass"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3196 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3197 if (signers() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3198 guarantee(signers()->is_objArray(), "should be obj array"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3199 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3200 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3201 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3202 void InstanceKlass::oop_verify_on(oop obj, outputStream* st) { |
0 | 3203 Klass::oop_verify_on(obj, st); |
3204 VerifyFieldClosure blk; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3205 obj->oop_iterate_no_header(&blk); |
0 | 3206 } |
3207 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3208 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3209 // JNIid class for jfieldIDs only |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3210 // Note to reviewers: |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3211 // These JNI functions are just moved over to column 1 and not changed |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3212 // in the compressed oops workspace. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3213 JNIid::JNIid(Klass* holder, int offset, JNIid* next) { |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3214 _holder = holder; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3215 _offset = offset; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3216 _next = next; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3217 debug_only(_is_static_field_id = false;) |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3218 } |
0 | 3219 |
3220 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3221 JNIid* JNIid::find(int offset) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3222 JNIid* current = this; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3223 while (current != NULL) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3224 if (current->offset() == offset) return current; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3225 current = current->next(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3226 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3227 return NULL; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3228 } |
0 | 3229 |
3230 void JNIid::deallocate(JNIid* current) { | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3231 while (current != NULL) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3232 JNIid* next = current->next(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3233 delete current; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3234 current = next; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3235 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3236 } |
0 | 3237 |
3238 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3239 void JNIid::verify(Klass* holder) { |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6733
diff
changeset
|
3240 int first_field_offset = InstanceMirrorKlass::offset_of_static_fields(); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3241 int end_field_offset; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3242 end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize); |
0 | 3243 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3244 JNIid* current = this; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3245 while (current != NULL) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3246 guarantee(current->holder() == holder, "Invalid klass in JNIid"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3247 #ifdef ASSERT |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3248 int o = current->offset(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3249 if (current->is_static_field_id()) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3250 guarantee(o >= first_field_offset && o < end_field_offset, "Invalid static field offset in JNIid"); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3251 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3252 #endif |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3253 current = current->next(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3254 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3255 } |
0 | 3256 |
3257 | |
3258 #ifdef ASSERT | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3259 void InstanceKlass::set_init_state(ClassState state) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3260 bool good_state = is_shared() ? (_init_state <= state) |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3261 : (_init_state < state); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3262 assert(good_state || state == allocated, "illegal state transition"); |
4739
52b5d32fbfaf
7117052: instanceKlass::_init_state can be u1 type
coleenp
parents:
4006
diff
changeset
|
3263 _init_state = (u1)state; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3264 } |
0 | 3265 #endif |
3266 | |
3267 | |
3268 // RedefineClasses() support for previous versions: | |
3269 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3270 // Purge previous versions |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3271 static void purge_previous_versions_internal(InstanceKlass* ik, int emcp_method_count) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3272 if (ik->previous_versions() != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3273 // This klass has previous versions so see what we can cleanup |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3274 // while it is safe to do so. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3275 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3276 int deleted_count = 0; // leave debugging breadcrumbs |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3277 int live_count = 0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3278 ClassLoaderData* loader_data = ik->class_loader_data() == NULL ? |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3279 ClassLoaderData::the_null_class_loader_data() : |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3280 ik->class_loader_data(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3281 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3282 // RC_TRACE macro has an embedded ResourceMark |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3283 RC_TRACE(0x00000200, ("purge: %s: previous version length=%d", |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3284 ik->external_name(), ik->previous_versions()->length())); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3285 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3286 for (int i = ik->previous_versions()->length() - 1; i >= 0; i--) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3287 // check the previous versions array |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3288 PreviousVersionNode * pv_node = ik->previous_versions()->at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3289 ConstantPool* cp_ref = pv_node->prev_constant_pool(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3290 assert(cp_ref != NULL, "cp ref was unexpectedly cleared"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3291 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3292 ConstantPool* pvcp = cp_ref; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3293 if (!pvcp->on_stack()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3294 // If the constant pool isn't on stack, none of the methods |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3295 // are executing. Delete all the methods, the constant pool and |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3296 // and this previous version node. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3297 GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3298 if (method_refs != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3299 for (int j = method_refs->length() - 1; j >= 0; j--) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3300 Method* method = method_refs->at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3301 assert(method != NULL, "method ref was unexpectedly cleared"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3302 method_refs->remove_at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3303 // method will be freed with associated class. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3304 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3305 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3306 // Remove the constant pool |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3307 delete pv_node; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3308 // Since we are traversing the array backwards, we don't have to |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3309 // do anything special with the index. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3310 ik->previous_versions()->remove_at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3311 deleted_count++; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3312 continue; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3313 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3314 RC_TRACE(0x00000200, ("purge: previous version @%d is alive", i)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3315 assert(pvcp->pool_holder() != NULL, "Constant pool with no holder"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3316 guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3317 live_count++; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3318 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3319 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3320 // At least one method is live in this previous version, clean out |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3321 // the others or mark them as obsolete. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3322 GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3323 if (method_refs != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3324 RC_TRACE(0x00000200, ("purge: previous methods length=%d", |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3325 method_refs->length())); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3326 for (int j = method_refs->length() - 1; j >= 0; j--) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3327 Method* method = method_refs->at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3328 assert(method != NULL, "method ref was unexpectedly cleared"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3329 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3330 // Remove the emcp method if it's not executing |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3331 // If it's been made obsolete by a redefinition of a non-emcp |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3332 // method, mark it as obsolete but leave it to clean up later. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3333 if (!method->on_stack()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3334 method_refs->remove_at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3335 } else if (emcp_method_count == 0) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3336 method->set_is_obsolete(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3337 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3338 // RC_TRACE macro has an embedded ResourceMark |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3339 RC_TRACE(0x00000200, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3340 ("purge: %s(%s): prev method @%d in version @%d is alive", |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3341 method->name()->as_C_string(), |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3342 method->signature()->as_C_string(), j, i)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3343 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3344 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3345 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3346 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3347 assert(ik->previous_versions()->length() == live_count, "sanity check"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3348 RC_TRACE(0x00000200, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3349 ("purge: previous version stats: live=%d, deleted=%d", live_count, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3350 deleted_count)); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3351 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3352 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3353 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3354 // External interface for use during class unloading. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3355 void InstanceKlass::purge_previous_versions(InstanceKlass* ik) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3356 // Call with >0 emcp methods since they are not currently being redefined. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3357 purge_previous_versions_internal(ik, 1); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3358 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3359 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3360 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3361 // Potentially add an information node that contains pointers to the |
0 | 3362 // interesting parts of the previous version of the_class. |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3363 // This is also where we clean out any unused references. |
977
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
3364 // Note that while we delete nodes from the _previous_versions |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
3365 // array, we never delete the array itself until the klass is |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
3366 // unloaded. The has_been_redefined() query depends on that fact. |
74a5db69c1fe
6419370: 4/4 new jmethodID code has tiny holes in synchronization
dcubed
parents:
974
diff
changeset
|
3367 // |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3368 void InstanceKlass::add_previous_version(instanceKlassHandle ikh, |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3369 BitMap* emcp_methods, int emcp_method_count) { |
0 | 3370 assert(Thread::current()->is_VM_thread(), |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
52
diff
changeset
|
3371 "only VMThread can add previous versions"); |
0 | 3372 |
3373 if (_previous_versions == NULL) { | |
3374 // This is the first previous version so make some space. | |
3375 // Start with 2 elements under the assumption that the class | |
3376 // won't be redefined much. | |
6197 | 3377 _previous_versions = new (ResourceObj::C_HEAP, mtClass) |
0 | 3378 GrowableArray<PreviousVersionNode *>(2, true); |
3379 } | |
3380 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3381 ConstantPool* cp_ref = ikh->constants(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3382 |
0 | 3383 // RC_TRACE macro has an embedded ResourceMark |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3384 RC_TRACE(0x00000400, ("adding previous version ref for %s @%d, EMCP_cnt=%d " |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3385 "on_stack=%d", |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3386 ikh->external_name(), _previous_versions->length(), emcp_method_count, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3387 cp_ref->on_stack())); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3388 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3389 // If the constant pool for this previous version of the class |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3390 // is not marked as being on the stack, then none of the methods |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3391 // in this previous version of the class are on the stack so |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3392 // we don't need to create a new PreviousVersionNode. However, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3393 // we still need to examine older previous versions below. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3394 Array<Method*>* old_methods = ikh->methods(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3395 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3396 if (cp_ref->on_stack()) { |
0 | 3397 PreviousVersionNode * pv_node = NULL; |
3398 if (emcp_method_count == 0) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3399 // non-shared ConstantPool gets a reference |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3400 pv_node = new PreviousVersionNode(cp_ref, !cp_ref->is_shared(), NULL); |
0 | 3401 RC_TRACE(0x00000400, |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3402 ("add: all methods are obsolete; flushing any EMCP refs")); |
0 | 3403 } else { |
3404 int local_count = 0; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3405 GrowableArray<Method*>* method_refs = new (ResourceObj::C_HEAP, mtClass) |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3406 GrowableArray<Method*>(emcp_method_count, true); |
0 | 3407 for (int i = 0; i < old_methods->length(); i++) { |
3408 if (emcp_methods->at(i)) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3409 // this old method is EMCP. Save it only if it's on the stack |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3410 Method* old_method = old_methods->at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3411 if (old_method->on_stack()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3412 method_refs->append(old_method); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3413 } |
0 | 3414 if (++local_count >= emcp_method_count) { |
3415 // no more EMCP methods so bail out now | |
3416 break; | |
3417 } | |
3418 } | |
3419 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3420 // non-shared ConstantPool gets a reference |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3421 pv_node = new PreviousVersionNode(cp_ref, !cp_ref->is_shared(), method_refs); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3422 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3423 // append new previous version. |
0 | 3424 _previous_versions->append(pv_node); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3425 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3426 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3427 // Since the caller is the VMThread and we are at a safepoint, this |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3428 // is a good time to clear out unused references. |
0 | 3429 |
3430 RC_TRACE(0x00000400, ("add: previous version length=%d", | |
3431 _previous_versions->length())); | |
3432 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3433 // Purge previous versions not executing on the stack |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3434 purge_previous_versions_internal(this, emcp_method_count); |
0 | 3435 |
3436 int obsolete_method_count = old_methods->length() - emcp_method_count; | |
3437 | |
3438 if (emcp_method_count != 0 && obsolete_method_count != 0 && | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3439 _previous_versions->length() > 0) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3440 // We have a mix of obsolete and EMCP methods so we have to |
0 | 3441 // clear out any matching EMCP method entries the hard way. |
3442 int local_count = 0; | |
3443 for (int i = 0; i < old_methods->length(); i++) { | |
3444 if (!emcp_methods->at(i)) { | |
3445 // only obsolete methods are interesting | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3446 Method* old_method = old_methods->at(i); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
3447 Symbol* m_name = old_method->name(); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
3448 Symbol* m_signature = old_method->signature(); |
0 | 3449 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3450 // we might not have added the last entry |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3451 for (int j = _previous_versions->length() - 1; j >= 0; j--) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3452 // check the previous versions array for non executing obsolete methods |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3453 PreviousVersionNode * pv_node = _previous_versions->at(j); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3454 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3455 GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods(); |
0 | 3456 if (method_refs == NULL) { |
3457 // We have run into a PreviousVersion generation where | |
3458 // all methods were made obsolete during that generation's | |
3459 // RedefineClasses() operation. At the time of that | |
3460 // operation, all EMCP methods were flushed so we don't | |
3461 // have to go back any further. | |
3462 // | |
3463 // A NULL method_refs is different than an empty method_refs. | |
3464 // We cannot infer any optimizations about older generations | |
3465 // from an empty method_refs for the current generation. | |
3466 break; | |
3467 } | |
3468 | |
3469 for (int k = method_refs->length() - 1; k >= 0; k--) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3470 Method* method = method_refs->at(k); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3471 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3472 if (!method->is_obsolete() && |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3473 method->name() == m_name && |
0 | 3474 method->signature() == m_signature) { |
3475 // The current RedefineClasses() call has made all EMCP | |
3476 // versions of this method obsolete so mark it as obsolete | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3477 // and remove the reference. |
0 | 3478 RC_TRACE(0x00000400, |
3479 ("add: %s(%s): flush obsolete method @%d in version @%d", | |
3480 m_name->as_C_string(), m_signature->as_C_string(), k, j)); | |
3481 | |
3482 method->set_is_obsolete(); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3483 // Leave obsolete methods on the previous version list to |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3484 // clean up later. |
0 | 3485 break; |
3486 } | |
3487 } | |
3488 | |
3489 // The previous loop may not find a matching EMCP method, but | |
3490 // that doesn't mean that we can optimize and not go any | |
3491 // further back in the PreviousVersion generations. The EMCP | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3492 // method for this generation could have already been deleted, |
0 | 3493 // but there still may be an older EMCP method that has not |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3494 // been deleted. |
0 | 3495 } |
3496 | |
3497 if (++local_count >= obsolete_method_count) { | |
3498 // no more obsolete methods so bail out now | |
3499 break; | |
3500 } | |
3501 } | |
3502 } | |
3503 } | |
3504 } // end add_previous_version() | |
3505 | |
3506 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3507 // Determine if InstanceKlass has a previous version. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3508 bool InstanceKlass::has_previous_version() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3509 return (_previous_versions != NULL && _previous_versions->length() > 0); |
0 | 3510 } // end has_previous_version() |
3511 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3512 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3513 Method* InstanceKlass::method_with_idnum(int idnum) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3514 Method* m = NULL; |
0 | 3515 if (idnum < methods()->length()) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3516 m = methods()->at(idnum); |
0 | 3517 } |
3518 if (m == NULL || m->method_idnum() != idnum) { | |
3519 for (int index = 0; index < methods()->length(); ++index) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3520 m = methods()->at(index); |
0 | 3521 if (m->method_idnum() == idnum) { |
3522 return m; | |
3523 } | |
3524 } | |
3525 } | |
3526 return m; | |
3527 } | |
3528 | |
3529 | |
3530 // Construct a PreviousVersionNode entry for the array hung off | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3531 // the InstanceKlass. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3532 PreviousVersionNode::PreviousVersionNode(ConstantPool* prev_constant_pool, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3533 bool prev_cp_is_weak, GrowableArray<Method*>* prev_EMCP_methods) { |
0 | 3534 |
3535 _prev_constant_pool = prev_constant_pool; | |
47
2c106685d6d0
6497639: 4/3 Profiling Swing application caused JVM crash
dcubed
parents:
0
diff
changeset
|
3536 _prev_cp_is_weak = prev_cp_is_weak; |
0 | 3537 _prev_EMCP_methods = prev_EMCP_methods; |
3538 } | |
3539 | |
3540 | |
3541 // Destroy a PreviousVersionNode | |
3542 PreviousVersionNode::~PreviousVersionNode() { | |
3543 if (_prev_constant_pool != NULL) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3544 _prev_constant_pool = NULL; |
0 | 3545 } |
3546 | |
3547 if (_prev_EMCP_methods != NULL) { | |
3548 delete _prev_EMCP_methods; | |
3549 } | |
3550 } | |
3551 | |
3552 | |
3553 // Construct a PreviousVersionInfo entry | |
3554 PreviousVersionInfo::PreviousVersionInfo(PreviousVersionNode *pv_node) { | |
3555 _prev_constant_pool_handle = constantPoolHandle(); // NULL handle | |
3556 _prev_EMCP_method_handles = NULL; | |
3557 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3558 ConstantPool* cp = pv_node->prev_constant_pool(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3559 assert(cp != NULL, "constant pool ref was unexpectedly cleared"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3560 if (cp == NULL) { |
0 | 3561 return; // robustness |
3562 } | |
3563 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3564 // make the ConstantPool* safe to return |
0 | 3565 _prev_constant_pool_handle = constantPoolHandle(cp); |
3566 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3567 GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods(); |
0 | 3568 if (method_refs == NULL) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3569 // the InstanceKlass did not have any EMCP methods |
0 | 3570 return; |
3571 } | |
3572 | |
3573 _prev_EMCP_method_handles = new GrowableArray<methodHandle>(10); | |
3574 | |
3575 int n_methods = method_refs->length(); | |
3576 for (int i = 0; i < n_methods; i++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3577 Method* method = method_refs->at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3578 assert (method != NULL, "method has been cleared"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3579 if (method == NULL) { |
0 | 3580 continue; // robustness |
3581 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3582 // make the Method* safe to return |
0 | 3583 _prev_EMCP_method_handles->append(methodHandle(method)); |
3584 } | |
3585 } | |
3586 | |
3587 | |
3588 // Destroy a PreviousVersionInfo | |
3589 PreviousVersionInfo::~PreviousVersionInfo() { | |
3590 // Since _prev_EMCP_method_handles is not C-heap allocated, we | |
3591 // don't have to delete it. | |
3592 } | |
3593 | |
3594 | |
3595 // Construct a helper for walking the previous versions array | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3596 PreviousVersionWalker::PreviousVersionWalker(InstanceKlass *ik) { |
0 | 3597 _previous_versions = ik->previous_versions(); |
3598 _current_index = 0; | |
3599 // _hm needs no initialization | |
3600 _current_p = NULL; | |
3601 } | |
3602 | |
3603 | |
3604 // Destroy a PreviousVersionWalker | |
3605 PreviousVersionWalker::~PreviousVersionWalker() { | |
3606 // Delete the current info just in case the caller didn't walk to | |
3607 // the end of the previous versions list. No harm if _current_p is | |
3608 // already NULL. | |
3609 delete _current_p; | |
3610 | |
3611 // When _hm is destroyed, all the Handles returned in | |
3612 // PreviousVersionInfo objects will be destroyed. | |
3613 // Also, after this destructor is finished it will be | |
3614 // safe to delete the GrowableArray allocated in the | |
3615 // PreviousVersionInfo objects. | |
3616 } | |
3617 | |
3618 | |
3619 // Return the interesting information for the next previous version | |
3620 // of the klass. Returns NULL if there are no more previous versions. | |
3621 PreviousVersionInfo* PreviousVersionWalker::next_previous_version() { | |
3622 if (_previous_versions == NULL) { | |
3623 // no previous versions so nothing to return | |
3624 return NULL; | |
3625 } | |
3626 | |
3627 delete _current_p; // cleanup the previous info for the caller | |
3628 _current_p = NULL; // reset to NULL so we don't delete same object twice | |
3629 | |
3630 int length = _previous_versions->length(); | |
3631 | |
3632 while (_current_index < length) { | |
3633 PreviousVersionNode * pv_node = _previous_versions->at(_current_index++); | |
6197 | 3634 PreviousVersionInfo * pv_info = new (ResourceObj::C_HEAP, mtClass) |
0 | 3635 PreviousVersionInfo(pv_node); |
3636 | |
3637 constantPoolHandle cp_h = pv_info->prev_constant_pool_handle(); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3638 assert (!cp_h.is_null(), "null cp found in previous version"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3639 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3640 // The caller will need to delete pv_info when they are done with it. |
0 | 3641 _current_p = pv_info; |
3642 return pv_info; | |
3643 } | |
3644 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6266
diff
changeset
|
3645 // all of the underlying nodes' info has been deleted |
0 | 3646 return NULL; |
3647 } // end next_previous_version() |