Mercurial > hg > truffle
annotate src/share/vm/runtime/vmStructs.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 /* |
8031 | 2 * Copyright (c) 2000, 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:
1166
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1166
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:
1166
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/dictionary.hpp" | |
27 #include "classfile/javaClasses.hpp" | |
28 #include "classfile/loaderConstraints.hpp" | |
29 #include "classfile/placeholders.hpp" | |
30 #include "classfile/symbolTable.hpp" | |
31 #include "classfile/systemDictionary.hpp" | |
3939 | 32 #include "ci/ciField.hpp" |
33 #include "ci/ciInstance.hpp" | |
34 #include "ci/ciObjArrayKlass.hpp" | |
35 #include "ci/ciMethodData.hpp" | |
36 #include "ci/ciSymbol.hpp" | |
1972 | 37 #include "code/codeBlob.hpp" |
38 #include "code/codeCache.hpp" | |
39 #include "code/compressedStream.hpp" | |
40 #include "code/location.hpp" | |
41 #include "code/nmethod.hpp" | |
42 #include "code/pcDesc.hpp" | |
43 #include "code/stubs.hpp" | |
44 #include "code/vmreg.hpp" | |
45 #include "compiler/oopMap.hpp" | |
3939 | 46 #include "compiler/compileBroker.hpp" |
1972 | 47 #include "gc_implementation/shared/immutableSpace.hpp" |
48 #include "gc_implementation/shared/markSweep.hpp" | |
49 #include "gc_implementation/shared/mutableSpace.hpp" | |
50 #include "gc_interface/collectedHeap.hpp" | |
51 #include "interpreter/bytecodeInterpreter.hpp" | |
52 #include "interpreter/bytecodes.hpp" | |
53 #include "interpreter/interpreter.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
54 #include "memory/allocation.hpp" |
1972 | 55 #include "memory/cardTableRS.hpp" |
56 #include "memory/defNewGeneration.hpp" | |
6026 | 57 #include "memory/freeBlockDictionary.hpp" |
1972 | 58 #include "memory/genCollectedHeap.hpp" |
59 #include "memory/generation.hpp" | |
60 #include "memory/generationSpec.hpp" | |
61 #include "memory/heap.hpp" | |
6885 | 62 #include "memory/metablock.hpp" |
1972 | 63 #include "memory/space.hpp" |
64 #include "memory/tenuredGeneration.hpp" | |
65 #include "memory/universe.hpp" | |
66 #include "memory/watermark.hpp" | |
67 #include "oops/arrayKlass.hpp" | |
68 #include "oops/arrayOop.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
69 #include "oops/compiledICHolder.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
70 #include "oops/constMethod.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
71 #include "oops/constantPool.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
72 #include "oops/cpCache.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
73 #include "oops/instanceClassLoaderKlass.hpp" |
1972 | 74 #include "oops/instanceKlass.hpp" |
2411
63997f575155
7031614: jmap -permstat fails with java.lang.InternalError in sun.jvm.hotspot.oops.OopField.getValue
never
parents:
2388
diff
changeset
|
75 #include "oops/instanceMirrorKlass.hpp" |
1972 | 76 #include "oops/instanceOop.hpp" |
77 #include "oops/klass.hpp" | |
78 #include "oops/markOop.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
79 #include "oops/methodData.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
80 #include "oops/method.hpp" |
1972 | 81 #include "oops/objArrayKlass.hpp" |
82 #include "oops/objArrayOop.hpp" | |
83 #include "oops/oop.inline.hpp" | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
84 #include "oops/symbol.hpp" |
1972 | 85 #include "oops/typeArrayKlass.hpp" |
86 #include "oops/typeArrayOop.hpp" | |
87 #include "prims/jvmtiAgentThread.hpp" | |
88 #include "runtime/arguments.hpp" | |
3939 | 89 #include "runtime/deoptimization.hpp" |
90 #include "runtime/vframeArray.hpp" | |
1972 | 91 #include "runtime/globals.hpp" |
92 #include "runtime/java.hpp" | |
93 #include "runtime/javaCalls.hpp" | |
94 #include "runtime/perfMemory.hpp" | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2192
diff
changeset
|
95 #include "runtime/serviceThread.hpp" |
1972 | 96 #include "runtime/sharedRuntime.hpp" |
97 #include "runtime/stubRoutines.hpp" | |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6972
diff
changeset
|
98 #include "runtime/thread.inline.hpp" |
1972 | 99 #include "runtime/virtualspace.hpp" |
100 #include "runtime/vmStructs.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
101 #include "utilities/array.hpp" |
1972 | 102 #include "utilities/globalDefinitions.hpp" |
103 #include "utilities/hashtable.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
104 #include "utilities/macros.hpp" |
1972 | 105 #ifdef TARGET_ARCH_x86 |
106 # include "vmStructs_x86.hpp" | |
107 #endif | |
108 #ifdef TARGET_ARCH_sparc | |
109 # include "vmStructs_sparc.hpp" | |
110 #endif | |
111 #ifdef TARGET_ARCH_zero | |
112 # include "vmStructs_zero.hpp" | |
113 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
114 #ifdef TARGET_ARCH_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
115 # include "vmStructs_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
116 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
117 #ifdef TARGET_ARCH_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
118 # include "vmStructs_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
119 #endif |
1972 | 120 #ifdef TARGET_OS_ARCH_linux_x86 |
121 # include "vmStructs_linux_x86.hpp" | |
122 #endif | |
123 #ifdef TARGET_OS_ARCH_linux_sparc | |
124 # include "vmStructs_linux_sparc.hpp" | |
125 #endif | |
126 #ifdef TARGET_OS_ARCH_linux_zero | |
127 # include "vmStructs_linux_zero.hpp" | |
128 #endif | |
129 #ifdef TARGET_OS_ARCH_solaris_x86 | |
130 # include "vmStructs_solaris_x86.hpp" | |
131 #endif | |
132 #ifdef TARGET_OS_ARCH_solaris_sparc | |
133 # include "vmStructs_solaris_sparc.hpp" | |
134 #endif | |
135 #ifdef TARGET_OS_ARCH_windows_x86 | |
136 # include "vmStructs_windows_x86.hpp" | |
137 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
138 #ifdef TARGET_OS_ARCH_linux_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
139 # include "vmStructs_linux_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
140 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
141 #ifdef TARGET_OS_ARCH_linux_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
142 # include "vmStructs_linux_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
143 #endif |
3960 | 144 #ifdef TARGET_OS_ARCH_bsd_x86 |
145 # include "vmStructs_bsd_x86.hpp" | |
146 #endif | |
147 #ifdef TARGET_OS_ARCH_bsd_zero | |
148 # include "vmStructs_bsd_zero.hpp" | |
149 #endif | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
150 #if INCLUDE_ALL_GCS |
1972 | 151 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp" |
152 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp" | |
153 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp" | |
154 #include "gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp" | |
155 #include "gc_implementation/parNew/parNewGeneration.hpp" | |
156 #include "gc_implementation/parNew/vmStructs_parNew.hpp" | |
157 #include "gc_implementation/parallelScavenge/asPSOldGen.hpp" | |
158 #include "gc_implementation/parallelScavenge/asPSYoungGen.hpp" | |
159 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
160 #include "gc_implementation/parallelScavenge/psOldGen.hpp" | |
161 #include "gc_implementation/parallelScavenge/psVirtualspace.hpp" | |
162 #include "gc_implementation/parallelScavenge/psYoungGen.hpp" | |
163 #include "gc_implementation/parallelScavenge/vmStructs_parallelgc.hpp" | |
3972 | 164 #include "gc_implementation/g1/vmStructs_g1.hpp" |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
165 #endif // INCLUDE_ALL_GCS |
1972 | 166 #ifdef COMPILER2 |
3939 | 167 #include "opto/addnode.hpp" |
168 #include "opto/block.hpp" | |
169 #include "opto/callnode.hpp" | |
170 #include "opto/cfgnode.hpp" | |
171 #include "opto/chaitin.hpp" | |
172 #include "opto/divnode.hpp" | |
173 #include "opto/locknode.hpp" | |
174 #include "opto/loopnode.hpp" | |
175 #include "opto/machnode.hpp" | |
1972 | 176 #include "opto/matcher.hpp" |
3939 | 177 #include "opto/mulnode.hpp" |
178 #include "opto/phaseX.hpp" | |
179 #include "opto/parse.hpp" | |
180 #include "opto/regalloc.hpp" | |
181 #include "opto/rootnode.hpp" | |
182 #include "opto/subnode.hpp" | |
183 #include "opto/vectornode.hpp" | |
1972 | 184 #ifdef TARGET_ARCH_MODEL_x86_32 |
185 # include "adfiles/adGlobals_x86_32.hpp" | |
186 #endif | |
187 #ifdef TARGET_ARCH_MODEL_x86_64 | |
188 # include "adfiles/adGlobals_x86_64.hpp" | |
189 #endif | |
190 #ifdef TARGET_ARCH_MODEL_sparc | |
191 # include "adfiles/adGlobals_sparc.hpp" | |
192 #endif | |
193 #ifdef TARGET_ARCH_MODEL_zero | |
194 # include "adfiles/adGlobals_zero.hpp" | |
195 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
196 #ifdef TARGET_ARCH_MODEL_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
197 # include "adfiles/adGlobals_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
198 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
199 #ifdef TARGET_ARCH_MODEL_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
200 # include "adfiles/adGlobals_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
201 #endif |
1972 | 202 #endif |
0 | 203 |
204 // Note: the cross-product of (c1, c2, product, nonproduct, ...), | |
205 // (nonstatic, static), and (unchecked, checked) has not been taken. | |
206 // Only the macros currently needed have been defined. | |
207 | |
208 // A field whose type is not checked is given a null string as the | |
209 // type name, indicating an "opaque" type to the serviceability agent. | |
210 | |
211 // NOTE: there is an interdependency between this file and | |
212 // HotSpotTypeDataBase.java, which parses the type strings. | |
213 | |
214 #ifndef REG_COUNT | |
215 #define REG_COUNT 0 | |
216 #endif | |
217 // whole purpose of this function is to work around bug c++/27724 in gcc 4.1.1 | |
218 // with optimization turned on it doesn't affect produced code | |
219 static inline uint64_t cast_uint64_t(size_t x) | |
220 { | |
221 return x; | |
222 } | |
223 | |
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
224 #if INCLUDE_JVMTI |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
225 #define JVMTI_STRUCTS(static_field) \ |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
226 static_field(JvmtiExport, _can_access_local_variables, bool) \ |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
227 static_field(JvmtiExport, _can_hotswap_or_post_breakpoint, bool) \ |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
228 static_field(JvmtiExport, _can_post_on_exceptions, bool) \ |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
229 static_field(JvmtiExport, _can_walk_any_space, bool) |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
230 #else |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
231 #define JVMTI_STRUCTS(static_field) |
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
232 #endif // INCLUDE_JVMTI |
0 | 233 |
6197 | 234 typedef HashtableEntry<intptr_t, mtInternal> IntptrHashtableEntry; |
235 typedef Hashtable<intptr_t, mtInternal> IntptrHashtable; | |
236 typedef Hashtable<Symbol*, mtSymbol> SymbolHashtable; | |
237 typedef HashtableEntry<Symbol*, mtClass> SymbolHashtableEntry; | |
238 typedef Hashtable<oop, mtSymbol> StringHashtable; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
239 typedef TwoOopHashtable<Klass*, mtClass> KlassTwoOopHashtable; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
240 typedef Hashtable<Klass*, mtClass> KlassHashtable; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
241 typedef HashtableEntry<Klass*, mtClass> KlassHashtableEntry; |
6197 | 242 typedef TwoOopHashtable<Symbol*, mtClass> SymbolTwoOopHashtable; |
6885 | 243 typedef BinaryTreeDictionary<Metablock, FreeList> MetablockTreeDictionary; |
6197 | 244 |
0 | 245 //-------------------------------------------------------------------------------- |
246 // VM_STRUCTS | |
247 // | |
248 // This list enumerates all of the fields the serviceability agent | |
249 // needs to know about. Be sure to see also the type table below this one. | |
250 // NOTE that there are platform-specific additions to this table in | |
251 // vmStructs_<os>_<cpu>.hpp. | |
252 | |
253 #define VM_STRUCTS(nonstatic_field, \ | |
254 static_field, \ | |
255 unchecked_nonstatic_field, \ | |
256 volatile_nonstatic_field, \ | |
257 nonproduct_nonstatic_field, \ | |
258 c1_nonstatic_field, \ | |
259 c2_nonstatic_field, \ | |
260 unchecked_c1_static_field, \ | |
7583 | 261 unchecked_c2_static_field) \ |
0 | 262 \ |
263 /******************************************************************/ \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
264 /* OopDesc and Klass hierarchies (NOTE: MethodData* incomplete) */ \ |
0 | 265 /******************************************************************/ \ |
266 \ | |
267 volatile_nonstatic_field(oopDesc, _mark, markOop) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
268 volatile_nonstatic_field(oopDesc, _metadata._klass, Klass*) \ |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
269 volatile_nonstatic_field(oopDesc, _metadata._compressed_klass, narrowOop) \ |
0 | 270 static_field(oopDesc, _bs, BarrierSet*) \ |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
271 nonstatic_field(ArrayKlass, _dimension, int) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
272 volatile_nonstatic_field(ArrayKlass, _higher_dimension, Klass*) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
273 volatile_nonstatic_field(ArrayKlass, _lower_dimension, Klass*) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
274 nonstatic_field(ArrayKlass, _vtable_len, int) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
275 nonstatic_field(ArrayKlass, _alloc_size, juint) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
276 nonstatic_field(ArrayKlass, _component_mirror, oop) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
277 nonstatic_field(CompiledICHolder, _holder_method, Method*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
278 nonstatic_field(CompiledICHolder, _holder_klass, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
279 nonstatic_field(ConstantPool, _tags, Array<u1>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
280 nonstatic_field(ConstantPool, _cache, ConstantPoolCache*) \ |
6940
18fb7da42534
8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents:
6926
diff
changeset
|
281 nonstatic_field(ConstantPool, _pool_holder, InstanceKlass*) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
282 nonstatic_field(ConstantPool, _operands, Array<u2>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
283 nonstatic_field(ConstantPool, _length, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
284 nonstatic_field(ConstantPool, _resolved_references, jobject) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
285 nonstatic_field(ConstantPool, _reference_map, Array<u2>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
286 nonstatic_field(ConstantPoolCache, _length, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
287 nonstatic_field(ConstantPoolCache, _constant_pool, ConstantPool*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
288 nonstatic_field(InstanceKlass, _array_klasses, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
289 nonstatic_field(InstanceKlass, _methods, Array<Method*>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
290 nonstatic_field(InstanceKlass, _local_interfaces, Array<Klass*>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
291 nonstatic_field(InstanceKlass, _transitive_interfaces, Array<Klass*>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
292 nonstatic_field(InstanceKlass, _fields, Array<u2>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
293 nonstatic_field(InstanceKlass, _java_fields_count, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
294 nonstatic_field(InstanceKlass, _constants, ConstantPool*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
295 nonstatic_field(InstanceKlass, _class_loader_data, ClassLoaderData*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
296 nonstatic_field(InstanceKlass, _protection_domain, oop) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
297 nonstatic_field(InstanceKlass, _signers, objArrayOop) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
298 nonstatic_field(InstanceKlass, _source_file_name, Symbol*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
299 nonstatic_field(InstanceKlass, _source_debug_extension, char*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
300 nonstatic_field(InstanceKlass, _inner_classes, Array<jushort>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
301 nonstatic_field(InstanceKlass, _nonstatic_field_size, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
302 nonstatic_field(InstanceKlass, _static_field_size, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
303 nonstatic_field(InstanceKlass, _static_oop_field_count, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
304 nonstatic_field(InstanceKlass, _nonstatic_oop_map_size, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
305 nonstatic_field(InstanceKlass, _is_marked_dependent, bool) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
306 nonstatic_field(InstanceKlass, _minor_version, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
307 nonstatic_field(InstanceKlass, _major_version, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
308 nonstatic_field(InstanceKlass, _init_state, u1) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
309 nonstatic_field(InstanceKlass, _init_thread, Thread*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
310 nonstatic_field(InstanceKlass, _vtable_len, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
311 nonstatic_field(InstanceKlass, _itable_len, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
312 nonstatic_field(InstanceKlass, _reference_type, u1) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
313 volatile_nonstatic_field(InstanceKlass, _oop_map_cache, OopMapCache*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
314 nonstatic_field(InstanceKlass, _jni_ids, JNIid*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
315 nonstatic_field(InstanceKlass, _osr_nmethods_head, nmethod*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
316 nonstatic_field(InstanceKlass, _breakpoints, BreakpointInfo*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
317 nonstatic_field(InstanceKlass, _generic_signature, Symbol*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
318 nonstatic_field(InstanceKlass, _methods_jmethod_ids, jmethodID*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
319 nonstatic_field(InstanceKlass, _methods_cached_itable_indices, int*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
320 volatile_nonstatic_field(InstanceKlass, _idnum_allocated_count, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
321 nonstatic_field(InstanceKlass, _annotations, Annotations*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
322 nonstatic_field(InstanceKlass, _dependencies, nmethodBucket*) \ |
3939 | 323 nonstatic_field(nmethodBucket, _nmethod, nmethod*) \ |
324 nonstatic_field(nmethodBucket, _count, int) \ | |
325 nonstatic_field(nmethodBucket, _next, nmethodBucket*) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
326 nonstatic_field(InstanceKlass, _method_ordering, Array<int>*) \ |
0 | 327 nonstatic_field(Klass, _super_check_offset, juint) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
328 nonstatic_field(Klass, _secondary_super_cache, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
329 nonstatic_field(Klass, _secondary_supers, Array<Klass*>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
330 nonstatic_field(Klass, _primary_supers[0], Klass*) \ |
0 | 331 nonstatic_field(Klass, _java_mirror, oop) \ |
332 nonstatic_field(Klass, _modifier_flags, jint) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
333 nonstatic_field(Klass, _super, Klass*) \ |
0 | 334 nonstatic_field(Klass, _layout_helper, jint) \ |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
335 nonstatic_field(Klass, _name, Symbol*) \ |
0 | 336 nonstatic_field(Klass, _access_flags, AccessFlags) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
337 nonstatic_field(Klass, _subklass, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
338 nonstatic_field(Klass, _next_sibling, Klass*) \ |
0 | 339 nonstatic_field(Klass, _alloc_count, juint) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
340 nonstatic_field(MethodData, _size, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
341 nonstatic_field(MethodData, _method, Method*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
342 nonstatic_field(MethodData, _data_size, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
343 nonstatic_field(MethodData, _data[0], intptr_t) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
344 nonstatic_field(MethodData, _nof_decompiles, uint) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
345 nonstatic_field(MethodData, _nof_overflow_recompiles, uint) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
346 nonstatic_field(MethodData, _nof_overflow_traps, uint) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
347 nonstatic_field(MethodData, _eflags, intx) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
348 nonstatic_field(MethodData, _arg_local, intx) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
349 nonstatic_field(MethodData, _arg_stack, intx) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
350 nonstatic_field(MethodData, _arg_returned, intx) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
351 nonstatic_field(Method, _constMethod, ConstMethod*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
352 nonstatic_field(Method, _method_data, MethodData*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
353 nonstatic_field(Method, _interpreter_invocation_count, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
354 nonstatic_field(Method, _access_flags, AccessFlags) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
355 nonstatic_field(Method, _vtable_index, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
356 nonstatic_field(Method, _method_size, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
357 nonstatic_field(Method, _interpreter_throwout_count, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
358 nonstatic_field(Method, _number_of_breakpoints, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
359 nonstatic_field(Method, _invocation_counter, InvocationCounter) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
360 nonstatic_field(Method, _backedge_counter, InvocationCounter) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
361 nonproduct_nonstatic_field(Method, _compiled_invocation_count, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
362 volatile_nonstatic_field(Method, _code, nmethod*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
363 nonstatic_field(Method, _i2i_entry, address) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
364 nonstatic_field(Method, _adapter, AdapterHandlerEntry*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
365 volatile_nonstatic_field(Method, _from_compiled_entry, address) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
366 volatile_nonstatic_field(Method, _from_interpreted_entry, address) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
367 volatile_nonstatic_field(ConstMethod, _fingerprint, uint64_t) \ |
8031 | 368 nonstatic_field(ConstMethod, _constants, ConstantPool*) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
369 nonstatic_field(ConstMethod, _stackmap_data, Array<u1>*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
370 nonstatic_field(ConstMethod, _constMethod_size, int) \ |
8031 | 371 nonstatic_field(ConstMethod, _flags, u2) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
372 nonstatic_field(ConstMethod, _code_size, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
373 nonstatic_field(ConstMethod, _name_index, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
374 nonstatic_field(ConstMethod, _signature_index, u2) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
375 nonstatic_field(ConstMethod, _method_idnum, u2) \ |
7183
b2dbd323c668
8003848: Make ConstMethod::generic_signature_index optional and move Method::_max_stack to ConstMethod.
jiangli
parents:
6972
diff
changeset
|
376 nonstatic_field(ConstMethod, _max_stack, u2) \ |
7402
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7184
diff
changeset
|
377 nonstatic_field(ConstMethod, _max_locals, u2) \ |
fd74228fd5ca
8004076: Move _max_locals and _size_of_parameters to ConstMethod for better sharing.
jiangli
parents:
7184
diff
changeset
|
378 nonstatic_field(ConstMethod, _size_of_parameters, u2) \ |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
379 nonstatic_field(ObjArrayKlass, _element_klass, Klass*) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
380 nonstatic_field(ObjArrayKlass, _bottom_klass, Klass*) \ |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
381 volatile_nonstatic_field(Symbol, _refcount, int) \ |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
382 nonstatic_field(Symbol, _identity_hash, int) \ |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
383 nonstatic_field(Symbol, _length, unsigned short) \ |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
384 unchecked_nonstatic_field(Symbol, _body, sizeof(jbyte)) /* NOTE: no type */ \ |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
385 nonstatic_field(TypeArrayKlass, _max_length, int) \ |
0 | 386 \ |
387 /***********************/ \ | |
388 /* Constant Pool Cache */ \ | |
389 /***********************/ \ | |
390 \ | |
391 volatile_nonstatic_field(ConstantPoolCacheEntry, _indices, intx) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
392 nonstatic_field(ConstantPoolCacheEntry, _f1, volatile Metadata*) \ |
0 | 393 volatile_nonstatic_field(ConstantPoolCacheEntry, _f2, intx) \ |
394 volatile_nonstatic_field(ConstantPoolCacheEntry, _flags, intx) \ | |
395 \ | |
396 /********************************/ \ | |
397 /* MethodOop-related structures */ \ | |
398 /********************************/ \ | |
399 \ | |
400 nonstatic_field(CheckedExceptionElement, class_cp_index, u2) \ | |
401 nonstatic_field(LocalVariableTableElement, start_bci, u2) \ | |
402 nonstatic_field(LocalVariableTableElement, length, u2) \ | |
403 nonstatic_field(LocalVariableTableElement, name_cp_index, u2) \ | |
404 nonstatic_field(LocalVariableTableElement, descriptor_cp_index, u2) \ | |
405 nonstatic_field(LocalVariableTableElement, signature_cp_index, u2) \ | |
406 nonstatic_field(LocalVariableTableElement, slot, u2) \ | |
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
407 nonstatic_field(ExceptionTableElement, start_pc, u2) \ |
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
408 nonstatic_field(ExceptionTableElement, end_pc, u2) \ |
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
409 nonstatic_field(ExceptionTableElement, handler_pc, u2) \ |
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
410 nonstatic_field(ExceptionTableElement, catch_type_index, u2) \ |
0 | 411 nonstatic_field(BreakpointInfo, _orig_bytecode, Bytecodes::Code) \ |
412 nonstatic_field(BreakpointInfo, _bci, int) \ | |
413 nonstatic_field(BreakpointInfo, _name_index, u2) \ | |
414 nonstatic_field(BreakpointInfo, _signature_index, u2) \ | |
415 nonstatic_field(BreakpointInfo, _next, BreakpointInfo*) \ | |
416 /***********/ \ | |
417 /* JNI IDs */ \ | |
418 /***********/ \ | |
419 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
420 nonstatic_field(JNIid, _holder, Klass*) \ |
0 | 421 nonstatic_field(JNIid, _next, JNIid*) \ |
422 nonstatic_field(JNIid, _offset, int) \ | |
423 /************/ \ | |
424 /* Universe */ \ | |
425 /************/ \ | |
426 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
427 static_field(Universe, _boolArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
428 static_field(Universe, _byteArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
429 static_field(Universe, _charArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
430 static_field(Universe, _intArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
431 static_field(Universe, _shortArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
432 static_field(Universe, _longArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
433 static_field(Universe, _singleArrayKlassObj, Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
434 static_field(Universe, _doubleArrayKlassObj, Klass*) \ |
3939 | 435 static_field(Universe, _mirrors[0], oop) \ |
0 | 436 static_field(Universe, _main_thread_group, oop) \ |
437 static_field(Universe, _system_thread_group, oop) \ | |
438 static_field(Universe, _the_empty_class_klass_array, objArrayOop) \ | |
439 static_field(Universe, _out_of_memory_error_java_heap, oop) \ | |
440 static_field(Universe, _out_of_memory_error_perm_gen, oop) \ | |
441 static_field(Universe, _out_of_memory_error_array_size, oop) \ | |
442 static_field(Universe, _out_of_memory_error_gc_overhead_limit, oop) \ | |
443 static_field(Universe, _null_ptr_exception_instance, oop) \ | |
444 static_field(Universe, _arithmetic_exception_instance, oop) \ | |
445 static_field(Universe, _vm_exception, oop) \ | |
446 static_field(Universe, _collectedHeap, CollectedHeap*) \ | |
447 static_field(Universe, _base_vtable_size, int) \ | |
448 static_field(Universe, _bootstrapping, bool) \ | |
449 static_field(Universe, _fully_initialized, bool) \ | |
450 static_field(Universe, _verify_count, int) \ | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
365
diff
changeset
|
451 static_field(Universe, _narrow_oop._base, address) \ |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
365
diff
changeset
|
452 static_field(Universe, _narrow_oop._shift, int) \ |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
365
diff
changeset
|
453 static_field(Universe, _narrow_oop._use_implicit_null_checks, bool) \ |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
454 static_field(Universe, _narrow_klass._base, address) \ |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
455 static_field(Universe, _narrow_klass._shift, int) \ |
0 | 456 \ |
457 /**********************************************************************************/ \ | |
458 /* Generation and Space hierarchies */ \ | |
459 /**********************************************************************************/ \ | |
460 \ | |
461 unchecked_nonstatic_field(ageTable, sizes, sizeof(ageTable::sizes)) \ | |
462 \ | |
463 nonstatic_field(BarrierSet, _max_covered_regions, int) \ | |
464 nonstatic_field(BlockOffsetTable, _bottom, HeapWord*) \ | |
465 nonstatic_field(BlockOffsetTable, _end, HeapWord*) \ | |
466 \ | |
467 nonstatic_field(BlockOffsetSharedArray, _reserved, MemRegion) \ | |
468 nonstatic_field(BlockOffsetSharedArray, _end, HeapWord*) \ | |
469 nonstatic_field(BlockOffsetSharedArray, _vs, VirtualSpace) \ | |
470 nonstatic_field(BlockOffsetSharedArray, _offset_array, u_char*) \ | |
471 \ | |
472 nonstatic_field(BlockOffsetArray, _array, BlockOffsetSharedArray*) \ | |
473 nonstatic_field(BlockOffsetArray, _sp, Space*) \ | |
474 nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_threshold, HeapWord*) \ | |
475 nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_index, size_t) \ | |
476 \ | |
477 nonstatic_field(BlockOffsetArrayNonContigSpace, _unallocated_block, HeapWord*) \ | |
478 \ | |
479 nonstatic_field(CardGeneration, _rs, GenRemSet*) \ | |
480 nonstatic_field(CardGeneration, _bts, BlockOffsetSharedArray*) \ | |
9072
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8712
diff
changeset
|
481 nonstatic_field(CardGeneration, _shrink_factor, size_t) \ |
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8712
diff
changeset
|
482 nonstatic_field(CardGeneration, _capacity_at_prologue, size_t) \ |
8617e38bb4cb
8008508: CMS does not correctly reduce heap size after a Full GC
jmasa
parents:
8712
diff
changeset
|
483 nonstatic_field(CardGeneration, _used_at_prologue, size_t) \ |
0 | 484 \ |
485 nonstatic_field(CardTableModRefBS, _whole_heap, const MemRegion) \ | |
486 nonstatic_field(CardTableModRefBS, _guard_index, const size_t) \ | |
487 nonstatic_field(CardTableModRefBS, _last_valid_index, const size_t) \ | |
488 nonstatic_field(CardTableModRefBS, _page_size, const size_t) \ | |
489 nonstatic_field(CardTableModRefBS, _byte_map_size, const size_t) \ | |
490 nonstatic_field(CardTableModRefBS, _byte_map, jbyte*) \ | |
491 nonstatic_field(CardTableModRefBS, _cur_covered_regions, int) \ | |
492 nonstatic_field(CardTableModRefBS, _covered, MemRegion*) \ | |
493 nonstatic_field(CardTableModRefBS, _committed, MemRegion*) \ | |
494 nonstatic_field(CardTableModRefBS, _guard_region, MemRegion) \ | |
495 nonstatic_field(CardTableModRefBS, byte_map_base, jbyte*) \ | |
496 \ | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
497 nonstatic_field(CardTableRS, _ct_bs, CardTableModRefBSForCTRS*) \ |
0 | 498 \ |
499 nonstatic_field(CollectedHeap, _reserved, MemRegion) \ | |
500 nonstatic_field(CollectedHeap, _barrier_set, BarrierSet*) \ | |
1166 | 501 nonstatic_field(CollectedHeap, _defer_initial_card_mark, bool) \ |
0 | 502 nonstatic_field(CollectedHeap, _is_gc_active, bool) \ |
503 nonstatic_field(CompactibleSpace, _compaction_top, HeapWord*) \ | |
504 nonstatic_field(CompactibleSpace, _first_dead, HeapWord*) \ | |
505 nonstatic_field(CompactibleSpace, _end_of_live, HeapWord*) \ | |
506 \ | |
507 \ | |
508 nonstatic_field(ContiguousSpace, _top, HeapWord*) \ | |
509 nonstatic_field(ContiguousSpace, _concurrent_iteration_safe_limit, HeapWord*) \ | |
510 nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \ | |
511 \ | |
512 nonstatic_field(DefNewGeneration, _next_gen, Generation*) \ | |
6818 | 513 nonstatic_field(DefNewGeneration, _tenuring_threshold, uint) \ |
0 | 514 nonstatic_field(DefNewGeneration, _age_table, ageTable) \ |
515 nonstatic_field(DefNewGeneration, _eden_space, EdenSpace*) \ | |
516 nonstatic_field(DefNewGeneration, _from_space, ContiguousSpace*) \ | |
517 nonstatic_field(DefNewGeneration, _to_space, ContiguousSpace*) \ | |
518 \ | |
519 nonstatic_field(EdenSpace, _gen, DefNewGeneration*) \ | |
520 \ | |
521 nonstatic_field(Generation, _reserved, MemRegion) \ | |
522 nonstatic_field(Generation, _virtual_space, VirtualSpace) \ | |
523 nonstatic_field(Generation, _level, int) \ | |
524 nonstatic_field(Generation, _stat_record, Generation::StatRecord) \ | |
525 \ | |
526 nonstatic_field(Generation::StatRecord, invocations, int) \ | |
527 nonstatic_field(Generation::StatRecord, accumulated_time, elapsedTimer) \ | |
528 \ | |
529 nonstatic_field(GenerationSpec, _name, Generation::Name) \ | |
530 nonstatic_field(GenerationSpec, _init_size, size_t) \ | |
531 nonstatic_field(GenerationSpec, _max_size, size_t) \ | |
532 \ | |
533 static_field(GenCollectedHeap, _gch, GenCollectedHeap*) \ | |
534 nonstatic_field(GenCollectedHeap, _n_gens, int) \ | |
535 unchecked_nonstatic_field(GenCollectedHeap, _gens, sizeof(GenCollectedHeap::_gens)) /* NOTE: no type */ \ | |
536 nonstatic_field(GenCollectedHeap, _gen_specs, GenerationSpec**) \ | |
537 \ | |
538 nonstatic_field(HeapWord, i, char*) \ | |
539 \ | |
540 nonstatic_field(MemRegion, _start, HeapWord*) \ | |
541 nonstatic_field(MemRegion, _word_size, size_t) \ | |
542 \ | |
543 nonstatic_field(OffsetTableContigSpace, _offsets, BlockOffsetArray) \ | |
544 \ | |
545 nonstatic_field(OneContigSpaceCardGeneration, _min_heap_delta_bytes, size_t) \ | |
546 nonstatic_field(OneContigSpaceCardGeneration, _the_space, ContiguousSpace*) \ | |
547 nonstatic_field(OneContigSpaceCardGeneration, _last_gc, WaterMark) \ | |
548 \ | |
549 \ | |
550 \ | |
551 nonstatic_field(Space, _bottom, HeapWord*) \ | |
552 nonstatic_field(Space, _end, HeapWord*) \ | |
553 \ | |
554 nonstatic_field(ThreadLocalAllocBuffer, _start, HeapWord*) \ | |
555 nonstatic_field(ThreadLocalAllocBuffer, _top, HeapWord*) \ | |
556 nonstatic_field(ThreadLocalAllocBuffer, _end, HeapWord*) \ | |
557 nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \ | |
558 nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \ | |
559 static_field(ThreadLocalAllocBuffer, _target_refills, unsigned) \ | |
560 nonstatic_field(VirtualSpace, _low_boundary, char*) \ | |
561 nonstatic_field(VirtualSpace, _high_boundary, char*) \ | |
562 nonstatic_field(VirtualSpace, _low, char*) \ | |
563 nonstatic_field(VirtualSpace, _high, char*) \ | |
564 nonstatic_field(VirtualSpace, _lower_high, char*) \ | |
565 nonstatic_field(VirtualSpace, _middle_high, char*) \ | |
566 nonstatic_field(VirtualSpace, _upper_high, char*) \ | |
567 nonstatic_field(WaterMark, _point, HeapWord*) \ | |
568 nonstatic_field(WaterMark, _space, Space*) \ | |
569 \ | |
570 /************************/ \ | |
571 /* PerfMemory - jvmstat */ \ | |
572 /************************/ \ | |
573 \ | |
574 nonstatic_field(PerfDataPrologue, magic, jint) \ | |
575 nonstatic_field(PerfDataPrologue, byte_order, jbyte) \ | |
576 nonstatic_field(PerfDataPrologue, major_version, jbyte) \ | |
577 nonstatic_field(PerfDataPrologue, minor_version, jbyte) \ | |
578 nonstatic_field(PerfDataPrologue, accessible, jbyte) \ | |
579 nonstatic_field(PerfDataPrologue, used, jint) \ | |
580 nonstatic_field(PerfDataPrologue, overflow, jint) \ | |
581 nonstatic_field(PerfDataPrologue, mod_time_stamp, jlong) \ | |
582 nonstatic_field(PerfDataPrologue, entry_offset, jint) \ | |
583 nonstatic_field(PerfDataPrologue, num_entries, jint) \ | |
584 \ | |
585 nonstatic_field(PerfDataEntry, entry_length, jint) \ | |
586 nonstatic_field(PerfDataEntry, name_offset, jint) \ | |
587 nonstatic_field(PerfDataEntry, vector_length, jint) \ | |
588 nonstatic_field(PerfDataEntry, data_type, jbyte) \ | |
589 nonstatic_field(PerfDataEntry, flags, jbyte) \ | |
590 nonstatic_field(PerfDataEntry, data_units, jbyte) \ | |
591 nonstatic_field(PerfDataEntry, data_variability, jbyte) \ | |
592 nonstatic_field(PerfDataEntry, data_offset, jint) \ | |
593 \ | |
594 static_field(PerfMemory, _start, char*) \ | |
595 static_field(PerfMemory, _end, char*) \ | |
596 static_field(PerfMemory, _top, char*) \ | |
597 static_field(PerfMemory, _capacity, size_t) \ | |
598 static_field(PerfMemory, _prologue, PerfDataPrologue*) \ | |
599 static_field(PerfMemory, _initialized, jint) \ | |
600 \ | |
601 /***************/ \ | |
602 /* SymbolTable */ \ | |
603 /***************/ \ | |
604 \ | |
605 static_field(SymbolTable, _the_table, SymbolTable*) \ | |
606 \ | |
607 /***************/ \ | |
608 /* StringTable */ \ | |
609 /***************/ \ | |
610 \ | |
611 static_field(StringTable, _the_table, StringTable*) \ | |
612 \ | |
613 /********************/ \ | |
614 /* SystemDictionary */ \ | |
615 /********************/ \ | |
616 \ | |
617 static_field(SystemDictionary, _dictionary, Dictionary*) \ | |
618 static_field(SystemDictionary, _placeholders, PlaceholderTable*) \ | |
619 static_field(SystemDictionary, _shared_dictionary, Dictionary*) \ | |
620 static_field(SystemDictionary, _system_loader_lock_obj, oop) \ | |
621 static_field(SystemDictionary, _loader_constraints, LoaderConstraintTable*) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
622 static_field(SystemDictionary, WK_KLASS(Object_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
623 static_field(SystemDictionary, WK_KLASS(String_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
624 static_field(SystemDictionary, WK_KLASS(Class_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
625 static_field(SystemDictionary, WK_KLASS(Cloneable_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
626 static_field(SystemDictionary, WK_KLASS(ClassLoader_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
627 static_field(SystemDictionary, WK_KLASS(Serializable_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
628 static_field(SystemDictionary, WK_KLASS(System_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
629 static_field(SystemDictionary, WK_KLASS(Throwable_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
630 static_field(SystemDictionary, WK_KLASS(ThreadDeath_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
631 static_field(SystemDictionary, WK_KLASS(Error_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
632 static_field(SystemDictionary, WK_KLASS(Exception_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
633 static_field(SystemDictionary, WK_KLASS(RuntimeException_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
634 static_field(SystemDictionary, WK_KLASS(ClassNotFoundException_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
635 static_field(SystemDictionary, WK_KLASS(NoClassDefFoundError_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
636 static_field(SystemDictionary, WK_KLASS(LinkageError_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
637 static_field(SystemDictionary, WK_KLASS(ClassCastException_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
638 static_field(SystemDictionary, WK_KLASS(ArrayStoreException_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
639 static_field(SystemDictionary, WK_KLASS(VirtualMachineError_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
640 static_field(SystemDictionary, WK_KLASS(OutOfMemoryError_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
641 static_field(SystemDictionary, WK_KLASS(StackOverflowError_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
642 static_field(SystemDictionary, WK_KLASS(ProtectionDomain_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
643 static_field(SystemDictionary, WK_KLASS(AccessControlContext_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
644 static_field(SystemDictionary, WK_KLASS(Reference_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
645 static_field(SystemDictionary, WK_KLASS(SoftReference_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
646 static_field(SystemDictionary, WK_KLASS(WeakReference_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
647 static_field(SystemDictionary, WK_KLASS(FinalReference_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
648 static_field(SystemDictionary, WK_KLASS(PhantomReference_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
649 static_field(SystemDictionary, WK_KLASS(Finalizer_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
650 static_field(SystemDictionary, WK_KLASS(Thread_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
651 static_field(SystemDictionary, WK_KLASS(ThreadGroup_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
652 static_field(SystemDictionary, WK_KLASS(Properties_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
653 static_field(SystemDictionary, WK_KLASS(StringBuffer_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
654 static_field(SystemDictionary, WK_KLASS(MethodHandle_klass), Klass*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
655 static_field(SystemDictionary, _box_klasses[0], Klass*) \ |
0 | 656 static_field(SystemDictionary, _java_system_loader, oop) \ |
657 \ | |
3962
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
658 /*************/ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
659 /* vmSymbols */ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
660 /*************/ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
661 \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
662 static_field(vmSymbols, _symbols[0], Symbol*) \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
663 \ |
0 | 664 /*******************/ \ |
665 /* HashtableBucket */ \ | |
666 /*******************/ \ | |
667 \ | |
6197 | 668 nonstatic_field(HashtableBucket<mtInternal>, _entry, BasicHashtableEntry<mtInternal>*) \ |
0 | 669 \ |
670 /******************/ \ | |
671 /* HashtableEntry */ \ | |
672 /******************/ \ | |
673 \ | |
6197 | 674 nonstatic_field(BasicHashtableEntry<mtInternal>, _next, BasicHashtableEntry<mtInternal>*) \ |
675 nonstatic_field(BasicHashtableEntry<mtInternal>, _hash, unsigned int) \ | |
676 nonstatic_field(IntptrHashtableEntry, _literal, intptr_t) \ | |
0 | 677 \ |
678 /*************/ \ | |
679 /* Hashtable */ \ | |
680 /*************/ \ | |
681 \ | |
6197 | 682 nonstatic_field(BasicHashtable<mtInternal>, _table_size, int) \ |
683 nonstatic_field(BasicHashtable<mtInternal>, _buckets, HashtableBucket<mtInternal>*) \ | |
684 nonstatic_field(BasicHashtable<mtInternal>, _free_list, BasicHashtableEntry<mtInternal>*) \ | |
685 nonstatic_field(BasicHashtable<mtInternal>, _first_free_entry, char*) \ | |
686 nonstatic_field(BasicHashtable<mtInternal>, _end_block, char*) \ | |
687 nonstatic_field(BasicHashtable<mtInternal>, _entry_size, int) \ | |
0 | 688 \ |
689 /*******************/ \ | |
690 /* DictionaryEntry */ \ | |
691 /*******************/ \ | |
692 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
693 nonstatic_field(DictionaryEntry, _loader_data, ClassLoaderData*) \ |
0 | 694 nonstatic_field(DictionaryEntry, _pd_set, ProtectionDomainEntry*) \ |
695 \ | |
696 /********************/ \ | |
697 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
698 nonstatic_field(PlaceholderEntry, _loader_data, ClassLoaderData*) \ |
0 | 699 \ |
700 /**************************/ \ | |
701 /* ProctectionDomainEntry */ \ | |
702 /**************************/ \ | |
703 \ | |
704 nonstatic_field(ProtectionDomainEntry, _next, ProtectionDomainEntry*) \ | |
705 nonstatic_field(ProtectionDomainEntry, _protection_domain, oop) \ | |
706 \ | |
707 /*************************/ \ | |
708 /* LoaderConstraintEntry */ \ | |
709 /*************************/ \ | |
710 \ | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
711 nonstatic_field(LoaderConstraintEntry, _name, Symbol*) \ |
0 | 712 nonstatic_field(LoaderConstraintEntry, _num_loaders, int) \ |
713 nonstatic_field(LoaderConstraintEntry, _max_loaders, int) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
714 nonstatic_field(LoaderConstraintEntry, _loaders, ClassLoaderData**) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
715 \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
716 nonstatic_field(ClassLoaderData, _class_loader, oop) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
717 nonstatic_field(ClassLoaderData, _next, ClassLoaderData*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
718 \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
719 static_field(ClassLoaderDataGraph, _head, ClassLoaderData*) \ |
0 | 720 \ |
3939 | 721 /*******************/ \ |
722 /* GrowableArrays */ \ | |
723 /*******************/ \ | |
724 \ | |
725 nonstatic_field(GenericGrowableArray, _len, int) \ | |
726 nonstatic_field(GenericGrowableArray, _max, int) \ | |
727 nonstatic_field(GenericGrowableArray, _arena, Arena*) \ | |
728 nonstatic_field(GrowableArray<int>, _data, int*) \ | |
729 \ | |
0 | 730 /********************************/ \ |
731 /* CodeCache (NOTE: incomplete) */ \ | |
732 /********************************/ \ | |
733 \ | |
734 static_field(CodeCache, _heap, CodeHeap*) \ | |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
931
diff
changeset
|
735 static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \ |
0 | 736 \ |
737 /*******************************/ \ | |
738 /* CodeHeap (NOTE: incomplete) */ \ | |
739 /*******************************/ \ | |
740 \ | |
741 nonstatic_field(CodeHeap, _memory, VirtualSpace) \ | |
742 nonstatic_field(CodeHeap, _segmap, VirtualSpace) \ | |
743 nonstatic_field(CodeHeap, _log2_segment_size, int) \ | |
744 nonstatic_field(HeapBlock, _header, HeapBlock::Header) \ | |
745 nonstatic_field(HeapBlock::Header, _length, size_t) \ | |
746 nonstatic_field(HeapBlock::Header, _used, bool) \ | |
747 \ | |
748 /**********************************/ \ | |
749 /* Interpreter (NOTE: incomplete) */ \ | |
750 /**********************************/ \ | |
751 \ | |
752 static_field(AbstractInterpreter, _code, StubQueue*) \ | |
753 \ | |
754 /****************************/ \ | |
755 /* Stubs (NOTE: incomplete) */ \ | |
756 /****************************/ \ | |
757 \ | |
758 nonstatic_field(StubQueue, _stub_buffer, address) \ | |
759 nonstatic_field(StubQueue, _buffer_limit, int) \ | |
760 nonstatic_field(StubQueue, _queue_begin, int) \ | |
761 nonstatic_field(StubQueue, _queue_end, int) \ | |
762 nonstatic_field(StubQueue, _number_of_stubs, int) \ | |
763 nonstatic_field(InterpreterCodelet, _size, int) \ | |
764 nonstatic_field(InterpreterCodelet, _description, const char*) \ | |
765 nonstatic_field(InterpreterCodelet, _bytecode, Bytecodes::Code) \ | |
766 \ | |
767 /***********************************/ \ | |
768 /* StubRoutines (NOTE: incomplete) */ \ | |
769 /***********************************/ \ | |
770 \ | |
771 static_field(StubRoutines, _call_stub_return_address, address) \ | |
772 \ | |
773 /***************************************/ \ | |
774 /* PcDesc and other compiled code info */ \ | |
775 /***************************************/ \ | |
776 \ | |
777 nonstatic_field(PcDesc, _pc_offset, int) \ | |
778 nonstatic_field(PcDesc, _scope_decode_offset, int) \ | |
1040
873ec3787992
6892186: SA does not dump debug info for scalar replaced objects
kvn
parents:
993
diff
changeset
|
779 nonstatic_field(PcDesc, _obj_decode_offset, int) \ |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
780 nonstatic_field(PcDesc, _flags, int) \ |
0 | 781 \ |
782 /***************************************************/ \ | |
783 /* CodeBlobs (NOTE: incomplete, but only a little) */ \ | |
784 /***************************************************/ \ | |
785 \ | |
786 nonstatic_field(CodeBlob, _name, const char*) \ | |
787 nonstatic_field(CodeBlob, _size, int) \ | |
788 nonstatic_field(CodeBlob, _header_size, int) \ | |
789 nonstatic_field(CodeBlob, _relocation_size, int) \ | |
1748 | 790 nonstatic_field(CodeBlob, _content_offset, int) \ |
791 nonstatic_field(CodeBlob, _code_offset, int) \ | |
0 | 792 nonstatic_field(CodeBlob, _frame_complete_offset, int) \ |
793 nonstatic_field(CodeBlob, _data_offset, int) \ | |
794 nonstatic_field(CodeBlob, _frame_size, int) \ | |
795 nonstatic_field(CodeBlob, _oop_maps, OopMapSet*) \ | |
796 \ | |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
797 nonstatic_field(RuntimeStub, _caller_must_gc_arguments, bool) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
798 \ |
0 | 799 /**************************************************/ \ |
800 /* NMethods (NOTE: incomplete, but only a little) */ \ | |
801 /**************************************************/ \ | |
802 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
803 nonstatic_field(nmethod, _method, Method*) \ |
0 | 804 nonstatic_field(nmethod, _entry_bci, int) \ |
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
931
diff
changeset
|
805 nonstatic_field(nmethod, _osr_link, nmethod*) \ |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
931
diff
changeset
|
806 nonstatic_field(nmethod, _scavenge_root_link, nmethod*) \ |
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
931
diff
changeset
|
807 nonstatic_field(nmethod, _scavenge_root_state, jbyte) \ |
3388
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2411
diff
changeset
|
808 nonstatic_field(nmethod, _state, unsigned char) \ |
0 | 809 nonstatic_field(nmethod, _exception_offset, int) \ |
810 nonstatic_field(nmethod, _deoptimize_offset, int) \ | |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
811 nonstatic_field(nmethod, _deoptimize_mh_offset, int) \ |
0 | 812 nonstatic_field(nmethod, _orig_pc_offset, int) \ |
813 nonstatic_field(nmethod, _stub_offset, int) \ | |
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1166
diff
changeset
|
814 nonstatic_field(nmethod, _consts_offset, int) \ |
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1166
diff
changeset
|
815 nonstatic_field(nmethod, _oops_offset, int) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
816 nonstatic_field(nmethod, _metadata_offset, int) \ |
0 | 817 nonstatic_field(nmethod, _scopes_data_offset, int) \ |
818 nonstatic_field(nmethod, _scopes_pcs_offset, int) \ | |
819 nonstatic_field(nmethod, _dependencies_offset, int) \ | |
820 nonstatic_field(nmethod, _handler_table_offset, int) \ | |
821 nonstatic_field(nmethod, _nul_chk_table_offset, int) \ | |
822 nonstatic_field(nmethod, _nmethod_end_offset, int) \ | |
823 nonstatic_field(nmethod, _entry_point, address) \ | |
824 nonstatic_field(nmethod, _verified_entry_point, address) \ | |
825 nonstatic_field(nmethod, _osr_entry_point, address) \ | |
826 nonstatic_field(nmethod, _lock_count, jint) \ | |
827 nonstatic_field(nmethod, _stack_traversal_mark, long) \ | |
3388
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2411
diff
changeset
|
828 nonstatic_field(nmethod, _compile_id, int) \ |
3939 | 829 nonstatic_field(nmethod, _exception_cache, ExceptionCache*) \ |
3388
a80577f854f9
7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents:
2411
diff
changeset
|
830 nonstatic_field(nmethod, _marked_for_deoptimization, bool) \ |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
831 \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
832 unchecked_c2_static_field(Deoptimization, _trap_reason_name, void*) \ |
3939 | 833 \ |
0 | 834 /********************************/ \ |
835 /* JavaCalls (NOTE: incomplete) */ \ | |
836 /********************************/ \ | |
837 \ | |
838 nonstatic_field(JavaCallWrapper, _anchor, JavaFrameAnchor) \ | |
839 /********************************/ \ | |
840 /* JavaFrameAnchor (NOTE: incomplete) */ \ | |
841 /********************************/ \ | |
842 volatile_nonstatic_field(JavaFrameAnchor, _last_Java_sp, intptr_t*) \ | |
843 volatile_nonstatic_field(JavaFrameAnchor, _last_Java_pc, address) \ | |
844 \ | |
845 /******************************/ \ | |
846 /* Threads (NOTE: incomplete) */ \ | |
847 /******************************/ \ | |
848 \ | |
849 static_field(Threads, _thread_list, JavaThread*) \ | |
850 static_field(Threads, _number_of_threads, int) \ | |
851 static_field(Threads, _number_of_non_daemon_threads, int) \ | |
852 static_field(Threads, _return_code, int) \ | |
853 \ | |
3939 | 854 nonstatic_field(ThreadShadow, _pending_exception, oop) \ |
855 nonstatic_field(ThreadShadow, _exception_file, const char*) \ | |
856 nonstatic_field(ThreadShadow, _exception_line, int) \ | |
0 | 857 volatile_nonstatic_field(Thread, _suspend_flags, uint32_t) \ |
858 nonstatic_field(Thread, _active_handles, JNIHandleBlock*) \ | |
859 nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \ | |
860 nonstatic_field(Thread, _current_pending_monitor, ObjectMonitor*) \ | |
861 nonstatic_field(Thread, _current_pending_monitor_is_from_java, bool) \ | |
862 nonstatic_field(Thread, _current_waiting_monitor, ObjectMonitor*) \ | |
863 nonstatic_field(NamedThread, _name, char*) \ | |
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1040
diff
changeset
|
864 nonstatic_field(NamedThread, _processed_thread, JavaThread*) \ |
0 | 865 nonstatic_field(JavaThread, _next, JavaThread*) \ |
866 nonstatic_field(JavaThread, _threadObj, oop) \ | |
867 nonstatic_field(JavaThread, _anchor, JavaFrameAnchor) \ | |
3939 | 868 nonstatic_field(JavaThread, _vm_result, oop) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
869 nonstatic_field(JavaThread, _vm_result_2, Metadata*) \ |
3939 | 870 nonstatic_field(JavaThread, _pending_async_exception, oop) \ |
871 volatile_nonstatic_field(JavaThread, _exception_oop, oop) \ | |
872 volatile_nonstatic_field(JavaThread, _exception_pc, address) \ | |
873 nonstatic_field(JavaThread, _is_compiling, bool) \ | |
874 nonstatic_field(JavaThread, _special_runtime_exit_condition, JavaThread::AsyncRequests) \ | |
875 nonstatic_field(JavaThread, _saved_exception_pc, address) \ | |
0 | 876 volatile_nonstatic_field(JavaThread, _thread_state, JavaThreadState) \ |
877 nonstatic_field(JavaThread, _osthread, OSThread*) \ | |
878 nonstatic_field(JavaThread, _stack_base, address) \ | |
879 nonstatic_field(JavaThread, _stack_size, size_t) \ | |
3939 | 880 nonstatic_field(JavaThread, _vframe_array_head, vframeArray*) \ |
881 nonstatic_field(JavaThread, _vframe_array_last, vframeArray*) \ | |
882 nonstatic_field(Thread, _resource_area, ResourceArea*) \ | |
883 nonstatic_field(CompilerThread, _env, ciEnv*) \ | |
0 | 884 \ |
885 /************/ \ | |
886 /* OSThread */ \ | |
887 /************/ \ | |
888 \ | |
2386
083f13976b51
6535709: interrupt of wait()ing thread isn't triggerring InterruptedException - test intwait3
dholmes
parents:
2260
diff
changeset
|
889 volatile_nonstatic_field(OSThread, _interrupted, jint) \ |
0 | 890 \ |
891 /************************/ \ | |
892 /* OopMap and OopMapSet */ \ | |
893 /************************/ \ | |
894 \ | |
895 nonstatic_field(OopMap, _pc_offset, int) \ | |
896 nonstatic_field(OopMap, _omv_count, int) \ | |
897 nonstatic_field(OopMap, _omv_data_size, int) \ | |
898 nonstatic_field(OopMap, _omv_data, unsigned char*) \ | |
899 nonstatic_field(OopMap, _write_stream, CompressedWriteStream*) \ | |
900 nonstatic_field(OopMapSet, _om_count, int) \ | |
901 nonstatic_field(OopMapSet, _om_size, int) \ | |
902 nonstatic_field(OopMapSet, _om_data, OopMap**) \ | |
903 \ | |
904 /*********************************/ \ | |
905 /* JNIHandles and JNIHandleBlock */ \ | |
906 /*********************************/ \ | |
907 static_field(JNIHandles, _global_handles, JNIHandleBlock*) \ | |
908 static_field(JNIHandles, _weak_global_handles, JNIHandleBlock*) \ | |
909 static_field(JNIHandles, _deleted_handle, oop) \ | |
910 \ | |
911 unchecked_nonstatic_field(JNIHandleBlock, _handles, JNIHandleBlock::block_size_in_oops * sizeof(Oop)) /* Note: no type */ \ | |
912 nonstatic_field(JNIHandleBlock, _top, int) \ | |
913 nonstatic_field(JNIHandleBlock, _next, JNIHandleBlock*) \ | |
914 \ | |
915 /********************/ \ | |
916 /* CompressedStream */ \ | |
917 /********************/ \ | |
918 \ | |
919 nonstatic_field(CompressedStream, _buffer, u_char*) \ | |
920 nonstatic_field(CompressedStream, _position, int) \ | |
921 \ | |
922 /*********************************/ \ | |
923 /* VMRegImpl (NOTE: incomplete) */ \ | |
924 /*********************************/ \ | |
925 \ | |
926 static_field(VMRegImpl, regName[0], const char*) \ | |
927 static_field(VMRegImpl, stack0, VMReg) \ | |
928 \ | |
929 /*******************************/ \ | |
930 /* Runtime1 (NOTE: incomplete) */ \ | |
931 /*******************************/ \ | |
932 \ | |
3939 | 933 unchecked_c1_static_field(Runtime1, _blobs, sizeof(Runtime1::_blobs)) /* NOTE: no type */ \ |
934 \ | |
935 /**************/ \ | |
936 /* allocation */ \ | |
937 /**************/ \ | |
938 \ | |
939 nonstatic_field(Chunk, _next, Chunk*) \ | |
940 nonstatic_field(Chunk, _len, const size_t) \ | |
941 \ | |
942 nonstatic_field(Arena, _first, Chunk*) \ | |
943 nonstatic_field(Arena, _chunk, Chunk*) \ | |
944 nonstatic_field(Arena, _hwm, char*) \ | |
945 nonstatic_field(Arena, _max, char*) \ | |
946 \ | |
947 /************/ \ | |
948 /* CI */ \ | |
949 /************/ \ | |
950 \ | |
951 nonstatic_field(ciEnv, _system_dictionary_modification_counter, int) \ | |
952 nonstatic_field(ciEnv, _compiler_data, void*) \ | |
953 nonstatic_field(ciEnv, _failure_reason, const char*) \ | |
954 nonstatic_field(ciEnv, _factory, ciObjectFactory*) \ | |
955 nonstatic_field(ciEnv, _dependencies, Dependencies*) \ | |
956 nonstatic_field(ciEnv, _task, CompileTask*) \ | |
957 nonstatic_field(ciEnv, _arena, Arena*) \ | |
958 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
959 nonstatic_field(ciBaseObject, _ident, uint) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
960 \ |
3939 | 961 nonstatic_field(ciObject, _handle, jobject) \ |
962 nonstatic_field(ciObject, _klass, ciKlass*) \ | |
963 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
964 nonstatic_field(ciMetadata, _metadata, Metadata*) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
965 \ |
3939 | 966 nonstatic_field(ciSymbol, _symbol, Symbol*) \ |
967 \ | |
968 nonstatic_field(ciType, _basic_type, BasicType) \ | |
969 \ | |
970 nonstatic_field(ciKlass, _name, ciSymbol*) \ | |
971 \ | |
972 nonstatic_field(ciArrayKlass, _dimension, jint) \ | |
973 \ | |
974 nonstatic_field(ciObjArrayKlass, _element_klass, ciKlass*) \ | |
975 nonstatic_field(ciObjArrayKlass, _base_element_klass, ciKlass*) \ | |
976 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
977 nonstatic_field(ciInstanceKlass, _init_state, InstanceKlass::ClassState) \ |
3939 | 978 nonstatic_field(ciInstanceKlass, _is_shared, bool) \ |
979 \ | |
980 nonstatic_field(ciMethod, _interpreter_invocation_count, int) \ | |
981 nonstatic_field(ciMethod, _interpreter_throwout_count, int) \ | |
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6940
diff
changeset
|
982 nonstatic_field(ciMethod, _instructions_size, int) \ |
3939 | 983 \ |
984 nonstatic_field(ciMethodData, _data_size, int) \ | |
985 nonstatic_field(ciMethodData, _state, u_char) \ | |
986 nonstatic_field(ciMethodData, _extra_data_size, int) \ | |
987 nonstatic_field(ciMethodData, _data, intptr_t*) \ | |
988 nonstatic_field(ciMethodData, _hint_di, int) \ | |
989 nonstatic_field(ciMethodData, _eflags, intx) \ | |
990 nonstatic_field(ciMethodData, _arg_local, intx) \ | |
991 nonstatic_field(ciMethodData, _arg_stack, intx) \ | |
992 nonstatic_field(ciMethodData, _arg_returned, intx) \ | |
993 nonstatic_field(ciMethodData, _current_mileage, int) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
994 nonstatic_field(ciMethodData, _orig, MethodData) \ |
3939 | 995 \ |
996 nonstatic_field(ciField, _holder, ciInstanceKlass*) \ | |
997 nonstatic_field(ciField, _name, ciSymbol*) \ | |
998 nonstatic_field(ciField, _signature, ciSymbol*) \ | |
999 nonstatic_field(ciField, _offset, int) \ | |
1000 nonstatic_field(ciField, _is_constant, bool) \ | |
1001 nonstatic_field(ciField, _constant_value, ciConstant) \ | |
1002 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1003 nonstatic_field(ciObjectFactory, _ci_metadata, GrowableArray<ciMetadata*>*) \ |
3939 | 1004 nonstatic_field(ciObjectFactory, _symbols, GrowableArray<ciSymbol*>*) \ |
1005 nonstatic_field(ciObjectFactory, _unloaded_methods, GrowableArray<ciMethod*>*) \ | |
1006 \ | |
1007 nonstatic_field(ciConstant, _type, BasicType) \ | |
1008 nonstatic_field(ciConstant, _value._int, jint) \ | |
1009 nonstatic_field(ciConstant, _value._long, jlong) \ | |
1010 nonstatic_field(ciConstant, _value._float, jfloat) \ | |
1011 nonstatic_field(ciConstant, _value._double, jdouble) \ | |
1012 nonstatic_field(ciConstant, _value._object, ciObject*) \ | |
0 | 1013 \ |
1014 /************/ \ | |
1015 /* Monitors */ \ | |
1016 /************/ \ | |
1017 \ | |
1018 volatile_nonstatic_field(ObjectMonitor, _header, markOop) \ | |
1019 unchecked_nonstatic_field(ObjectMonitor, _object, sizeof(void *)) /* NOTE: no type */ \ | |
1020 unchecked_nonstatic_field(ObjectMonitor, _owner, sizeof(void *)) /* NOTE: no type */ \ | |
1021 volatile_nonstatic_field(ObjectMonitor, _count, intptr_t) \ | |
1022 volatile_nonstatic_field(ObjectMonitor, _waiters, intptr_t) \ | |
1023 volatile_nonstatic_field(ObjectMonitor, _recursions, intptr_t) \ | |
1024 nonstatic_field(ObjectMonitor, FreeNext, ObjectMonitor*) \ | |
1025 volatile_nonstatic_field(BasicLock, _displaced_header, markOop) \ | |
1026 nonstatic_field(BasicObjectLock, _lock, BasicLock) \ | |
1027 nonstatic_field(BasicObjectLock, _obj, oop) \ | |
1028 static_field(ObjectSynchronizer, gBlockList, ObjectMonitor*) \ | |
1029 \ | |
1030 /*********************/ \ | |
1031 /* Matcher (C2 only) */ \ | |
1032 /*********************/ \ | |
1033 \ | |
3939 | 1034 unchecked_c2_static_field(Matcher, _regEncode, sizeof(Matcher::_regEncode)) /* NOTE: no type */ \ |
1035 \ | |
1036 c2_nonstatic_field(Node, _in, Node**) \ | |
1037 c2_nonstatic_field(Node, _out, Node**) \ | |
1038 c2_nonstatic_field(Node, _cnt, node_idx_t) \ | |
1039 c2_nonstatic_field(Node, _max, node_idx_t) \ | |
1040 c2_nonstatic_field(Node, _outcnt, node_idx_t) \ | |
1041 c2_nonstatic_field(Node, _outmax, node_idx_t) \ | |
1042 c2_nonstatic_field(Node, _idx, const node_idx_t) \ | |
1043 c2_nonstatic_field(Node, _class_id, jushort) \ | |
1044 c2_nonstatic_field(Node, _flags, jushort) \ | |
1045 \ | |
1046 c2_nonstatic_field(Compile, _root, RootNode*) \ | |
1047 c2_nonstatic_field(Compile, _unique, uint) \ | |
1048 c2_nonstatic_field(Compile, _entry_bci, int) \ | |
1049 c2_nonstatic_field(Compile, _top, Node*) \ | |
1050 c2_nonstatic_field(Compile, _cfg, PhaseCFG*) \ | |
1051 c2_nonstatic_field(Compile, _regalloc, PhaseRegAlloc*) \ | |
1052 c2_nonstatic_field(Compile, _method, ciMethod*) \ | |
1053 c2_nonstatic_field(Compile, _compile_id, const int) \ | |
1054 c2_nonstatic_field(Compile, _save_argument_registers, const bool) \ | |
1055 c2_nonstatic_field(Compile, _subsume_loads, const bool) \ | |
1056 c2_nonstatic_field(Compile, _do_escape_analysis, const bool) \ | |
1057 c2_nonstatic_field(Compile, _ilt, InlineTree*) \ | |
1058 \ | |
1059 c2_nonstatic_field(InlineTree, _caller_jvms, JVMState*) \ | |
1060 c2_nonstatic_field(InlineTree, _method, ciMethod*) \ | |
1061 c2_nonstatic_field(InlineTree, _caller_tree, InlineTree*) \ | |
1062 c2_nonstatic_field(InlineTree, _subtrees, GrowableArray<InlineTree*>) \ | |
1063 \ | |
1064 c2_nonstatic_field(OptoRegPair, _first, short) \ | |
1065 c2_nonstatic_field(OptoRegPair, _second, short) \ | |
1066 \ | |
1067 c2_nonstatic_field(JVMState, _caller, JVMState*) \ | |
1068 c2_nonstatic_field(JVMState, _depth, uint) \ | |
1069 c2_nonstatic_field(JVMState, _locoff, uint) \ | |
1070 c2_nonstatic_field(JVMState, _stkoff, uint) \ | |
1071 c2_nonstatic_field(JVMState, _monoff, uint) \ | |
1072 c2_nonstatic_field(JVMState, _scloff, uint) \ | |
1073 c2_nonstatic_field(JVMState, _endoff, uint) \ | |
1074 c2_nonstatic_field(JVMState, _sp, uint) \ | |
1075 c2_nonstatic_field(JVMState, _bci, int) \ | |
1076 c2_nonstatic_field(JVMState, _method, ciMethod*) \ | |
1077 c2_nonstatic_field(JVMState, _map, SafePointNode*) \ | |
1078 \ | |
1079 c2_nonstatic_field(SafePointNode, _jvms, JVMState* const) \ | |
1080 \ | |
1081 c2_nonstatic_field(MachSafePointNode, _jvms, JVMState*) \ | |
1082 c2_nonstatic_field(MachSafePointNode, _jvmadj, uint) \ | |
1083 \ | |
1084 c2_nonstatic_field(MachIfNode, _prob, jfloat) \ | |
1085 c2_nonstatic_field(MachIfNode, _fcnt, jfloat) \ | |
1086 \ | |
1087 c2_nonstatic_field(CallNode, _entry_point, address) \ | |
1088 \ | |
1089 c2_nonstatic_field(CallJavaNode, _method, ciMethod*) \ | |
1090 \ | |
1091 c2_nonstatic_field(CallRuntimeNode, _name, const char*) \ | |
1092 \ | |
1093 c2_nonstatic_field(CallStaticJavaNode, _name, const char*) \ | |
1094 \ | |
1095 c2_nonstatic_field(MachCallJavaNode, _method, ciMethod*) \ | |
1096 c2_nonstatic_field(MachCallJavaNode, _bci, int) \ | |
1097 \ | |
1098 c2_nonstatic_field(MachCallStaticJavaNode, _name, const char*) \ | |
1099 \ | |
1100 c2_nonstatic_field(MachCallRuntimeNode, _name, const char*) \ | |
1101 \ | |
1102 c2_nonstatic_field(PhaseCFG, _num_blocks, uint) \ | |
1103 c2_nonstatic_field(PhaseCFG, _blocks, Block_List) \ | |
1104 c2_nonstatic_field(PhaseCFG, _bbs, Block_Array) \ | |
1105 c2_nonstatic_field(PhaseCFG, _broot, Block*) \ | |
1106 \ | |
1107 c2_nonstatic_field(PhaseRegAlloc, _node_regs, OptoRegPair*) \ | |
1108 c2_nonstatic_field(PhaseRegAlloc, _node_regs_max_index, uint) \ | |
1109 c2_nonstatic_field(PhaseRegAlloc, _framesize, uint) \ | |
1110 c2_nonstatic_field(PhaseRegAlloc, _max_reg, OptoReg::Name) \ | |
1111 \ | |
1112 c2_nonstatic_field(PhaseChaitin, _trip_cnt, int) \ | |
1113 c2_nonstatic_field(PhaseChaitin, _alternate, int) \ | |
1114 c2_nonstatic_field(PhaseChaitin, _lo_degree, uint) \ | |
1115 c2_nonstatic_field(PhaseChaitin, _lo_stk_degree, uint) \ | |
1116 c2_nonstatic_field(PhaseChaitin, _hi_degree, uint) \ | |
1117 c2_nonstatic_field(PhaseChaitin, _simplified, uint) \ | |
1118 c2_nonstatic_field(PhaseChaitin, _maxlrg, uint) \ | |
1119 \ | |
1120 c2_nonstatic_field(Block, _nodes, Node_List) \ | |
1121 c2_nonstatic_field(Block, _succs, Block_Array) \ | |
1122 c2_nonstatic_field(Block, _num_succs, uint) \ | |
1123 c2_nonstatic_field(Block, _pre_order, uint) \ | |
1124 c2_nonstatic_field(Block, _dom_depth, uint) \ | |
1125 c2_nonstatic_field(Block, _idom, Block*) \ | |
1126 c2_nonstatic_field(Block, _freq, jfloat) \ | |
1127 \ | |
1128 c2_nonstatic_field(CFGElement, _freq, jfloat) \ | |
1129 \ | |
1130 c2_nonstatic_field(Block_List, _cnt, uint) \ | |
1131 \ | |
1132 c2_nonstatic_field(Block_Array, _size, uint) \ | |
1133 c2_nonstatic_field(Block_Array, _blocks, Block**) \ | |
1134 c2_nonstatic_field(Block_Array, _arena, Arena*) \ | |
1135 \ | |
1136 c2_nonstatic_field(Node_List, _cnt, uint) \ | |
1137 \ | |
1138 c2_nonstatic_field(Node_Array, _max, uint) \ | |
1139 c2_nonstatic_field(Node_Array, _nodes, Node**) \ | |
1140 c2_nonstatic_field(Node_Array, _a, Arena*) \ | |
1141 \ | |
0 | 1142 \ |
1143 /*********************/ \ | |
1144 /* -XX flags */ \ | |
1145 /*********************/ \ | |
1146 \ | |
1147 nonstatic_field(Flag, type, const char*) \ | |
1148 nonstatic_field(Flag, name, const char*) \ | |
1149 unchecked_nonstatic_field(Flag, addr, sizeof(void*)) /* NOTE: no type */ \ | |
1150 nonstatic_field(Flag, kind, const char*) \ | |
3939 | 1151 nonstatic_field(Flag, origin, FlagValueOrigin) \ |
0 | 1152 static_field(Flag, flags, Flag*) \ |
1153 static_field(Flag, numFlags, size_t) \ | |
1154 \ | |
1155 /*************************/ \ | |
1156 /* JDK / VM version info */ \ | |
1157 /*************************/ \ | |
1158 \ | |
1159 static_field(Abstract_VM_Version, _s_vm_release, const char*) \ | |
1160 static_field(Abstract_VM_Version, _s_internal_vm_info_string, const char*) \ | |
1161 static_field(Abstract_VM_Version, _vm_major_version, int) \ | |
1162 static_field(Abstract_VM_Version, _vm_minor_version, int) \ | |
1163 static_field(Abstract_VM_Version, _vm_build_number, int) \ | |
8005
ec0c4951286c
8004710: NPG: jmap could throw sun.jvm.hotspot.types.WrongTypeException after PermGen removal
stefank
parents:
7947
diff
changeset
|
1164 static_field(Abstract_VM_Version, _reserve_for_allocation_prefetch, int) \ |
0 | 1165 \ |
242 | 1166 static_field(JDK_Version, _current, JDK_Version) \ |
1167 nonstatic_field(JDK_Version, _partially_initialized, bool) \ | |
1168 nonstatic_field(JDK_Version, _major, unsigned char) \ | |
0 | 1169 \ |
3939 | 1170 /*************************/ \ |
1171 /* JVMTI */ \ | |
1172 /*************************/ \ | |
0 | 1173 \ |
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6818
diff
changeset
|
1174 JVMTI_STRUCTS(static_field) \ |
0 | 1175 \ |
1176 /*************/ \ | |
1177 /* Arguments */ \ | |
1178 /*************/ \ | |
1179 \ | |
1180 static_field(Arguments, _jvm_flags_array, char**) \ | |
1181 static_field(Arguments, _num_jvm_flags, int) \ | |
1182 static_field(Arguments, _jvm_args_array, char**) \ | |
1183 static_field(Arguments, _num_jvm_args, int) \ | |
1184 static_field(Arguments, _java_command, char*) \ | |
1185 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1186 /************/ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1187 /* Array<T> */ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1188 /************/ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1189 \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1190 nonstatic_field(Array<int>, _length, int) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1191 unchecked_nonstatic_field(Array<int>, _data, sizeof(int)) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1192 unchecked_nonstatic_field(Array<u1>, _data, sizeof(u1)) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1193 unchecked_nonstatic_field(Array<u2>, _data, sizeof(u2)) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1194 unchecked_nonstatic_field(Array<Method*>, _data, sizeof(Method*)) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1195 unchecked_nonstatic_field(Array<Klass*>, _data, sizeof(Klass*)) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1196 \ |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2260
diff
changeset
|
1197 /*********************************/ \ |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2260
diff
changeset
|
1198 /* java_lang_Class fields */ \ |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2260
diff
changeset
|
1199 /*********************************/ \ |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2260
diff
changeset
|
1200 \ |
3938 | 1201 static_field(java_lang_Class, _klass_offset, int) \ |
1202 static_field(java_lang_Class, _array_klass_offset, int) \ | |
1203 static_field(java_lang_Class, _oop_size_offset, int) \ | |
1204 static_field(java_lang_Class, _static_oop_field_count_offset, int) \ | |
0 | 1205 \ |
1206 /************************/ \ | |
1207 /* Miscellaneous fields */ \ | |
1208 /************************/ \ | |
1209 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1210 nonstatic_field(CompileTask, _method, Method*) \ |
3939 | 1211 nonstatic_field(CompileTask, _osr_bci, int) \ |
1212 nonstatic_field(CompileTask, _comp_level, int) \ | |
1213 nonstatic_field(CompileTask, _compile_id, uint) \ | |
1214 nonstatic_field(CompileTask, _next, CompileTask*) \ | |
1215 nonstatic_field(CompileTask, _prev, CompileTask*) \ | |
1216 \ | |
1217 nonstatic_field(vframeArray, _next, vframeArray*) \ | |
1218 nonstatic_field(vframeArray, _original, frame) \ | |
1219 nonstatic_field(vframeArray, _caller, frame) \ | |
1220 nonstatic_field(vframeArray, _frames, int) \ | |
1221 \ | |
1222 nonstatic_field(vframeArrayElement, _frame, frame) \ | |
1223 nonstatic_field(vframeArrayElement, _bci, int) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1224 nonstatic_field(vframeArrayElement, _method, Method*) \ |
3939 | 1225 \ |
1226 nonstatic_field(AccessFlags, _flags, jint) \ | |
1227 nonstatic_field(elapsedTimer, _counter, jlong) \ | |
1228 nonstatic_field(elapsedTimer, _active, bool) \ | |
6885 | 1229 nonstatic_field(InvocationCounter, _counter, unsigned int) \ |
1230 volatile_nonstatic_field(FreeChunk, _size, size_t) \ | |
1231 nonstatic_field(FreeChunk, _next, FreeChunk*) \ | |
1232 nonstatic_field(FreeChunk, _prev, FreeChunk*) \ | |
1233 nonstatic_field(FreeList<FreeChunk>, _size, size_t) \ | |
1234 nonstatic_field(FreeList<Metablock>, _size, size_t) \ | |
1235 nonstatic_field(FreeList<FreeChunk>, _count, ssize_t) \ | |
1236 nonstatic_field(FreeList<Metablock>, _count, ssize_t) \ | |
1237 nonstatic_field(MetablockTreeDictionary, _total_size, size_t) | |
0 | 1238 |
1239 | |
1240 //-------------------------------------------------------------------------------- | |
1241 // VM_TYPES | |
1242 // | |
1243 // This list must enumerate at least all of the types in the above | |
1244 // list. For the types in the above list, the entry below must have | |
1245 // exactly the same spacing since string comparisons are done in the | |
1246 // code which verifies the consistency of these tables (in the debug | |
1247 // build). | |
1248 // | |
1249 // In addition to the above types, this list is required to enumerate | |
1250 // the JNI's java types, which are used to indicate the size of Java | |
1251 // fields in this VM to the SA. Further, oop types are currently | |
1252 // distinguished by name (i.e., ends with "oop") over in the SA. | |
1253 // | |
1254 // The declare_toplevel_type macro should be used to declare types | |
1255 // which do not have a superclass. | |
1256 // | |
1257 // The declare_integer_type and declare_unsigned_integer_type macros | |
1258 // are required in order to properly identify C integer types over in | |
1259 // the SA. They should be used for any type which is otherwise opaque | |
1260 // and which it is necessary to coerce into an integer value. This | |
1261 // includes, for example, the type uintptr_t. Note that while they | |
1262 // will properly identify the type's size regardless of the platform, | |
1263 // since it is does not seem possible to deduce or check signedness at | |
1264 // compile time using the pointer comparison tricks, it is currently | |
1265 // required that the given types have the same signedness across all | |
1266 // platforms. | |
1267 // | |
1268 // NOTE that there are platform-specific additions to this table in | |
1269 // vmStructs_<os>_<cpu>.hpp. | |
1270 | |
1271 #define VM_TYPES(declare_type, \ | |
1272 declare_toplevel_type, \ | |
1273 declare_oop_type, \ | |
1274 declare_integer_type, \ | |
1275 declare_unsigned_integer_type, \ | |
1276 declare_c1_toplevel_type, \ | |
1277 declare_c2_type, \ | |
7583 | 1278 declare_c2_toplevel_type) \ |
0 | 1279 \ |
1280 /*************************************************************/ \ | |
1281 /* Java primitive types -- required by the SA implementation */ \ | |
1282 /* in order to determine the size of Java fields in this VM */ \ | |
1283 /* (the implementation looks up these names specifically) */ \ | |
1284 /* NOTE: since we fetch these sizes from the remote VM, we */ \ | |
1285 /* have a bootstrapping sequence during which it is not */ \ | |
1286 /* valid to fetch Java values from the remote process, only */ \ | |
1287 /* C integer values (of known size). NOTE also that we do */ \ | |
1288 /* NOT include "Java unsigned" types like juint here; since */ \ | |
1289 /* Java does not have unsigned primitive types, those can */ \ | |
1290 /* not be mapped directly and are considered to be C integer */ \ | |
1291 /* types in this system (see the "other types" section, */ \ | |
1292 /* below.) */ \ | |
1293 /*************************************************************/ \ | |
1294 \ | |
1295 declare_toplevel_type(jboolean) \ | |
1296 declare_toplevel_type(jbyte) \ | |
1297 declare_toplevel_type(jchar) \ | |
1298 declare_toplevel_type(jdouble) \ | |
1299 declare_toplevel_type(jfloat) \ | |
1300 declare_toplevel_type(jint) \ | |
1301 declare_toplevel_type(jlong) \ | |
1302 declare_toplevel_type(jshort) \ | |
1303 \ | |
1304 /*********************************************************************/ \ | |
1305 /* C integer types. User-defined typedefs (like "size_t" or */ \ | |
1306 /* "intptr_t") are guaranteed to be present with the same names over */ \ | |
1307 /* in the SA's type database. Names like "unsigned short" are not */ \ | |
1308 /* guaranteed to be visible through the SA's type database lookup */ \ | |
1309 /* mechanism, though they will have a Type object created for them */ \ | |
1310 /* and are valid types for Fields. */ \ | |
1311 /*********************************************************************/ \ | |
1312 declare_integer_type(bool) \ | |
3939 | 1313 declare_integer_type(short) \ |
0 | 1314 declare_integer_type(int) \ |
1315 declare_integer_type(long) \ | |
1316 declare_integer_type(char) \ | |
1317 declare_unsigned_integer_type(unsigned char) \ | |
3939 | 1318 declare_unsigned_integer_type(u_char) \ |
0 | 1319 declare_unsigned_integer_type(unsigned int) \ |
3939 | 1320 declare_unsigned_integer_type(uint) \ |
0 | 1321 declare_unsigned_integer_type(unsigned short) \ |
3940 | 1322 declare_unsigned_integer_type(jushort) \ |
0 | 1323 declare_unsigned_integer_type(unsigned long) \ |
1324 /* The compiler thinks this is a different type than */ \ | |
1325 /* unsigned short on Win32 */ \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1326 declare_unsigned_integer_type(u1) \ |
0 | 1327 declare_unsigned_integer_type(u2) \ |
1328 declare_unsigned_integer_type(unsigned) \ | |
1329 \ | |
1330 /*****************************/ \ | |
1331 /* C primitive pointer types */ \ | |
1332 /*****************************/ \ | |
1333 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1334 declare_toplevel_type(void*) \ |
0 | 1335 declare_toplevel_type(int*) \ |
1336 declare_toplevel_type(char*) \ | |
1337 declare_toplevel_type(char**) \ | |
1338 declare_toplevel_type(u_char*) \ | |
1339 declare_toplevel_type(unsigned char*) \ | |
1340 \ | |
1341 /*******************************************************************/ \ | |
1342 /* Types which it will be handy to have available over in the SA */ \ | |
1343 /* in order to do platform-independent address -> integer coercion */ \ | |
1344 /* (note: these will be looked up by name) */ \ | |
1345 /*******************************************************************/ \ | |
1346 \ | |
1347 declare_unsigned_integer_type(size_t) \ | |
152
c70a245cad3a
6670684: 4/5 SA command universe did not print out CMS space information
dcubed
parents:
0
diff
changeset
|
1348 declare_integer_type(ssize_t) \ |
0 | 1349 declare_integer_type(intx) \ |
1350 declare_integer_type(intptr_t) \ | |
1351 declare_unsigned_integer_type(uintx) \ | |
1352 declare_unsigned_integer_type(uintptr_t) \ | |
1353 declare_unsigned_integer_type(uint32_t) \ | |
1354 declare_unsigned_integer_type(uint64_t) \ | |
1355 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1356 /******************************************/ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1357 /* OopDesc hierarchy (NOTE: some missing) */ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1358 /******************************************/ \ |
0 | 1359 \ |
1360 declare_toplevel_type(oopDesc) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1361 declare_type(arrayOopDesc, oopDesc) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1362 declare_type(objArrayOopDesc, arrayOopDesc) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1363 declare_type(instanceOopDesc, oopDesc) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1364 declare_type(markOopDesc, oopDesc) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1365 \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1366 /**************************************************/ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1367 /* MetadataOopDesc hierarchy (NOTE: some missing) */ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1368 /**************************************************/ \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1369 \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1370 declare_toplevel_type(CompiledICHolder) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1371 declare_toplevel_type(MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1372 declare_type(Metadata, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1373 declare_type(Klass, Metadata) \ |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
1374 declare_type(ArrayKlass, Klass) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
1375 declare_type(ObjArrayKlass, ArrayKlass) \ |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6802
diff
changeset
|
1376 declare_type(TypeArrayKlass, ArrayKlass) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1377 declare_type(InstanceKlass, Klass) \ |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
1378 declare_type(InstanceClassLoaderKlass, InstanceKlass) \ |
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
1379 declare_type(InstanceMirrorKlass, InstanceKlass) \ |
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
1380 declare_type(InstanceRefKlass, InstanceKlass) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1381 declare_type(ConstantPool, Metadata) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1382 declare_type(ConstantPoolCache, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1383 declare_type(MethodData, Metadata) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1384 declare_type(Method, Metadata) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1385 declare_type(ConstMethod, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1386 \ |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
1387 declare_toplevel_type(Symbol) \ |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
1388 declare_toplevel_type(Symbol*) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1389 declare_toplevel_type(volatile Metadata*) \ |
0 | 1390 \ |
3939 | 1391 declare_toplevel_type(nmethodBucket) \ |
1392 \ | |
0 | 1393 /********/ \ |
1394 /* Oops */ \ | |
1395 /********/ \ | |
1396 \ | |
1397 declare_oop_type(markOop) \ | |
1398 declare_oop_type(objArrayOop) \ | |
1399 declare_oop_type(oop) \ | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
1400 declare_oop_type(narrowOop) \ |
0 | 1401 declare_oop_type(typeArrayOop) \ |
1402 \ | |
1403 /*************************************/ \ | |
1404 /* MethodOop-related data structures */ \ | |
1405 /*************************************/ \ | |
1406 \ | |
1407 declare_toplevel_type(CheckedExceptionElement) \ | |
1408 declare_toplevel_type(LocalVariableTableElement) \ | |
6213
8150fa46d2ed
7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents:
6146
diff
changeset
|
1409 declare_toplevel_type(ExceptionTableElement) \ |
0 | 1410 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1411 declare_toplevel_type(ClassLoaderData) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1412 declare_toplevel_type(ClassLoaderDataGraph) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1413 \ |
0 | 1414 /******************************************/ \ |
1415 /* Generation and space hierarchies */ \ | |
1416 /* (needed for run-time type information) */ \ | |
1417 /******************************************/ \ | |
1418 \ | |
1419 declare_toplevel_type(CollectedHeap) \ | |
1420 declare_type(SharedHeap, CollectedHeap) \ | |
1421 declare_type(GenCollectedHeap, SharedHeap) \ | |
1422 declare_toplevel_type(Generation) \ | |
1423 declare_type(DefNewGeneration, Generation) \ | |
1424 declare_type(CardGeneration, Generation) \ | |
1425 declare_type(OneContigSpaceCardGeneration, CardGeneration) \ | |
1426 declare_type(TenuredGeneration, OneContigSpaceCardGeneration) \ | |
1427 declare_toplevel_type(Space) \ | |
1428 declare_toplevel_type(BitMap) \ | |
1429 declare_type(CompactibleSpace, Space) \ | |
1430 declare_type(ContiguousSpace, CompactibleSpace) \ | |
1431 declare_type(EdenSpace, ContiguousSpace) \ | |
1432 declare_type(OffsetTableContigSpace, ContiguousSpace) \ | |
1433 declare_type(TenuredSpace, OffsetTableContigSpace) \ | |
1434 declare_toplevel_type(BarrierSet) \ | |
1435 declare_type(ModRefBarrierSet, BarrierSet) \ | |
1436 declare_type(CardTableModRefBS, ModRefBarrierSet) \ | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
1437 declare_type(CardTableModRefBSForCTRS, CardTableModRefBS) \ |
0 | 1438 declare_toplevel_type(GenRemSet) \ |
1439 declare_type(CardTableRS, GenRemSet) \ | |
1440 declare_toplevel_type(BlockOffsetSharedArray) \ | |
1441 declare_toplevel_type(BlockOffsetTable) \ | |
1442 declare_type(BlockOffsetArray, BlockOffsetTable) \ | |
1443 declare_type(BlockOffsetArrayContigSpace, BlockOffsetArray) \ | |
1444 declare_type(BlockOffsetArrayNonContigSpace, BlockOffsetArray) \ | |
1445 \ | |
1446 /* Miscellaneous other GC types */ \ | |
1447 \ | |
1448 declare_toplevel_type(ageTable) \ | |
1449 declare_toplevel_type(Generation::StatRecord) \ | |
1450 declare_toplevel_type(GenerationSpec) \ | |
1451 declare_toplevel_type(HeapWord) \ | |
1452 declare_toplevel_type(MemRegion) \ | |
1453 declare_toplevel_type(ThreadLocalAllocBuffer) \ | |
1454 declare_toplevel_type(VirtualSpace) \ | |
1455 declare_toplevel_type(WaterMark) \ | |
1456 \ | |
1457 /* Pointers to Garbage Collection types */ \ | |
1458 \ | |
1459 declare_toplevel_type(BarrierSet*) \ | |
1460 declare_toplevel_type(BlockOffsetSharedArray*) \ | |
1461 declare_toplevel_type(GenRemSet*) \ | |
1462 declare_toplevel_type(CardTableRS*) \ | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
1463 declare_toplevel_type(CardTableModRefBS*) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
1464 declare_toplevel_type(CardTableModRefBS**) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
1465 declare_toplevel_type(CardTableModRefBSForCTRS*) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
147
diff
changeset
|
1466 declare_toplevel_type(CardTableModRefBSForCTRS**) \ |
0 | 1467 declare_toplevel_type(CollectedHeap*) \ |
1468 declare_toplevel_type(ContiguousSpace*) \ | |
1469 declare_toplevel_type(DefNewGeneration*) \ | |
1470 declare_toplevel_type(EdenSpace*) \ | |
1471 declare_toplevel_type(GenCollectedHeap*) \ | |
1472 declare_toplevel_type(Generation*) \ | |
1473 declare_toplevel_type(GenerationSpec**) \ | |
1474 declare_toplevel_type(HeapWord*) \ | |
1475 declare_toplevel_type(MemRegion*) \ | |
1476 declare_toplevel_type(OffsetTableContigSpace*) \ | |
1477 declare_toplevel_type(OneContigSpaceCardGeneration*) \ | |
1478 declare_toplevel_type(Space*) \ | |
1479 declare_toplevel_type(ThreadLocalAllocBuffer*) \ | |
1480 \ | |
1481 /************************/ \ | |
1482 /* PerfMemory - jvmstat */ \ | |
1483 /************************/ \ | |
1484 \ | |
1485 declare_toplevel_type(PerfDataPrologue) \ | |
1486 declare_toplevel_type(PerfDataPrologue*) \ | |
1487 declare_toplevel_type(PerfDataEntry) \ | |
1488 declare_toplevel_type(PerfMemory) \ | |
1489 \ | |
1490 /*********************************/ \ | |
1491 /* SymbolTable, SystemDictionary */ \ | |
1492 /*********************************/ \ | |
1493 \ | |
6197 | 1494 declare_toplevel_type(BasicHashtable<mtInternal>) \ |
1495 declare_type(IntptrHashtable, BasicHashtable<mtInternal>) \ | |
1496 declare_type(SymbolTable, SymbolHashtable) \ | |
1497 declare_type(StringTable, StringHashtable) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1498 declare_type(LoaderConstraintTable, KlassHashtable) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1499 declare_type(KlassTwoOopHashtable, KlassHashtable) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1500 declare_type(Dictionary, KlassTwoOopHashtable) \ |
6197 | 1501 declare_type(PlaceholderTable, SymbolTwoOopHashtable) \ |
1502 declare_toplevel_type(BasicHashtableEntry<mtInternal>) \ | |
1503 declare_type(IntptrHashtableEntry, BasicHashtableEntry<mtInternal>) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1504 declare_type(DictionaryEntry, KlassHashtableEntry) \ |
6197 | 1505 declare_type(PlaceholderEntry, SymbolHashtableEntry) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1506 declare_type(LoaderConstraintEntry, KlassHashtableEntry) \ |
6197 | 1507 declare_toplevel_type(HashtableBucket<mtInternal>) \ |
0 | 1508 declare_toplevel_type(SystemDictionary) \ |
3962
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
1509 declare_toplevel_type(vmSymbols) \ |
0 | 1510 declare_toplevel_type(ProtectionDomainEntry) \ |
1511 \ | |
3939 | 1512 declare_toplevel_type(GenericGrowableArray) \ |
1513 declare_toplevel_type(GrowableArray<int>) \ | |
1514 declare_toplevel_type(Arena) \ | |
1515 declare_type(ResourceArea, Arena) \ | |
1516 declare_toplevel_type(Chunk) \ | |
1517 \ | |
0 | 1518 /***********************************************************/ \ |
1519 /* Thread hierarchy (needed for run-time type information) */ \ | |
1520 /***********************************************************/ \ | |
1521 \ | |
1522 declare_toplevel_type(Threads) \ | |
1523 declare_toplevel_type(ThreadShadow) \ | |
1524 declare_type(Thread, ThreadShadow) \ | |
1525 declare_type(NamedThread, Thread) \ | |
1526 declare_type(WatcherThread, Thread) \ | |
1527 declare_type(JavaThread, Thread) \ | |
1528 declare_type(JvmtiAgentThread, JavaThread) \ | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2192
diff
changeset
|
1529 declare_type(ServiceThread, JavaThread) \ |
3939 | 1530 declare_type(CompilerThread, JavaThread) \ |
0 | 1531 declare_toplevel_type(OSThread) \ |
1532 declare_toplevel_type(JavaFrameAnchor) \ | |
1533 \ | |
1534 /***************/ \ | |
1535 /* Interpreter */ \ | |
1536 /***************/ \ | |
1537 \ | |
1538 declare_toplevel_type(AbstractInterpreter) \ | |
1539 \ | |
1540 /*********/ \ | |
1541 /* Stubs */ \ | |
1542 /*********/ \ | |
1543 \ | |
1544 declare_toplevel_type(StubQueue) \ | |
1545 declare_toplevel_type(StubRoutines) \ | |
1546 declare_toplevel_type(Stub) \ | |
1547 declare_type(InterpreterCodelet, Stub) \ | |
1548 \ | |
1549 /*************/ \ | |
1550 /* JavaCalls */ \ | |
1551 /*************/ \ | |
1552 \ | |
1553 declare_toplevel_type(JavaCallWrapper) \ | |
1554 \ | |
1555 /*************/ \ | |
1556 /* CodeCache */ \ | |
1557 /*************/ \ | |
1558 \ | |
1559 declare_toplevel_type(CodeCache) \ | |
1560 \ | |
1561 /************/ \ | |
1562 /* CodeHeap */ \ | |
1563 /************/ \ | |
1564 \ | |
1565 declare_toplevel_type(CodeHeap) \ | |
1566 declare_toplevel_type(CodeHeap*) \ | |
1567 declare_toplevel_type(HeapBlock) \ | |
1568 declare_toplevel_type(HeapBlock::Header) \ | |
1569 declare_type(FreeBlock, HeapBlock) \ | |
1570 \ | |
1571 /*************************************************************/ \ | |
1572 /* CodeBlob hierarchy (needed for run-time type information) */ \ | |
1573 /*************************************************************/ \ | |
1574 \ | |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1575 declare_toplevel_type(SharedRuntime) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1576 \ |
0 | 1577 declare_toplevel_type(CodeBlob) \ |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1578 declare_type(BufferBlob, CodeBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1579 declare_type(AdapterBlob, BufferBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1580 declare_type(MethodHandlesAdapterBlob, BufferBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1581 declare_type(nmethod, CodeBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1582 declare_type(RuntimeStub, CodeBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1583 declare_type(SingletonBlob, CodeBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1584 declare_type(SafepointBlob, SingletonBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1585 declare_type(DeoptimizationBlob, SingletonBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1586 declare_c2_type(ExceptionBlob, SingletonBlob) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
1587 declare_c2_type(UncommonTrapBlob, CodeBlob) \ |
0 | 1588 \ |
1589 /***************************************/ \ | |
1590 /* PcDesc and other compiled code info */ \ | |
1591 /***************************************/ \ | |
1592 \ | |
1593 declare_toplevel_type(PcDesc) \ | |
3939 | 1594 declare_toplevel_type(ExceptionCache) \ |
1595 declare_toplevel_type(PcDescCache) \ | |
1596 declare_toplevel_type(Dependencies) \ | |
1597 declare_toplevel_type(CompileTask) \ | |
1598 declare_toplevel_type(Deoptimization) \ | |
0 | 1599 \ |
1600 /************************/ \ | |
1601 /* OopMap and OopMapSet */ \ | |
1602 /************************/ \ | |
1603 \ | |
1604 declare_toplevel_type(OopMap) \ | |
1605 declare_toplevel_type(OopMapSet) \ | |
1606 \ | |
1607 /********************/ \ | |
1608 /* CompressedStream */ \ | |
1609 /********************/ \ | |
1610 \ | |
1611 declare_toplevel_type(CompressedStream) \ | |
1612 \ | |
1613 /**************/ \ | |
1614 /* VMRegImpl */ \ | |
1615 /**************/ \ | |
1616 \ | |
1617 declare_toplevel_type(VMRegImpl) \ | |
1618 \ | |
1619 /*********************************/ \ | |
1620 /* JNIHandles and JNIHandleBlock */ \ | |
1621 /*********************************/ \ | |
1622 \ | |
1623 declare_toplevel_type(JNIHandles) \ | |
1624 declare_toplevel_type(JNIHandleBlock) \ | |
3939 | 1625 declare_toplevel_type(jobject) \ |
0 | 1626 \ |
1627 /**********************/ \ | |
1628 /* Runtime1 (C1 only) */ \ | |
1629 /**********************/ \ | |
1630 \ | |
1631 declare_c1_toplevel_type(Runtime1) \ | |
1632 \ | |
1633 /************/ \ | |
1634 /* Monitors */ \ | |
1635 /************/ \ | |
1636 \ | |
1637 declare_toplevel_type(ObjectMonitor) \ | |
1638 declare_toplevel_type(ObjectSynchronizer) \ | |
1639 declare_toplevel_type(BasicLock) \ | |
1640 declare_toplevel_type(BasicObjectLock) \ | |
1641 \ | |
1642 /*********************/ \ | |
1643 /* Matcher (C2 only) */ \ | |
1644 /*********************/ \ | |
1645 \ | |
1646 declare_c2_toplevel_type(Matcher) \ | |
3939 | 1647 declare_c2_toplevel_type(Compile) \ |
1648 declare_c2_toplevel_type(InlineTree) \ | |
1649 declare_c2_toplevel_type(OptoRegPair) \ | |
1650 declare_c2_toplevel_type(JVMState) \ | |
1651 declare_c2_toplevel_type(Phase) \ | |
1652 declare_c2_type(PhaseCFG, Phase) \ | |
1653 declare_c2_type(PhaseRegAlloc, Phase) \ | |
1654 declare_c2_type(PhaseChaitin, PhaseRegAlloc) \ | |
1655 declare_c2_toplevel_type(CFGElement) \ | |
1656 declare_c2_type(Block, CFGElement) \ | |
1657 declare_c2_toplevel_type(Block_Array) \ | |
1658 declare_c2_type(Block_List, Block_Array) \ | |
1659 declare_c2_toplevel_type(Node_Array) \ | |
1660 declare_c2_type(Node_List, Node_Array) \ | |
1661 declare_c2_type(Unique_Node_List, Node_List) \ | |
1662 declare_c2_toplevel_type(Node) \ | |
1663 declare_c2_type(AddNode, Node) \ | |
1664 declare_c2_type(AddINode, AddNode) \ | |
1665 declare_c2_type(AddLNode, AddNode) \ | |
1666 declare_c2_type(AddFNode, AddNode) \ | |
1667 declare_c2_type(AddDNode, AddNode) \ | |
1668 declare_c2_type(AddPNode, Node) \ | |
1669 declare_c2_type(OrINode, AddNode) \ | |
1670 declare_c2_type(OrLNode, AddNode) \ | |
1671 declare_c2_type(XorINode, AddNode) \ | |
1672 declare_c2_type(XorLNode, AddNode) \ | |
1673 declare_c2_type(MaxNode, AddNode) \ | |
1674 declare_c2_type(MaxINode, MaxNode) \ | |
1675 declare_c2_type(MinINode, MaxNode) \ | |
1676 declare_c2_type(StartNode, MultiNode) \ | |
1677 declare_c2_type(StartOSRNode, StartNode) \ | |
1678 declare_c2_type(ParmNode, ProjNode) \ | |
1679 declare_c2_type(ReturnNode, Node) \ | |
1680 declare_c2_type(RethrowNode, Node) \ | |
1681 declare_c2_type(TailCallNode, ReturnNode) \ | |
1682 declare_c2_type(TailJumpNode, ReturnNode) \ | |
1683 declare_c2_type(SafePointNode, MultiNode) \ | |
1684 declare_c2_type(CallNode, SafePointNode) \ | |
1685 declare_c2_type(CallJavaNode, CallNode) \ | |
1686 declare_c2_type(CallStaticJavaNode, CallJavaNode) \ | |
1687 declare_c2_type(CallDynamicJavaNode, CallJavaNode) \ | |
1688 declare_c2_type(CallRuntimeNode, CallNode) \ | |
1689 declare_c2_type(CallLeafNode, CallRuntimeNode) \ | |
1690 declare_c2_type(CallLeafNoFPNode, CallLeafNode) \ | |
1691 declare_c2_type(AllocateNode, CallNode) \ | |
1692 declare_c2_type(AllocateArrayNode, AllocateNode) \ | |
1693 declare_c2_type(LockNode, AbstractLockNode) \ | |
1694 declare_c2_type(UnlockNode, AbstractLockNode) \ | |
1695 declare_c2_type(FastLockNode, CmpNode) \ | |
1696 declare_c2_type(FastUnlockNode, CmpNode) \ | |
1697 declare_c2_type(RegionNode, Node) \ | |
1698 declare_c2_type(JProjNode, ProjNode) \ | |
1699 declare_c2_type(PhiNode, TypeNode) \ | |
1700 declare_c2_type(GotoNode, Node) \ | |
1701 declare_c2_type(CProjNode, ProjNode) \ | |
1702 declare_c2_type(MultiBranchNode, MultiNode) \ | |
1703 declare_c2_type(IfNode, MultiBranchNode) \ | |
1704 declare_c2_type(IfTrueNode, CProjNode) \ | |
1705 declare_c2_type(IfFalseNode, CProjNode) \ | |
1706 declare_c2_type(PCTableNode, MultiBranchNode) \ | |
1707 declare_c2_type(JumpNode, PCTableNode) \ | |
1708 declare_c2_type(JumpProjNode, JProjNode) \ | |
1709 declare_c2_type(CatchNode, PCTableNode) \ | |
1710 declare_c2_type(CatchProjNode, CProjNode) \ | |
1711 declare_c2_type(CreateExNode, TypeNode) \ | |
1712 declare_c2_type(ClearArrayNode, Node) \ | |
1713 declare_c2_type(NeverBranchNode, MultiBranchNode) \ | |
1714 declare_c2_type(ConNode, TypeNode) \ | |
1715 declare_c2_type(ConINode, ConNode) \ | |
1716 declare_c2_type(ConPNode, ConNode) \ | |
1717 declare_c2_type(ConNNode, ConNode) \ | |
1718 declare_c2_type(ConLNode, ConNode) \ | |
1719 declare_c2_type(ConFNode, ConNode) \ | |
1720 declare_c2_type(ConDNode, ConNode) \ | |
1721 declare_c2_type(BinaryNode, Node) \ | |
1722 declare_c2_type(CMoveNode, TypeNode) \ | |
1723 declare_c2_type(CMoveDNode, CMoveNode) \ | |
1724 declare_c2_type(CMoveFNode, CMoveNode) \ | |
1725 declare_c2_type(CMoveINode, CMoveNode) \ | |
1726 declare_c2_type(CMoveLNode, CMoveNode) \ | |
1727 declare_c2_type(CMovePNode, CMoveNode) \ | |
1728 declare_c2_type(CMoveNNode, CMoveNode) \ | |
1729 declare_c2_type(EncodePNode, TypeNode) \ | |
1730 declare_c2_type(DecodeNNode, TypeNode) \ | |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
1731 declare_c2_type(EncodePKlassNode, TypeNode) \ |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
1732 declare_c2_type(DecodeNKlassNode, TypeNode) \ |
3939 | 1733 declare_c2_type(ConstraintCastNode, TypeNode) \ |
1734 declare_c2_type(CastIINode, ConstraintCastNode) \ | |
1735 declare_c2_type(CastPPNode, ConstraintCastNode) \ | |
1736 declare_c2_type(CheckCastPPNode, TypeNode) \ | |
1737 declare_c2_type(Conv2BNode, Node) \ | |
1738 declare_c2_type(ConvD2FNode, Node) \ | |
1739 declare_c2_type(ConvD2INode, Node) \ | |
1740 declare_c2_type(ConvD2LNode, Node) \ | |
1741 declare_c2_type(ConvF2DNode, Node) \ | |
1742 declare_c2_type(ConvF2INode, Node) \ | |
1743 declare_c2_type(ConvF2LNode, Node) \ | |
1744 declare_c2_type(ConvI2DNode, Node) \ | |
1745 declare_c2_type(ConvI2FNode, Node) \ | |
1746 declare_c2_type(ConvI2LNode, TypeNode) \ | |
1747 declare_c2_type(ConvL2DNode, Node) \ | |
1748 declare_c2_type(ConvL2FNode, Node) \ | |
1749 declare_c2_type(ConvL2INode, Node) \ | |
1750 declare_c2_type(CastX2PNode, Node) \ | |
1751 declare_c2_type(CastP2XNode, Node) \ | |
1752 declare_c2_type(MemBarNode, MultiNode) \ | |
1753 declare_c2_type(MemBarAcquireNode, MemBarNode) \ | |
1754 declare_c2_type(MemBarReleaseNode, MemBarNode) \ | |
1755 declare_c2_type(MemBarVolatileNode, MemBarNode) \ | |
1756 declare_c2_type(MemBarCPUOrderNode, MemBarNode) \ | |
1757 declare_c2_type(InitializeNode, MemBarNode) \ | |
1758 declare_c2_type(ThreadLocalNode, Node) \ | |
1759 declare_c2_type(Opaque1Node, Node) \ | |
1760 declare_c2_type(Opaque2Node, Node) \ | |
1761 declare_c2_type(PartialSubtypeCheckNode, Node) \ | |
1762 declare_c2_type(MoveI2FNode, Node) \ | |
1763 declare_c2_type(MoveL2DNode, Node) \ | |
1764 declare_c2_type(MoveF2INode, Node) \ | |
1765 declare_c2_type(MoveD2LNode, Node) \ | |
1766 declare_c2_type(DivINode, Node) \ | |
1767 declare_c2_type(DivLNode, Node) \ | |
1768 declare_c2_type(DivFNode, Node) \ | |
1769 declare_c2_type(DivDNode, Node) \ | |
1770 declare_c2_type(ModINode, Node) \ | |
1771 declare_c2_type(ModLNode, Node) \ | |
1772 declare_c2_type(ModFNode, Node) \ | |
1773 declare_c2_type(ModDNode, Node) \ | |
1774 declare_c2_type(DivModNode, MultiNode) \ | |
1775 declare_c2_type(DivModINode, DivModNode) \ | |
1776 declare_c2_type(DivModLNode, DivModNode) \ | |
1777 declare_c2_type(BoxLockNode, Node) \ | |
1778 declare_c2_type(LoopNode, RegionNode) \ | |
1779 declare_c2_type(CountedLoopNode, LoopNode) \ | |
1780 declare_c2_type(CountedLoopEndNode, IfNode) \ | |
1781 declare_c2_type(MachNode, Node) \ | |
1782 declare_c2_type(MachIdealNode, MachNode) \ | |
1783 declare_c2_type(MachTypeNode, MachNode) \ | |
1784 declare_c2_type(MachBreakpointNode, MachIdealNode) \ | |
1785 declare_c2_type(MachUEPNode, MachIdealNode) \ | |
1786 declare_c2_type(MachPrologNode, MachIdealNode) \ | |
1787 declare_c2_type(MachEpilogNode, MachIdealNode) \ | |
1788 declare_c2_type(MachNopNode, MachIdealNode) \ | |
1789 declare_c2_type(MachSpillCopyNode, MachIdealNode) \ | |
1790 declare_c2_type(MachNullCheckNode, MachIdealNode) \ | |
1791 declare_c2_type(MachProjNode, ProjNode) \ | |
1792 declare_c2_type(MachIfNode, MachNode) \ | |
1793 declare_c2_type(MachFastLockNode, MachNode) \ | |
1794 declare_c2_type(MachReturnNode, MachNode) \ | |
1795 declare_c2_type(MachSafePointNode, MachReturnNode) \ | |
1796 declare_c2_type(MachCallNode, MachSafePointNode) \ | |
1797 declare_c2_type(MachCallJavaNode, MachCallNode) \ | |
1798 declare_c2_type(MachCallStaticJavaNode, MachCallJavaNode) \ | |
1799 declare_c2_type(MachCallDynamicJavaNode, MachCallJavaNode) \ | |
1800 declare_c2_type(MachCallRuntimeNode, MachCallNode) \ | |
1801 declare_c2_type(MachHaltNode, MachReturnNode) \ | |
1802 declare_c2_type(MachTempNode, MachNode) \ | |
1803 declare_c2_type(MemNode, Node) \ | |
1804 declare_c2_type(MergeMemNode, Node) \ | |
1805 declare_c2_type(LoadNode, MemNode) \ | |
1806 declare_c2_type(LoadBNode, LoadNode) \ | |
1807 declare_c2_type(LoadUSNode, LoadNode) \ | |
1808 declare_c2_type(LoadINode, LoadNode) \ | |
1809 declare_c2_type(LoadRangeNode, LoadINode) \ | |
1810 declare_c2_type(LoadLNode, LoadNode) \ | |
1811 declare_c2_type(LoadL_unalignedNode, LoadLNode) \ | |
1812 declare_c2_type(LoadFNode, LoadNode) \ | |
1813 declare_c2_type(LoadDNode, LoadNode) \ | |
1814 declare_c2_type(LoadD_unalignedNode, LoadDNode) \ | |
1815 declare_c2_type(LoadPNode, LoadNode) \ | |
1816 declare_c2_type(LoadNNode, LoadNode) \ | |
1817 declare_c2_type(LoadKlassNode, LoadPNode) \ | |
1818 declare_c2_type(LoadNKlassNode, LoadNNode) \ | |
1819 declare_c2_type(LoadSNode, LoadNode) \ | |
1820 declare_c2_type(StoreNode, MemNode) \ | |
1821 declare_c2_type(StoreBNode, StoreNode) \ | |
1822 declare_c2_type(StoreCNode, StoreNode) \ | |
1823 declare_c2_type(StoreINode, StoreNode) \ | |
1824 declare_c2_type(StoreLNode, StoreNode) \ | |
1825 declare_c2_type(StoreFNode, StoreNode) \ | |
1826 declare_c2_type(StoreDNode, StoreNode) \ | |
1827 declare_c2_type(StorePNode, StoreNode) \ | |
1828 declare_c2_type(StoreNNode, StoreNode) \ | |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
1829 declare_c2_type(StoreNKlassNode, StoreNode) \ |
3939 | 1830 declare_c2_type(StoreCMNode, StoreNode) \ |
1831 declare_c2_type(LoadPLockedNode, LoadPNode) \ | |
1832 declare_c2_type(SCMemProjNode, ProjNode) \ | |
1833 declare_c2_type(LoadStoreNode, Node) \ | |
1834 declare_c2_type(StorePConditionalNode, LoadStoreNode) \ | |
1835 declare_c2_type(StoreLConditionalNode, LoadStoreNode) \ | |
1836 declare_c2_type(CompareAndSwapLNode, LoadStoreNode) \ | |
1837 declare_c2_type(CompareAndSwapINode, LoadStoreNode) \ | |
1838 declare_c2_type(CompareAndSwapPNode, LoadStoreNode) \ | |
1839 declare_c2_type(CompareAndSwapNNode, LoadStoreNode) \ | |
1840 declare_c2_type(PrefetchReadNode, Node) \ | |
1841 declare_c2_type(PrefetchWriteNode, Node) \ | |
1842 declare_c2_type(MulNode, Node) \ | |
1843 declare_c2_type(MulINode, MulNode) \ | |
1844 declare_c2_type(MulLNode, MulNode) \ | |
1845 declare_c2_type(MulFNode, MulNode) \ | |
1846 declare_c2_type(MulDNode, MulNode) \ | |
1847 declare_c2_type(MulHiLNode, Node) \ | |
1848 declare_c2_type(AndINode, MulINode) \ | |
1849 declare_c2_type(AndLNode, MulLNode) \ | |
1850 declare_c2_type(LShiftINode, Node) \ | |
1851 declare_c2_type(LShiftLNode, Node) \ | |
1852 declare_c2_type(RShiftINode, Node) \ | |
1853 declare_c2_type(RShiftLNode, Node) \ | |
1854 declare_c2_type(URShiftINode, Node) \ | |
1855 declare_c2_type(URShiftLNode, Node) \ | |
1856 declare_c2_type(MultiNode, Node) \ | |
1857 declare_c2_type(ProjNode, Node) \ | |
1858 declare_c2_type(TypeNode, Node) \ | |
1859 declare_c2_type(NodeHash, StackObj) \ | |
1860 declare_c2_type(RootNode, LoopNode) \ | |
1861 declare_c2_type(HaltNode, Node) \ | |
1862 declare_c2_type(SubNode, Node) \ | |
1863 declare_c2_type(SubINode, SubNode) \ | |
1864 declare_c2_type(SubLNode, SubNode) \ | |
1865 declare_c2_type(SubFPNode, SubNode) \ | |
1866 declare_c2_type(SubFNode, SubFPNode) \ | |
1867 declare_c2_type(SubDNode, SubFPNode) \ | |
1868 declare_c2_type(CmpNode, SubNode) \ | |
1869 declare_c2_type(CmpINode, CmpNode) \ | |
1870 declare_c2_type(CmpUNode, CmpNode) \ | |
1871 declare_c2_type(CmpPNode, CmpNode) \ | |
1872 declare_c2_type(CmpNNode, CmpNode) \ | |
1873 declare_c2_type(CmpLNode, CmpNode) \ | |
1874 declare_c2_type(CmpL3Node, CmpLNode) \ | |
1875 declare_c2_type(CmpFNode, CmpNode) \ | |
1876 declare_c2_type(CmpF3Node, CmpFNode) \ | |
1877 declare_c2_type(CmpDNode, CmpNode) \ | |
1878 declare_c2_type(CmpD3Node, CmpDNode) \ | |
1879 declare_c2_type(BoolNode, Node) \ | |
1880 declare_c2_type(AbsNode, Node) \ | |
1881 declare_c2_type(AbsINode, AbsNode) \ | |
1882 declare_c2_type(AbsFNode, AbsNode) \ | |
1883 declare_c2_type(AbsDNode, AbsNode) \ | |
1884 declare_c2_type(CmpLTMaskNode, Node) \ | |
1885 declare_c2_type(NegNode, Node) \ | |
1886 declare_c2_type(NegFNode, NegNode) \ | |
1887 declare_c2_type(NegDNode, NegNode) \ | |
1888 declare_c2_type(CosDNode, Node) \ | |
1889 declare_c2_type(SinDNode, Node) \ | |
1890 declare_c2_type(TanDNode, Node) \ | |
1891 declare_c2_type(AtanDNode, Node) \ | |
1892 declare_c2_type(SqrtDNode, Node) \ | |
1893 declare_c2_type(ExpDNode, Node) \ | |
1894 declare_c2_type(LogDNode, Node) \ | |
1895 declare_c2_type(Log10DNode, Node) \ | |
1896 declare_c2_type(PowDNode, Node) \ | |
1897 declare_c2_type(ReverseBytesINode, Node) \ | |
1898 declare_c2_type(ReverseBytesLNode, Node) \ | |
1899 declare_c2_type(VectorNode, Node) \ | |
1900 declare_c2_type(AddVBNode, VectorNode) \ | |
1901 declare_c2_type(AddVSNode, VectorNode) \ | |
1902 declare_c2_type(AddVINode, VectorNode) \ | |
1903 declare_c2_type(AddVLNode, VectorNode) \ | |
1904 declare_c2_type(AddVFNode, VectorNode) \ | |
1905 declare_c2_type(AddVDNode, VectorNode) \ | |
1906 declare_c2_type(SubVBNode, VectorNode) \ | |
1907 declare_c2_type(SubVSNode, VectorNode) \ | |
1908 declare_c2_type(SubVINode, VectorNode) \ | |
1909 declare_c2_type(SubVLNode, VectorNode) \ | |
1910 declare_c2_type(SubVFNode, VectorNode) \ | |
1911 declare_c2_type(SubVDNode, VectorNode) \ | |
6802
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1912 declare_c2_type(MulVSNode, VectorNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1913 declare_c2_type(MulVINode, VectorNode) \ |
3939 | 1914 declare_c2_type(MulVFNode, VectorNode) \ |
1915 declare_c2_type(MulVDNode, VectorNode) \ | |
1916 declare_c2_type(DivVFNode, VectorNode) \ | |
1917 declare_c2_type(DivVDNode, VectorNode) \ | |
1918 declare_c2_type(LShiftVBNode, VectorNode) \ | |
1919 declare_c2_type(LShiftVSNode, VectorNode) \ | |
1920 declare_c2_type(LShiftVINode, VectorNode) \ | |
6802
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1921 declare_c2_type(LShiftVLNode, VectorNode) \ |
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1922 declare_c2_type(RShiftVBNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1923 declare_c2_type(RShiftVSNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1924 declare_c2_type(RShiftVINode, VectorNode) \ |
6802
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1925 declare_c2_type(RShiftVLNode, VectorNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1926 declare_c2_type(URShiftVBNode, VectorNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1927 declare_c2_type(URShiftVSNode, VectorNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1928 declare_c2_type(URShiftVINode, VectorNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1929 declare_c2_type(URShiftVLNode, VectorNode) \ |
3939 | 1930 declare_c2_type(AndVNode, VectorNode) \ |
1931 declare_c2_type(OrVNode, VectorNode) \ | |
1932 declare_c2_type(XorVNode, VectorNode) \ | |
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1933 declare_c2_type(LoadVectorNode, LoadNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1934 declare_c2_type(StoreVectorNode, StoreNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1935 declare_c2_type(ReplicateBNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1936 declare_c2_type(ReplicateSNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1937 declare_c2_type(ReplicateINode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1938 declare_c2_type(ReplicateLNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1939 declare_c2_type(ReplicateFNode, VectorNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1940 declare_c2_type(ReplicateDNode, VectorNode) \ |
3939 | 1941 declare_c2_type(PackNode, VectorNode) \ |
1942 declare_c2_type(PackBNode, PackNode) \ | |
1943 declare_c2_type(PackSNode, PackNode) \ | |
1944 declare_c2_type(PackINode, PackNode) \ | |
1945 declare_c2_type(PackLNode, PackNode) \ | |
1946 declare_c2_type(PackFNode, PackNode) \ | |
1947 declare_c2_type(PackDNode, PackNode) \ | |
6179
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1948 declare_c2_type(Pack2LNode, PackNode) \ |
8c92982cbbc4
7119644: Increase superword's vector size up to 256 bits
kvn
parents:
6146
diff
changeset
|
1949 declare_c2_type(Pack2DNode, PackNode) \ |
3939 | 1950 declare_c2_type(ExtractNode, Node) \ |
1951 declare_c2_type(ExtractBNode, ExtractNode) \ | |
6802
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1952 declare_c2_type(ExtractUBNode, ExtractNode) \ |
0702f188baeb
7200233: C2: can't use expand rules for vector instruction rules
kvn
parents:
6800
diff
changeset
|
1953 declare_c2_type(ExtractCNode, ExtractNode) \ |
3939 | 1954 declare_c2_type(ExtractSNode, ExtractNode) \ |
1955 declare_c2_type(ExtractINode, ExtractNode) \ | |
1956 declare_c2_type(ExtractLNode, ExtractNode) \ | |
1957 declare_c2_type(ExtractFNode, ExtractNode) \ | |
1958 declare_c2_type(ExtractDNode, ExtractNode) \ | |
0 | 1959 \ |
1960 /*********************/ \ | |
1961 /* Adapter Blob Entries */ \ | |
1962 /*********************/ \ | |
1963 declare_toplevel_type(AdapterHandlerEntry) \ | |
1964 declare_toplevel_type(AdapterHandlerEntry*) \ | |
1965 \ | |
3939 | 1966 /*********************/ \ |
1967 /* CI */ \ | |
1968 /*********************/ \ | |
1969 declare_toplevel_type(ciEnv) \ | |
1970 declare_toplevel_type(ciObjectFactory) \ | |
1971 declare_toplevel_type(ciConstant) \ | |
1972 declare_toplevel_type(ciField) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1973 declare_toplevel_type(ciSymbol) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1974 declare_toplevel_type(ciBaseObject) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1975 declare_type(ciObject, ciBaseObject) \ |
3939 | 1976 declare_type(ciInstance, ciObject) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1977 declare_type(ciMetadata, ciBaseObject) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1978 declare_type(ciMethod, ciMetadata) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1979 declare_type(ciMethodData, ciMetadata) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
1980 declare_type(ciType, ciMetadata) \ |
3939 | 1981 declare_type(ciKlass, ciType) \ |
1982 declare_type(ciInstanceKlass, ciKlass) \ | |
1983 declare_type(ciArrayKlass, ciKlass) \ | |
1984 declare_type(ciTypeArrayKlass, ciArrayKlass) \ | |
1985 declare_type(ciObjArrayKlass, ciArrayKlass) \ | |
1986 \ | |
0 | 1987 /********************/ \ |
1988 /* -XX flags */ \ | |
1989 /********************/ \ | |
1990 \ | |
1991 declare_toplevel_type(Flag) \ | |
1992 declare_toplevel_type(Flag*) \ | |
1993 \ | |
1994 /********************/ \ | |
3939 | 1995 /* JVMTI */ \ |
1996 /********************/ \ | |
1997 \ | |
1998 declare_toplevel_type(JvmtiExport) \ | |
1999 \ | |
2000 /********************/ \ | |
0 | 2001 /* JDK/VM version */ \ |
2002 /********************/ \ | |
2003 \ | |
2004 declare_toplevel_type(Abstract_VM_Version) \ | |
2005 declare_toplevel_type(JDK_Version) \ | |
2006 \ | |
2007 /*************/ \ | |
2008 /* Arguments */ \ | |
2009 /*************/ \ | |
2010 \ | |
2011 declare_toplevel_type(Arguments) \ | |
2012 \ | |
2013 /***************/ \ | |
2014 /* Other types */ \ | |
2015 /***************/ \ | |
2016 \ | |
2017 /* all enum types */ \ | |
2018 \ | |
2019 declare_integer_type(Bytecodes::Code) \ | |
2020 declare_integer_type(Generation::Name) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2021 declare_integer_type(InstanceKlass::ClassState) \ |
0 | 2022 declare_integer_type(JavaThreadState) \ |
2023 declare_integer_type(Location::Type) \ | |
2024 declare_integer_type(Location::Where) \ | |
3939 | 2025 declare_integer_type(FlagValueOrigin) \ |
2026 COMPILER2_PRESENT(declare_integer_type(OptoReg::Name)) \ | |
0 | 2027 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2028 declare_toplevel_type(CHeapObj<mtInternal>) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2029 declare_type(Array<int>, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2030 declare_type(Array<u1>, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2031 declare_type(Array<u2>, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2032 declare_type(Array<Klass*>, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2033 declare_type(Array<Method*>, MetaspaceObj) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2034 \ |
0 | 2035 declare_integer_type(AccessFlags) /* FIXME: wrong type (not integer) */\ |
2036 declare_toplevel_type(address) /* FIXME: should this be an integer type? */\ | |
3939 | 2037 declare_integer_type(BasicType) /* FIXME: wrong type (not integer) */\ |
0 | 2038 declare_toplevel_type(BreakpointInfo) \ |
2039 declare_toplevel_type(BreakpointInfo*) \ | |
2040 declare_toplevel_type(CodeBlob*) \ | |
2041 declare_toplevel_type(CompressedWriteStream*) \ | |
2042 declare_toplevel_type(ConstantPoolCacheEntry) \ | |
2043 declare_toplevel_type(elapsedTimer) \ | |
3939 | 2044 declare_toplevel_type(frame) \ |
0 | 2045 declare_toplevel_type(intptr_t*) \ |
2046 declare_unsigned_integer_type(InvocationCounter) /* FIXME: wrong type (not integer) */ \ | |
2047 declare_toplevel_type(JavaThread*) \ | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2260
diff
changeset
|
2048 declare_toplevel_type(java_lang_Class) \ |
3939 | 2049 declare_integer_type(JavaThread::AsyncRequests) \ |
0 | 2050 declare_toplevel_type(jbyte*) \ |
2051 declare_toplevel_type(jbyte**) \ | |
2052 declare_toplevel_type(jint*) \ | |
2053 declare_toplevel_type(jniIdMapBase*) \ | |
2054 declare_unsigned_integer_type(juint) \ | |
2055 declare_unsigned_integer_type(julong) \ | |
2056 declare_toplevel_type(JNIHandleBlock*) \ | |
2057 declare_toplevel_type(JNIid) \ | |
2058 declare_toplevel_type(JNIid*) \ | |
2059 declare_toplevel_type(jmethodID*) \ | |
2060 declare_toplevel_type(Mutex*) \ | |
2061 declare_toplevel_type(nmethod*) \ | |
3939 | 2062 COMPILER2_PRESENT(declare_unsigned_integer_type(node_idx_t)) \ |
0 | 2063 declare_toplevel_type(ObjectMonitor*) \ |
2064 declare_toplevel_type(oop*) \ | |
2065 declare_toplevel_type(OopMap**) \ | |
2066 declare_toplevel_type(OopMapCache*) \ | |
2067 declare_toplevel_type(OopMapSet*) \ | |
2068 declare_toplevel_type(VMReg) \ | |
2069 declare_toplevel_type(OSThread*) \ | |
2070 declare_integer_type(ReferenceType) \ | |
2071 declare_toplevel_type(StubQueue*) \ | |
2072 declare_toplevel_type(Thread*) \ | |
3939 | 2073 declare_toplevel_type(Universe) \ |
2074 declare_toplevel_type(vframeArray) \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2075 declare_toplevel_type(vframeArrayElement) \ |
6885 | 2076 declare_toplevel_type(Annotations*) \ |
2077 \ | |
2078 /***************/ \ | |
2079 /* Miscellaneous types */ \ | |
2080 /***************/ \ | |
2081 \ | |
2082 /* freelist */ \ | |
2083 declare_toplevel_type(FreeChunk*) \ | |
2084 declare_toplevel_type(Metablock*) \ | |
2085 declare_toplevel_type(FreeBlockDictionary<FreeChunk>*) \ | |
2086 declare_toplevel_type(FreeList<FreeChunk>*) \ | |
2087 declare_toplevel_type(FreeList<FreeChunk>) \ | |
2088 declare_toplevel_type(FreeBlockDictionary<Metablock>*) \ | |
2089 declare_toplevel_type(FreeList<Metablock>*) \ | |
2090 declare_toplevel_type(FreeList<Metablock>) \ | |
7947
3c327c2b6782
8004895: NPG: JMapPermCore test failure caused by warnings about missing field
jmasa
parents:
7615
diff
changeset
|
2091 declare_type(MetablockTreeDictionary, FreeBlockDictionary<Metablock>) |
3939 | 2092 |
0 | 2093 |
2094 //-------------------------------------------------------------------------------- | |
2095 // VM_INT_CONSTANTS | |
2096 // | |
2097 // This table contains integer constants required over in the | |
2098 // serviceability agent. The "declare_constant" macro is used for all | |
2099 // enums, etc., while "declare_preprocessor_constant" must be used for | |
2100 // all #defined constants. | |
2101 | |
2102 #define VM_INT_CONSTANTS(declare_constant, \ | |
2103 declare_preprocessor_constant, \ | |
2104 declare_c1_constant, \ | |
2105 declare_c2_constant, \ | |
7583 | 2106 declare_c2_preprocessor_constant) \ |
0 | 2107 \ |
2108 /******************/ \ | |
2109 /* Useful globals */ \ | |
2110 /******************/ \ | |
2111 \ | |
2112 \ | |
2113 /**************/ \ | |
2114 /* Stack bias */ \ | |
2115 /**************/ \ | |
2116 \ | |
2117 declare_preprocessor_constant("STACK_BIAS", STACK_BIAS) \ | |
2118 \ | |
2119 /****************/ \ | |
2120 /* Object sizes */ \ | |
2121 /****************/ \ | |
2122 \ | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
2123 declare_constant(oopSize) \ |
0 | 2124 declare_constant(LogBytesPerWord) \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2125 declare_constant(BytesPerWord) \ |
0 | 2126 declare_constant(BytesPerLong) \ |
2127 \ | |
2128 /********************************************/ \ | |
2129 /* Generation and Space Hierarchy Constants */ \ | |
2130 /********************************************/ \ | |
2131 \ | |
2132 declare_constant(ageTable::table_size) \ | |
2133 \ | |
2134 declare_constant(BarrierSet::ModRef) \ | |
2135 declare_constant(BarrierSet::CardTableModRef) \ | |
2136 declare_constant(BarrierSet::Other) \ | |
2137 \ | |
2138 declare_constant(BlockOffsetSharedArray::LogN) \ | |
2139 declare_constant(BlockOffsetSharedArray::LogN_words) \ | |
2140 declare_constant(BlockOffsetSharedArray::N_bytes) \ | |
2141 declare_constant(BlockOffsetSharedArray::N_words) \ | |
2142 \ | |
2143 declare_constant(BlockOffsetArray::N_words) \ | |
2144 \ | |
2145 declare_constant(CardTableModRefBS::clean_card) \ | |
2146 declare_constant(CardTableModRefBS::last_card) \ | |
2147 declare_constant(CardTableModRefBS::dirty_card) \ | |
2148 declare_constant(CardTableModRefBS::Precise) \ | |
2149 declare_constant(CardTableModRefBS::ObjHeadPreciseArray) \ | |
2150 declare_constant(CardTableModRefBS::card_shift) \ | |
2151 declare_constant(CardTableModRefBS::card_size) \ | |
2152 declare_constant(CardTableModRefBS::card_size_in_words) \ | |
2153 \ | |
2154 declare_constant(CardTableRS::youngergen_card) \ | |
2155 \ | |
2156 declare_constant(CollectedHeap::Abstract) \ | |
2157 declare_constant(CollectedHeap::SharedHeap) \ | |
2158 declare_constant(CollectedHeap::GenCollectedHeap) \ | |
2159 \ | |
2160 declare_constant(GenCollectedHeap::max_gens) \ | |
2161 \ | |
2162 /* constants from Generation::Name enum */ \ | |
2163 \ | |
2164 declare_constant(Generation::DefNew) \ | |
2165 declare_constant(Generation::MarkSweepCompact) \ | |
2166 declare_constant(Generation::Other) \ | |
2167 \ | |
2168 declare_constant(Generation::LogOfGenGrain) \ | |
2169 declare_constant(Generation::GenGrain) \ | |
2170 \ | |
2171 declare_constant(HeapWordSize) \ | |
2172 declare_constant(LogHeapWordSize) \ | |
2173 \ | |
2174 \ | |
2175 /************************/ \ | |
2176 /* PerfMemory - jvmstat */ \ | |
2177 /************************/ \ | |
2178 \ | |
2179 declare_preprocessor_constant("PERFDATA_MAJOR_VERSION", PERFDATA_MAJOR_VERSION) \ | |
2180 declare_preprocessor_constant("PERFDATA_MINOR_VERSION", PERFDATA_MINOR_VERSION) \ | |
2181 declare_preprocessor_constant("PERFDATA_BIG_ENDIAN", PERFDATA_BIG_ENDIAN) \ | |
2182 declare_preprocessor_constant("PERFDATA_LITTLE_ENDIAN", PERFDATA_LITTLE_ENDIAN) \ | |
2183 \ | |
2184 /***************/ \ | |
2185 /* SymbolTable */ \ | |
2186 /***************/ \ | |
2187 \ | |
2188 declare_constant(SymbolTable::symbol_table_size) \ | |
2189 \ | |
2190 /***********************************/ \ | |
2191 /* LoaderConstraintTable constants */ \ | |
2192 /***********************************/ \ | |
2193 \ | |
2194 declare_constant(LoaderConstraintTable::_loader_constraint_size) \ | |
2195 declare_constant(LoaderConstraintTable::_nof_buckets) \ | |
2196 \ | |
2197 /************************************************************/ \ | |
2198 /* HotSpot specific JVM_ACC constants from global anon enum */ \ | |
2199 /************************************************************/ \ | |
2200 \ | |
2201 declare_constant(JVM_ACC_WRITTEN_FLAGS) \ | |
2202 declare_constant(JVM_ACC_MONITOR_MATCH) \ | |
2203 declare_constant(JVM_ACC_HAS_MONITOR_BYTECODES) \ | |
2204 declare_constant(JVM_ACC_HAS_LOOPS) \ | |
2205 declare_constant(JVM_ACC_LOOPS_FLAG_INIT) \ | |
2206 declare_constant(JVM_ACC_QUEUED) \ | |
6800
9191895df19d
7200001: failed C1 OSR compile doesn't get recompiled with C2
twisti
parents:
6735
diff
changeset
|
2207 declare_constant(JVM_ACC_NOT_C2_OSR_COMPILABLE) \ |
0 | 2208 declare_constant(JVM_ACC_HAS_LINE_NUMBER_TABLE) \ |
2209 declare_constant(JVM_ACC_HAS_CHECKED_EXCEPTIONS) \ | |
2210 declare_constant(JVM_ACC_HAS_JSRS) \ | |
2211 declare_constant(JVM_ACC_IS_OLD) \ | |
2212 declare_constant(JVM_ACC_IS_OBSOLETE) \ | |
2213 declare_constant(JVM_ACC_IS_PREFIXED_NATIVE) \ | |
2214 declare_constant(JVM_ACC_HAS_MIRANDA_METHODS) \ | |
2215 declare_constant(JVM_ACC_HAS_VANILLA_CONSTRUCTOR) \ | |
2216 declare_constant(JVM_ACC_HAS_FINALIZER) \ | |
2217 declare_constant(JVM_ACC_IS_CLONEABLE) \ | |
2218 declare_constant(JVM_ACC_HAS_LOCAL_VARIABLE_TABLE) \ | |
2219 declare_constant(JVM_ACC_PROMOTED_FLAGS) \ | |
2220 declare_constant(JVM_ACC_FIELD_ACCESS_WATCHED) \ | |
2221 declare_constant(JVM_ACC_FIELD_MODIFICATION_WATCHED) \ | |
2222 \ | |
2223 /*****************************/ \ | |
2224 /* Thread::SuspendFlags enum */ \ | |
2225 /*****************************/ \ | |
2226 \ | |
2227 declare_constant(Thread::_external_suspend) \ | |
2228 declare_constant(Thread::_ext_suspended) \ | |
2229 declare_constant(Thread::_has_async_exception) \ | |
2230 \ | |
2231 /*******************/ \ | |
2232 /* JavaThreadState */ \ | |
2233 /*******************/ \ | |
2234 \ | |
2235 declare_constant(_thread_uninitialized) \ | |
2236 declare_constant(_thread_new) \ | |
2237 declare_constant(_thread_new_trans) \ | |
2238 declare_constant(_thread_in_native) \ | |
2239 declare_constant(_thread_in_native_trans) \ | |
2240 declare_constant(_thread_in_vm) \ | |
2241 declare_constant(_thread_in_vm_trans) \ | |
2242 declare_constant(_thread_in_Java) \ | |
2243 declare_constant(_thread_in_Java_trans) \ | |
2244 declare_constant(_thread_blocked) \ | |
2245 declare_constant(_thread_blocked_trans) \ | |
2246 \ | |
2247 /******************************/ \ | |
2248 /* Klass misc. enum constants */ \ | |
2249 /******************************/ \ | |
2250 \ | |
2251 declare_constant(Klass::_primary_super_limit) \ | |
2252 declare_constant(Klass::_lh_instance_slow_path_bit) \ | |
2253 declare_constant(Klass::_lh_log2_element_size_shift) \ | |
2254 declare_constant(Klass::_lh_element_type_shift) \ | |
2255 declare_constant(Klass::_lh_header_size_shift) \ | |
2256 declare_constant(Klass::_lh_array_tag_shift) \ | |
2257 declare_constant(Klass::_lh_array_tag_type_value) \ | |
2258 declare_constant(Klass::_lh_array_tag_obj_value) \ | |
2259 \ | |
2260 /********************************/ \ | |
8031 | 2261 /* ConstMethod anon-enum */ \ |
0 | 2262 /********************************/ \ |
2263 \ | |
8031 | 2264 declare_constant(ConstMethod::_has_linenumber_table) \ |
2265 declare_constant(ConstMethod::_has_checked_exceptions) \ | |
2266 declare_constant(ConstMethod::_has_localvariable_table) \ | |
2267 declare_constant(ConstMethod::_has_exception_table) \ | |
2268 declare_constant(ConstMethod::_has_generic_signature) \ | |
2269 declare_constant(ConstMethod::_has_method_annotations) \ | |
2270 declare_constant(ConstMethod::_has_parameter_annotations) \ | |
2271 declare_constant(ConstMethod::_has_default_annotations) \ | |
2272 declare_constant(ConstMethod::_has_type_annotations) \ | |
0 | 2273 \ |
2274 /*************************************/ \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2275 /* InstanceKlass enum */ \ |
3938 | 2276 /*************************************/ \ |
2277 \ | |
2278 \ | |
2279 /*************************************/ \ | |
2280 /* FieldInfo FieldOffset enum */ \ | |
0 | 2281 /*************************************/ \ |
2282 \ | |
3938 | 2283 declare_constant(FieldInfo::access_flags_offset) \ |
2284 declare_constant(FieldInfo::name_index_offset) \ | |
2285 declare_constant(FieldInfo::signature_index_offset) \ | |
2286 declare_constant(FieldInfo::initval_index_offset) \ | |
7587 | 2287 declare_constant(FieldInfo::low_packed_offset) \ |
2288 declare_constant(FieldInfo::high_packed_offset) \ | |
3938 | 2289 declare_constant(FieldInfo::field_slots) \ |
0 | 2290 \ |
7587 | 2291 /*************************************/ \ |
2292 /* FieldInfo tag constants */ \ | |
2293 /*************************************/ \ | |
2294 \ | |
2295 declare_preprocessor_constant("FIELDINFO_TAG_SIZE", FIELDINFO_TAG_SIZE) \ | |
7620
e94ed1591b42
8006403: Regression: jstack failed due to the FieldInfo regression in SA
sla
parents:
7590
diff
changeset
|
2296 declare_preprocessor_constant("FIELDINFO_TAG_MASK", FIELDINFO_TAG_MASK) \ |
7587 | 2297 declare_preprocessor_constant("FIELDINFO_TAG_OFFSET", FIELDINFO_TAG_OFFSET) \ |
2298 \ | |
0 | 2299 /************************************************/ \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2300 /* InstanceKlass InnerClassAttributeOffset enum */ \ |
0 | 2301 /************************************************/ \ |
2302 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2303 declare_constant(InstanceKlass::inner_class_inner_class_info_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2304 declare_constant(InstanceKlass::inner_class_outer_class_info_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2305 declare_constant(InstanceKlass::inner_class_inner_name_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2306 declare_constant(InstanceKlass::inner_class_access_flags_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2307 declare_constant(InstanceKlass::inner_class_next_offset) \ |
0 | 2308 \ |
2309 /*********************************/ \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2310 /* InstanceKlass ClassState enum */ \ |
0 | 2311 /*********************************/ \ |
2312 \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2313 declare_constant(InstanceKlass::allocated) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2314 declare_constant(InstanceKlass::loaded) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2315 declare_constant(InstanceKlass::linked) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2316 declare_constant(InstanceKlass::being_initialized) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2317 declare_constant(InstanceKlass::fully_initialized) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2318 declare_constant(InstanceKlass::initialization_error) \ |
0 | 2319 \ |
2320 /*********************************/ \ | |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2321 /* Symbol* - symbol max length */ \ |
0 | 2322 /*********************************/ \ |
2323 \ | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
2324 declare_constant(Symbol::max_symbol_length) \ |
0 | 2325 \ |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1748
diff
changeset
|
2326 /*************************************************/ \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2327 /* ConstantPool* layout enum for InvokeDynamic */ \ |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1748
diff
changeset
|
2328 /*************************************************/ \ |
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1748
diff
changeset
|
2329 \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2330 declare_constant(ConstantPool::_indy_bsm_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2331 declare_constant(ConstantPool::_indy_argc_offset) \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
2332 declare_constant(ConstantPool::_indy_argv_offset) \ |
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1748
diff
changeset
|
2333 \ |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2334 /********************************/ \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2335 /* ConstantPoolCacheEntry enums */ \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2336 /********************************/ \ |
0 | 2337 \ |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2338 declare_constant(ConstantPoolCacheEntry::is_volatile_shift) \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2339 declare_constant(ConstantPoolCacheEntry::is_final_shift) \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2340 declare_constant(ConstantPoolCacheEntry::is_forced_virtual_shift) \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2341 declare_constant(ConstantPoolCacheEntry::is_vfinal_shift) \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2342 declare_constant(ConstantPoolCacheEntry::is_field_entry_shift) \ |
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
6217
diff
changeset
|
2343 declare_constant(ConstantPoolCacheEntry::tos_state_shift) \ |
0 | 2344 \ |
2345 /***************************************/ \ | |
2346 /* java_lang_Thread::ThreadStatus enum */ \ | |
2347 /***************************************/ \ | |
2348 \ | |
2349 declare_constant(java_lang_Thread::NEW) \ | |
2350 declare_constant(java_lang_Thread::RUNNABLE) \ | |
2351 declare_constant(java_lang_Thread::SLEEPING) \ | |
2352 declare_constant(java_lang_Thread::IN_OBJECT_WAIT) \ | |
2353 declare_constant(java_lang_Thread::IN_OBJECT_WAIT_TIMED) \ | |
2354 declare_constant(java_lang_Thread::PARKED) \ | |
2355 declare_constant(java_lang_Thread::PARKED_TIMED) \ | |
2356 declare_constant(java_lang_Thread::BLOCKED_ON_MONITOR_ENTER) \ | |
2357 declare_constant(java_lang_Thread::TERMINATED) \ | |
2358 \ | |
2359 /******************************/ \ | |
2360 /* Debug info */ \ | |
2361 /******************************/ \ | |
2362 \ | |
2363 declare_constant(Location::OFFSET_MASK) \ | |
2364 declare_constant(Location::OFFSET_SHIFT) \ | |
2365 declare_constant(Location::TYPE_MASK) \ | |
2366 declare_constant(Location::TYPE_SHIFT) \ | |
2367 declare_constant(Location::WHERE_MASK) \ | |
2368 declare_constant(Location::WHERE_SHIFT) \ | |
2369 \ | |
2370 /* constants from Location::Type enum */ \ | |
2371 \ | |
2372 declare_constant(Location::normal) \ | |
2373 declare_constant(Location::oop) \ | |
331
cecd8eb4e0ca
6706829: Compressed Oops: add debug info for narrow oops
kvn
parents:
304
diff
changeset
|
2374 declare_constant(Location::narrowoop) \ |
0 | 2375 declare_constant(Location::int_in_long) \ |
2376 declare_constant(Location::lng) \ | |
2377 declare_constant(Location::float_in_dbl) \ | |
2378 declare_constant(Location::dbl) \ | |
2379 declare_constant(Location::addr) \ | |
2380 declare_constant(Location::invalid) \ | |
2381 \ | |
2382 /* constants from Location::Where enum */ \ | |
2383 \ | |
2384 declare_constant(Location::on_stack) \ | |
2385 declare_constant(Location::in_register) \ | |
2386 \ | |
3939 | 2387 declare_constant(Deoptimization::Reason_many) \ |
2388 declare_constant(Deoptimization::Reason_none) \ | |
2389 declare_constant(Deoptimization::Reason_null_check) \ | |
2390 declare_constant(Deoptimization::Reason_null_assert) \ | |
2391 declare_constant(Deoptimization::Reason_range_check) \ | |
2392 declare_constant(Deoptimization::Reason_class_check) \ | |
2393 declare_constant(Deoptimization::Reason_array_check) \ | |
2394 declare_constant(Deoptimization::Reason_intrinsic) \ | |
2395 declare_constant(Deoptimization::Reason_bimorphic) \ | |
2396 declare_constant(Deoptimization::Reason_unloaded) \ | |
2397 declare_constant(Deoptimization::Reason_uninitialized) \ | |
2398 declare_constant(Deoptimization::Reason_unreached) \ | |
2399 declare_constant(Deoptimization::Reason_unhandled) \ | |
2400 declare_constant(Deoptimization::Reason_constraint) \ | |
2401 declare_constant(Deoptimization::Reason_div0_check) \ | |
2402 declare_constant(Deoptimization::Reason_age) \ | |
2403 declare_constant(Deoptimization::Reason_predicate) \ | |
2404 declare_constant(Deoptimization::Reason_loop_limit_check) \ | |
2405 declare_constant(Deoptimization::Reason_LIMIT) \ | |
2406 declare_constant(Deoptimization::Reason_RECORDED_LIMIT) \ | |
2407 \ | |
0 | 2408 /*********************/ \ |
2409 /* Matcher (C2 only) */ \ | |
2410 /*********************/ \ | |
2411 \ | |
2412 declare_c2_preprocessor_constant("Matcher::interpreter_frame_pointer_reg", Matcher::interpreter_frame_pointer_reg()) \ | |
2413 \ | |
2414 /*********************************************/ \ | |
2415 /* MethodCompilation (globalDefinitions.hpp) */ \ | |
2416 /*********************************************/ \ | |
2417 \ | |
2418 declare_constant(InvocationEntryBci) \ | |
2419 declare_constant(InvalidOSREntryBci) \ | |
2420 \ | |
2421 /***************/ \ | |
2422 /* OopMapValue */ \ | |
2423 /***************/ \ | |
2424 \ | |
2425 declare_constant(OopMapValue::type_bits) \ | |
2426 declare_constant(OopMapValue::register_bits) \ | |
2427 declare_constant(OopMapValue::type_shift) \ | |
2428 declare_constant(OopMapValue::register_shift) \ | |
2429 declare_constant(OopMapValue::type_mask) \ | |
2430 declare_constant(OopMapValue::type_mask_in_place) \ | |
2431 declare_constant(OopMapValue::register_mask) \ | |
2432 declare_constant(OopMapValue::register_mask_in_place) \ | |
2433 declare_constant(OopMapValue::unused_value) \ | |
2434 declare_constant(OopMapValue::oop_value) \ | |
2435 declare_constant(OopMapValue::value_value) \ | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
2436 declare_constant(OopMapValue::narrowoop_value) \ |
0 | 2437 declare_constant(OopMapValue::callee_saved_value) \ |
2438 declare_constant(OopMapValue::derived_oop_value) \ | |
2439 \ | |
2440 /******************/ \ | |
2441 /* JNIHandleBlock */ \ | |
2442 /******************/ \ | |
2443 \ | |
2444 declare_constant(JNIHandleBlock::block_size_in_oops) \ | |
2445 \ | |
2446 /**********************/ \ | |
2447 /* ObjectSynchronizer */ \ | |
2448 /**********************/ \ | |
2449 \ | |
2450 declare_constant(ObjectSynchronizer::_BLOCKSIZE) \ | |
2451 \ | |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2452 /**********************/ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2453 /* PcDesc */ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2454 /**********************/ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2455 \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2456 declare_constant(PcDesc::PCDESC_reexecute) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2457 declare_constant(PcDesc::PCDESC_is_method_handle_invoke) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2458 declare_constant(PcDesc::PCDESC_return_oop) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2459 \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2460 /**********************/ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2461 /* frame */ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2462 /**********************/ \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2463 \ |
6926 | 2464 NOT_ZERO(X86_ONLY(declare_constant(frame::entry_frame_call_wrapper_offset))) \ |
3908
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2465 declare_constant(frame::pc_return_offset) \ |
7588156f5cf9
7051798: SA-JDI: NPE in Frame.addressOfStackSlot(Frame.java:244)
never
parents:
3843
diff
changeset
|
2466 \ |
3962
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2467 /*************/ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2468 /* vmSymbols */ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2469 /*************/ \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2470 \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2471 declare_constant(vmSymbols::FIRST_SID) \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2472 declare_constant(vmSymbols::SID_LIMIT) \ |
cb315dc80374
7092278: "jmap -finalizerinfo" throws "sun.jvm.hotspot.utilities.AssertionFailure: invalid cp index 0 137"
never
parents:
3960
diff
changeset
|
2473 \ |
0 | 2474 /********************************/ \ |
2475 /* Calling convention constants */ \ | |
2476 /********************************/ \ | |
2477 \ | |
2478 declare_constant(RegisterImpl::number_of_registers) \ | |
2479 declare_constant(ConcreteRegisterImpl::number_of_registers) \ | |
2480 declare_preprocessor_constant("REG_COUNT", REG_COUNT) \ | |
2481 declare_c2_preprocessor_constant("SAVED_ON_ENTRY_REG_COUNT", SAVED_ON_ENTRY_REG_COUNT) \ | |
2482 declare_c2_preprocessor_constant("C_SAVED_ON_ENTRY_REG_COUNT", C_SAVED_ON_ENTRY_REG_COUNT) | |
2483 | |
2484 | |
2485 //-------------------------------------------------------------------------------- | |
2486 // VM_LONG_CONSTANTS | |
2487 // | |
2488 // This table contains long constants required over in the | |
2489 // serviceability agent. The "declare_constant" macro is used for all | |
2490 // enums, etc., while "declare_preprocessor_constant" must be used for | |
2491 // all #defined constants. | |
2492 | |
7583 | 2493 #define VM_LONG_CONSTANTS(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant) \ |
0 | 2494 \ |
2495 /*********************/ \ | |
2496 /* MarkOop constants */ \ | |
2497 /*********************/ \ | |
2498 \ | |
2499 /* Note: some of these are declared as long constants just for */ \ | |
2500 /* consistency. The mask constants are the only ones requiring */ \ | |
2501 /* 64 bits (on 64-bit platforms). */ \ | |
2502 \ | |
2503 declare_constant(markOopDesc::age_bits) \ | |
2504 declare_constant(markOopDesc::lock_bits) \ | |
2505 declare_constant(markOopDesc::biased_lock_bits) \ | |
2506 declare_constant(markOopDesc::max_hash_bits) \ | |
2507 declare_constant(markOopDesc::hash_bits) \ | |
2508 \ | |
2509 declare_constant(markOopDesc::lock_shift) \ | |
2510 declare_constant(markOopDesc::biased_lock_shift) \ | |
2511 declare_constant(markOopDesc::age_shift) \ | |
2512 declare_constant(markOopDesc::hash_shift) \ | |
2513 \ | |
2514 declare_constant(markOopDesc::lock_mask) \ | |
2515 declare_constant(markOopDesc::lock_mask_in_place) \ | |
2516 declare_constant(markOopDesc::biased_lock_mask) \ | |
2517 declare_constant(markOopDesc::biased_lock_mask_in_place) \ | |
2518 declare_constant(markOopDesc::biased_lock_bit_in_place) \ | |
2519 declare_constant(markOopDesc::age_mask) \ | |
2520 declare_constant(markOopDesc::age_mask_in_place) \ | |
2521 declare_constant(markOopDesc::hash_mask) \ | |
2522 declare_constant(markOopDesc::hash_mask_in_place) \ | |
2523 declare_constant(markOopDesc::biased_lock_alignment) \ | |
2524 \ | |
2525 declare_constant(markOopDesc::locked_value) \ | |
2526 declare_constant(markOopDesc::unlocked_value) \ | |
2527 declare_constant(markOopDesc::monitor_value) \ | |
2528 declare_constant(markOopDesc::marked_value) \ | |
2529 declare_constant(markOopDesc::biased_lock_pattern) \ | |
2530 \ | |
2531 declare_constant(markOopDesc::no_hash) \ | |
2532 declare_constant(markOopDesc::no_hash_in_place) \ | |
2533 declare_constant(markOopDesc::no_lock_in_place) \ | |
187 | 2534 declare_constant(markOopDesc::max_age) \ |
2535 \ | |
2536 /* Constants in markOop used by CMS. */ \ | |
2537 declare_constant(markOopDesc::cms_shift) \ | |
2538 declare_constant(markOopDesc::cms_mask) \ | |
7583 | 2539 declare_constant(markOopDesc::size_shift) |
0 | 2540 |
2541 | |
2542 //-------------------------------------------------------------------------------- | |
2543 // Macros operating on the above lists | |
2544 //-------------------------------------------------------------------------------- | |
2545 | |
2546 // This utility macro quotes the passed string | |
2547 #define QUOTE(x) #x | |
2548 | |
2549 //-------------------------------------------------------------------------------- | |
2550 // VMStructEntry macros | |
2551 // | |
2552 | |
2553 // This macro generates a VMStructEntry line for a nonstatic field | |
2554 #define GENERATE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \ | |
2555 { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 0, cast_uint64_t(offset_of(typeName, fieldName)), NULL }, | |
2556 | |
2557 // This macro generates a VMStructEntry line for a static field | |
2558 #define GENERATE_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \ | |
2559 { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, &typeName::fieldName }, | |
2560 | |
2561 // This macro generates a VMStructEntry line for an unchecked | |
2562 // nonstatic field, in which the size of the type is also specified. | |
2563 // The type string is given as NULL, indicating an "opaque" type. | |
2564 #define GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \ | |
2565 { QUOTE(typeName), QUOTE(fieldName), NULL, 0, cast_uint64_t(offset_of(typeName, fieldName)), NULL }, | |
2566 | |
2567 // This macro generates a VMStructEntry line for an unchecked | |
2568 // static field, in which the size of the type is also specified. | |
2569 // The type string is given as NULL, indicating an "opaque" type. | |
2570 #define GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \ | |
2571 { QUOTE(typeName), QUOTE(fieldName), NULL, 1, 0, (void*) &typeName::fieldName }, | |
2572 | |
2573 // This macro generates the sentinel value indicating the end of the list | |
2574 #define GENERATE_VM_STRUCT_LAST_ENTRY() \ | |
2575 { NULL, NULL, NULL, 0, 0, NULL } | |
2576 | |
2577 // This macro checks the type of a VMStructEntry by comparing pointer types | |
2578 #define CHECK_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \ | |
7590
fe1472c87a27
8005592: ClassLoaderDataGraph::_unloading incorrectly defined as nonstatic in vmStructs
mikael
parents:
7587
diff
changeset
|
2579 {typeName *dummyObj = NULL; type* dummy = &dummyObj->fieldName; \ |
fe1472c87a27
8005592: ClassLoaderDataGraph::_unloading incorrectly defined as nonstatic in vmStructs
mikael
parents:
7587
diff
changeset
|
2580 assert(offset_of(typeName, fieldName) < sizeof(typeName), "Illegal nonstatic struct entry, field offset too large"); } |
0 | 2581 |
2582 // This macro checks the type of a volatile VMStructEntry by comparing pointer types | |
2583 #define CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \ | |
2584 {typedef type dummyvtype; typeName *dummyObj = NULL; volatile dummyvtype* dummy = &dummyObj->fieldName; } | |
2585 | |
2586 // This macro checks the type of a VMStructEntry by comparing pointer types | |
2587 #define CHECK_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \ | |
2588 {type* dummy = &typeName::fieldName; } | |
2589 | |
2590 // This macro ensures the type of a field and its containing type are | |
2591 // present in the type table. The assertion string is shorter than | |
2592 // preferable because (incredibly) of a bug in Solstice NFS client | |
2593 // which seems to prevent very long lines from compiling. This assertion | |
2594 // means that an entry in VMStructs::localHotSpotVMStructs[] was not | |
2595 // found in VMStructs::localHotSpotVMTypes[]. | |
2596 #define ENSURE_FIELD_TYPE_PRESENT(typeName, fieldName, type) \ | |
2597 { assert(findType(QUOTE(typeName)) != 0, "type \"" QUOTE(typeName) "\" not found in type table"); \ | |
2598 assert(findType(QUOTE(type)) != 0, "type \"" QUOTE(type) "\" not found in type table"); } | |
2599 | |
2600 // This is a no-op macro for unchecked fields | |
2601 #define CHECK_NO_OP(a, b, c) | |
2602 | |
2603 // | |
2604 // Build-specific macros: | |
2605 // | |
2606 | |
2607 // Generate and check a nonstatic field in non-product builds | |
2608 #ifndef PRODUCT | |
2609 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2610 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2611 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c) | |
2612 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2613 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2614 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c) | |
2615 #else | |
2616 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2617 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2618 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) | |
2619 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2620 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2621 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) | |
2622 #endif /* PRODUCT */ | |
2623 | |
2624 // Generate and check a nonstatic field in C1 builds | |
2625 #ifdef COMPILER1 | |
2626 # define GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2627 # define CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2628 # define ENSURE_C1_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c) | |
2629 #else | |
2630 # define GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2631 # define CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2632 # define ENSURE_C1_FIELD_TYPE_PRESENT(a, b, c) | |
2633 #endif /* COMPILER1 */ | |
2634 // Generate and check a nonstatic field in C2 builds | |
2635 #ifdef COMPILER2 | |
2636 # define GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2637 # define CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2638 # define ENSURE_C2_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c) | |
2639 #else | |
2640 # define GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2641 # define CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) | |
2642 # define ENSURE_C2_FIELD_TYPE_PRESENT(a, b, c) | |
2643 #endif /* COMPILER2 */ | |
2644 | |
2645 // Generate but do not check a static field in C1 builds | |
2646 #ifdef COMPILER1 | |
2647 # define GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) | |
2648 #else | |
2649 # define GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) | |
2650 #endif /* COMPILER1 */ | |
2651 | |
2652 // Generate but do not check a static field in C2 builds | |
2653 #ifdef COMPILER2 | |
2654 # define GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) | |
2655 #else | |
2656 # define GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) | |
2657 #endif /* COMPILER2 */ | |
2658 | |
2659 //-------------------------------------------------------------------------------- | |
2660 // VMTypeEntry macros | |
2661 // | |
2662 | |
2663 #define GENERATE_VM_TYPE_ENTRY(type, superclass) \ | |
2664 { QUOTE(type), QUOTE(superclass), 0, 0, 0, sizeof(type) }, | |
2665 | |
2666 #define GENERATE_TOPLEVEL_VM_TYPE_ENTRY(type) \ | |
2667 { QUOTE(type), NULL, 0, 0, 0, sizeof(type) }, | |
2668 | |
2669 #define GENERATE_OOP_VM_TYPE_ENTRY(type) \ | |
2670 { QUOTE(type), NULL, 1, 0, 0, sizeof(type) }, | |
2671 | |
2672 #define GENERATE_INTEGER_VM_TYPE_ENTRY(type) \ | |
2673 { QUOTE(type), NULL, 0, 1, 0, sizeof(type) }, | |
2674 | |
2675 #define GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY(type) \ | |
2676 { QUOTE(type), NULL, 0, 1, 1, sizeof(type) }, | |
2677 | |
2678 #define GENERATE_VM_TYPE_LAST_ENTRY() \ | |
2679 { NULL, NULL, 0, 0, 0, 0 } | |
2680 | |
2681 #define CHECK_VM_TYPE_ENTRY(type, superclass) \ | |
2682 { type* dummyObj = NULL; superclass* dummySuperObj = dummyObj; } | |
2683 | |
2684 #define CHECK_VM_TYPE_NO_OP(a) | |
2685 #define CHECK_SINGLE_ARG_VM_TYPE_NO_OP(a) | |
2686 | |
2687 // | |
2688 // Build-specific macros: | |
2689 // | |
2690 | |
2691 #ifdef COMPILER1 | |
2692 # define GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY(a) GENERATE_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2693 # define CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2694 #else | |
2695 # define GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2696 # define CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2697 #endif /* COMPILER1 */ | |
2698 | |
2699 #ifdef COMPILER2 | |
2700 # define GENERATE_C2_VM_TYPE_ENTRY(a, b) GENERATE_VM_TYPE_ENTRY(a, b) | |
2701 # define CHECK_C2_VM_TYPE_ENTRY(a, b) CHECK_VM_TYPE_ENTRY(a, b) | |
2702 # define GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY(a) GENERATE_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2703 # define CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2704 #else | |
2705 # define GENERATE_C2_VM_TYPE_ENTRY(a, b) | |
2706 # define CHECK_C2_VM_TYPE_ENTRY(a, b) | |
2707 # define GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2708 # define CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY(a) | |
2709 #endif /* COMPILER2 */ | |
2710 | |
2711 | |
2712 //-------------------------------------------------------------------------------- | |
2713 // VMIntConstantEntry macros | |
2714 // | |
2715 | |
2716 #define GENERATE_VM_INT_CONSTANT_ENTRY(name) \ | |
2717 { QUOTE(name), (int32_t) name }, | |
2718 | |
2719 #define GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) \ | |
2720 { name, (int32_t) value }, | |
2721 | |
2722 // This macro generates the sentinel value indicating the end of the list | |
2723 #define GENERATE_VM_INT_CONSTANT_LAST_ENTRY() \ | |
2724 { NULL, 0 } | |
2725 | |
2726 | |
2727 // Generate an int constant for a C1 build | |
2728 #ifdef COMPILER1 | |
2729 # define GENERATE_C1_VM_INT_CONSTANT_ENTRY(name) GENERATE_VM_INT_CONSTANT_ENTRY(name) | |
2730 #else | |
2731 # define GENERATE_C1_VM_INT_CONSTANT_ENTRY(name) | |
2732 #endif /* COMPILER1 */ | |
2733 | |
2734 // Generate an int constant for a C2 build | |
2735 #ifdef COMPILER2 | |
2736 # define GENERATE_C2_VM_INT_CONSTANT_ENTRY(name) GENERATE_VM_INT_CONSTANT_ENTRY(name) | |
2737 # define GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) | |
2738 #else | |
2739 # define GENERATE_C2_VM_INT_CONSTANT_ENTRY(name) | |
2740 # define GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) | |
2741 #endif /* COMPILER1 */ | |
2742 | |
2743 //-------------------------------------------------------------------------------- | |
2744 // VMLongConstantEntry macros | |
2745 // | |
2746 | |
2747 #define GENERATE_VM_LONG_CONSTANT_ENTRY(name) \ | |
2748 { QUOTE(name), cast_uint64_t(name) }, | |
2749 | |
2750 #define GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) \ | |
2751 { name, cast_uint64_t(value) }, | |
2752 | |
2753 // This macro generates the sentinel value indicating the end of the list | |
2754 #define GENERATE_VM_LONG_CONSTANT_LAST_ENTRY() \ | |
2755 { NULL, 0 } | |
2756 | |
2757 // Generate a long constant for a C1 build | |
2758 #ifdef COMPILER1 | |
2759 # define GENERATE_C1_VM_LONG_CONSTANT_ENTRY(name) GENERATE_VM_LONG_CONSTANT_ENTRY(name) | |
2760 #else | |
2761 # define GENERATE_C1_VM_LONG_CONSTANT_ENTRY(name) | |
2762 #endif /* COMPILER1 */ | |
2763 | |
2764 // Generate a long constant for a C2 build | |
2765 #ifdef COMPILER2 | |
2766 # define GENERATE_C2_VM_LONG_CONSTANT_ENTRY(name) GENERATE_VM_LONG_CONSTANT_ENTRY(name) | |
2767 # define GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) | |
2768 #else | |
2769 # define GENERATE_C2_VM_LONG_CONSTANT_ENTRY(name) | |
2770 # define GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) | |
2771 #endif /* COMPILER1 */ | |
2772 | |
2773 // | |
2774 // Instantiation of VMStructEntries, VMTypeEntries and VMIntConstantEntries | |
2775 // | |
2776 | |
2777 // These initializers are allowed to access private fields in classes | |
2778 // as long as class VMStructs is a friend | |
2779 VMStructEntry VMStructs::localHotSpotVMStructs[] = { | |
2780 | |
7583 | 2781 VM_STRUCTS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
2782 GENERATE_STATIC_VM_STRUCT_ENTRY, | |
2783 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, | |
2784 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, | |
2785 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2786 GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY, | |
2787 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2788 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, | |
2789 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY) | |
0 | 2790 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2791 #if INCLUDE_ALL_GCS |
7583 | 2792 VM_STRUCTS_PARALLELGC(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
0 | 2793 GENERATE_STATIC_VM_STRUCT_ENTRY) |
2794 | |
7583 | 2795 VM_STRUCTS_CMS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
2796 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, | |
0 | 2797 GENERATE_STATIC_VM_STRUCT_ENTRY) |
3972 | 2798 |
7583 | 2799 VM_STRUCTS_G1(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
3972 | 2800 GENERATE_STATIC_VM_STRUCT_ENTRY) |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2801 #endif // INCLUDE_ALL_GCS |
0 | 2802 |
7583 | 2803 VM_STRUCTS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
2804 GENERATE_STATIC_VM_STRUCT_ENTRY, | |
2805 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, | |
2806 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, | |
2807 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2808 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2809 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, | |
2810 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY) | |
0 | 2811 |
7583 | 2812 VM_STRUCTS_OS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, |
2813 GENERATE_STATIC_VM_STRUCT_ENTRY, | |
2814 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, | |
2815 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, | |
2816 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2817 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2818 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, | |
2819 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY) | |
2820 | |
2821 GENERATE_VM_STRUCT_LAST_ENTRY() | |
0 | 2822 }; |
2823 | |
2824 VMTypeEntry VMStructs::localHotSpotVMTypes[] = { | |
2825 | |
2826 VM_TYPES(GENERATE_VM_TYPE_ENTRY, | |
2827 GENERATE_TOPLEVEL_VM_TYPE_ENTRY, | |
2828 GENERATE_OOP_VM_TYPE_ENTRY, | |
2829 GENERATE_INTEGER_VM_TYPE_ENTRY, | |
2830 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY, | |
2831 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
2832 GENERATE_C2_VM_TYPE_ENTRY, | |
7583 | 2833 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY) |
0 | 2834 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2835 #if INCLUDE_ALL_GCS |
0 | 2836 VM_TYPES_PARALLELGC(GENERATE_VM_TYPE_ENTRY, |
2837 GENERATE_TOPLEVEL_VM_TYPE_ENTRY) | |
2838 | |
2839 VM_TYPES_CMS(GENERATE_VM_TYPE_ENTRY, | |
2840 GENERATE_TOPLEVEL_VM_TYPE_ENTRY) | |
2841 | |
2842 VM_TYPES_PARNEW(GENERATE_VM_TYPE_ENTRY) | |
3972 | 2843 |
2844 VM_TYPES_G1(GENERATE_VM_TYPE_ENTRY, | |
2845 GENERATE_TOPLEVEL_VM_TYPE_ENTRY) | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2846 #endif // INCLUDE_ALL_GCS |
0 | 2847 |
2848 VM_TYPES_CPU(GENERATE_VM_TYPE_ENTRY, | |
2849 GENERATE_TOPLEVEL_VM_TYPE_ENTRY, | |
2850 GENERATE_OOP_VM_TYPE_ENTRY, | |
2851 GENERATE_INTEGER_VM_TYPE_ENTRY, | |
2852 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY, | |
2853 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
2854 GENERATE_C2_VM_TYPE_ENTRY, | |
7583 | 2855 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY) |
0 | 2856 |
2857 VM_TYPES_OS_CPU(GENERATE_VM_TYPE_ENTRY, | |
2858 GENERATE_TOPLEVEL_VM_TYPE_ENTRY, | |
2859 GENERATE_OOP_VM_TYPE_ENTRY, | |
2860 GENERATE_INTEGER_VM_TYPE_ENTRY, | |
2861 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY, | |
2862 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
2863 GENERATE_C2_VM_TYPE_ENTRY, | |
7583 | 2864 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY) |
2865 | |
2866 GENERATE_VM_TYPE_LAST_ENTRY() | |
0 | 2867 }; |
2868 | |
2869 VMIntConstantEntry VMStructs::localHotSpotVMIntConstants[] = { | |
2870 | |
2871 VM_INT_CONSTANTS(GENERATE_VM_INT_CONSTANT_ENTRY, | |
2872 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY, | |
2873 GENERATE_C1_VM_INT_CONSTANT_ENTRY, | |
2874 GENERATE_C2_VM_INT_CONSTANT_ENTRY, | |
7583 | 2875 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY) |
0 | 2876 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2877 #if INCLUDE_ALL_GCS |
0 | 2878 VM_INT_CONSTANTS_CMS(GENERATE_VM_INT_CONSTANT_ENTRY) |
2879 | |
2880 VM_INT_CONSTANTS_PARNEW(GENERATE_VM_INT_CONSTANT_ENTRY) | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2881 #endif // INCLUDE_ALL_GCS |
0 | 2882 |
2883 VM_INT_CONSTANTS_CPU(GENERATE_VM_INT_CONSTANT_ENTRY, | |
2884 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY, | |
2885 GENERATE_C1_VM_INT_CONSTANT_ENTRY, | |
2886 GENERATE_C2_VM_INT_CONSTANT_ENTRY, | |
7583 | 2887 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY) |
0 | 2888 |
2889 VM_INT_CONSTANTS_OS_CPU(GENERATE_VM_INT_CONSTANT_ENTRY, | |
2890 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY, | |
2891 GENERATE_C1_VM_INT_CONSTANT_ENTRY, | |
2892 GENERATE_C2_VM_INT_CONSTANT_ENTRY, | |
7583 | 2893 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY) |
2894 | |
2895 GENERATE_VM_INT_CONSTANT_LAST_ENTRY() | |
0 | 2896 }; |
2897 | |
2898 VMLongConstantEntry VMStructs::localHotSpotVMLongConstants[] = { | |
2899 | |
2900 VM_LONG_CONSTANTS(GENERATE_VM_LONG_CONSTANT_ENTRY, | |
2901 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY, | |
2902 GENERATE_C1_VM_LONG_CONSTANT_ENTRY, | |
2903 GENERATE_C2_VM_LONG_CONSTANT_ENTRY, | |
7583 | 2904 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY) |
0 | 2905 |
2906 VM_LONG_CONSTANTS_CPU(GENERATE_VM_LONG_CONSTANT_ENTRY, | |
2907 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY, | |
2908 GENERATE_C1_VM_LONG_CONSTANT_ENTRY, | |
2909 GENERATE_C2_VM_LONG_CONSTANT_ENTRY, | |
7583 | 2910 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY) |
0 | 2911 |
2912 VM_LONG_CONSTANTS_OS_CPU(GENERATE_VM_LONG_CONSTANT_ENTRY, | |
2913 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY, | |
2914 GENERATE_C1_VM_LONG_CONSTANT_ENTRY, | |
2915 GENERATE_C2_VM_LONG_CONSTANT_ENTRY, | |
7583 | 2916 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY) |
2917 | |
2918 GENERATE_VM_LONG_CONSTANT_LAST_ENTRY() | |
0 | 2919 }; |
2920 | |
2921 // This is used both to check the types of referenced fields and, in | |
2922 // debug builds, to ensure that all of the field types are present. | |
2923 void | |
2924 VMStructs::init() { | |
2925 VM_STRUCTS(CHECK_NONSTATIC_VM_STRUCT_ENTRY, | |
2926 CHECK_STATIC_VM_STRUCT_ENTRY, | |
2927 CHECK_NO_OP, | |
2928 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY, | |
2929 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2930 CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY, | |
2931 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2932 CHECK_NO_OP, | |
7583 | 2933 CHECK_NO_OP); |
0 | 2934 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2935 #if INCLUDE_ALL_GCS |
0 | 2936 VM_STRUCTS_PARALLELGC(CHECK_NONSTATIC_VM_STRUCT_ENTRY, |
2937 CHECK_STATIC_VM_STRUCT_ENTRY); | |
2938 | |
2939 VM_STRUCTS_CMS(CHECK_NONSTATIC_VM_STRUCT_ENTRY, | |
187 | 2940 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY, |
0 | 2941 CHECK_STATIC_VM_STRUCT_ENTRY); |
3972 | 2942 |
2943 VM_STRUCTS_G1(CHECK_NONSTATIC_VM_STRUCT_ENTRY, | |
2944 CHECK_STATIC_VM_STRUCT_ENTRY); | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2945 #endif // INCLUDE_ALL_GCS |
0 | 2946 |
2947 VM_STRUCTS_CPU(CHECK_NONSTATIC_VM_STRUCT_ENTRY, | |
2948 CHECK_STATIC_VM_STRUCT_ENTRY, | |
2949 CHECK_NO_OP, | |
2950 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY, | |
2951 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2952 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2953 CHECK_NO_OP, | |
7583 | 2954 CHECK_NO_OP); |
0 | 2955 |
2956 VM_STRUCTS_OS_CPU(CHECK_NONSTATIC_VM_STRUCT_ENTRY, | |
2957 CHECK_STATIC_VM_STRUCT_ENTRY, | |
2958 CHECK_NO_OP, | |
2959 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY, | |
2960 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, | |
2961 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY, | |
2962 CHECK_NO_OP, | |
7583 | 2963 CHECK_NO_OP); |
0 | 2964 |
2965 VM_TYPES(CHECK_VM_TYPE_ENTRY, | |
2966 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2967 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2968 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2969 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2970 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
2971 CHECK_C2_VM_TYPE_ENTRY, | |
7583 | 2972 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY); |
0 | 2973 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2974 #if INCLUDE_ALL_GCS |
0 | 2975 VM_TYPES_PARALLELGC(CHECK_VM_TYPE_ENTRY, |
2976 CHECK_SINGLE_ARG_VM_TYPE_NO_OP); | |
2977 | |
2978 VM_TYPES_CMS(CHECK_VM_TYPE_ENTRY, | |
2979 CHECK_SINGLE_ARG_VM_TYPE_NO_OP); | |
2980 | |
2981 VM_TYPES_PARNEW(CHECK_VM_TYPE_ENTRY) | |
3972 | 2982 |
2983 VM_TYPES_G1(CHECK_VM_TYPE_ENTRY, | |
2984 CHECK_SINGLE_ARG_VM_TYPE_NO_OP); | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
2985 #endif // INCLUDE_ALL_GCS |
0 | 2986 |
2987 VM_TYPES_CPU(CHECK_VM_TYPE_ENTRY, | |
2988 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2989 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2990 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2991 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2992 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
2993 CHECK_C2_VM_TYPE_ENTRY, | |
7583 | 2994 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY); |
0 | 2995 |
2996 VM_TYPES_OS_CPU(CHECK_VM_TYPE_ENTRY, | |
2997 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2998 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
2999 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
3000 CHECK_SINGLE_ARG_VM_TYPE_NO_OP, | |
3001 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY, | |
3002 CHECK_C2_VM_TYPE_ENTRY, | |
7583 | 3003 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY); |
0 | 3004 |
3005 // | |
3006 // Split VM_STRUCTS() invocation into two parts to allow MS VC++ 6.0 | |
3007 // to build with the source mounted over SNC3.2. Symptom was that | |
3008 // debug build failed with an internal compiler error. Has been seen | |
3009 // mounting sources from Solaris 2.6 and 2.7 hosts, but so far not | |
3010 // 2.8 hosts. Appears to occur because line is too long. | |
3011 // | |
3012 // If an assertion failure is triggered here it means that an entry | |
3013 // in VMStructs::localHotSpotVMStructs[] was not found in | |
3014 // VMStructs::localHotSpotVMTypes[]. (The assertion itself had to be | |
3015 // made less descriptive because of this above bug -- see the | |
3016 // definition of ENSURE_FIELD_TYPE_PRESENT.) | |
3017 // | |
3018 // NOTE: taken out because this was just not working on everyone's | |
3019 // Solstice NFS setup. If everyone switches to local workspaces on | |
3020 // Win32, we can put this back in. | |
3021 #ifndef _WINDOWS | |
7583 | 3022 debug_only(VM_STRUCTS(ENSURE_FIELD_TYPE_PRESENT, |
3023 CHECK_NO_OP, | |
3024 CHECK_NO_OP, | |
3025 CHECK_NO_OP, | |
3026 CHECK_NO_OP, | |
3027 CHECK_NO_OP, | |
3028 CHECK_NO_OP, | |
3029 CHECK_NO_OP, | |
3030 CHECK_NO_OP)); | |
3031 debug_only(VM_STRUCTS(CHECK_NO_OP, | |
3032 ENSURE_FIELD_TYPE_PRESENT, | |
3033 CHECK_NO_OP, | |
3034 ENSURE_FIELD_TYPE_PRESENT, | |
3035 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, | |
3036 ENSURE_C1_FIELD_TYPE_PRESENT, | |
3037 ENSURE_C2_FIELD_TYPE_PRESENT, | |
3038 CHECK_NO_OP, | |
3039 CHECK_NO_OP)); | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
3040 #if INCLUDE_ALL_GCS |
7583 | 3041 debug_only(VM_STRUCTS_PARALLELGC(ENSURE_FIELD_TYPE_PRESENT, |
0 | 3042 ENSURE_FIELD_TYPE_PRESENT)); |
7583 | 3043 debug_only(VM_STRUCTS_CMS(ENSURE_FIELD_TYPE_PRESENT, |
3044 ENSURE_FIELD_TYPE_PRESENT, | |
0 | 3045 ENSURE_FIELD_TYPE_PRESENT)); |
7583 | 3046 debug_only(VM_STRUCTS_G1(ENSURE_FIELD_TYPE_PRESENT, |
3972 | 3047 ENSURE_FIELD_TYPE_PRESENT)); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7615
diff
changeset
|
3048 #endif // INCLUDE_ALL_GCS |
7583 | 3049 debug_only(VM_STRUCTS_CPU(ENSURE_FIELD_TYPE_PRESENT, |
3050 ENSURE_FIELD_TYPE_PRESENT, | |
3051 CHECK_NO_OP, | |
3052 ENSURE_FIELD_TYPE_PRESENT, | |
3053 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, | |
3054 ENSURE_C2_FIELD_TYPE_PRESENT, | |
3055 CHECK_NO_OP, | |
3056 CHECK_NO_OP)); | |
3057 debug_only(VM_STRUCTS_OS_CPU(ENSURE_FIELD_TYPE_PRESENT, | |
3058 ENSURE_FIELD_TYPE_PRESENT, | |
3059 CHECK_NO_OP, | |
3060 ENSURE_FIELD_TYPE_PRESENT, | |
3061 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, | |
3062 ENSURE_C2_FIELD_TYPE_PRESENT, | |
3063 CHECK_NO_OP, | |
3064 CHECK_NO_OP)); | |
0 | 3065 #endif |
3066 } | |
3067 | |
3068 extern "C" { | |
3069 | |
3070 // see comments on cast_uint64_t at the top of this file | |
3071 #define ASSIGN_CONST_TO_64BIT_VAR(var, expr) \ | |
3072 JNIEXPORT uint64_t var = cast_uint64_t(expr); | |
3073 #define ASSIGN_OFFSET_TO_64BIT_VAR(var, type, field) \ | |
3074 ASSIGN_CONST_TO_64BIT_VAR(var, offset_of(type, field)) | |
3075 #define ASSIGN_STRIDE_TO_64BIT_VAR(var, array) \ | |
3076 ASSIGN_CONST_TO_64BIT_VAR(var, (char*)&array[1] - (char*)&array[0]) | |
3077 | |
3078 JNIEXPORT VMStructEntry* gHotSpotVMStructs = VMStructs::localHotSpotVMStructs; | |
3079 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryTypeNameOffset, VMStructEntry, typeName); | |
3080 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryFieldNameOffset, VMStructEntry, fieldName); | |
3081 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryTypeStringOffset, VMStructEntry, typeString); | |
3082 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryIsStaticOffset, VMStructEntry, isStatic); | |
3083 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryOffsetOffset, VMStructEntry, offset); | |
3084 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryAddressOffset, VMStructEntry, address); | |
3085 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMStructEntryArrayStride, gHotSpotVMStructs); | |
3086 JNIEXPORT VMTypeEntry* gHotSpotVMTypes = VMStructs::localHotSpotVMTypes; | |
3087 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryTypeNameOffset, VMTypeEntry, typeName); | |
3088 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntrySuperclassNameOffset, VMTypeEntry, superclassName); | |
3089 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsOopTypeOffset, VMTypeEntry, isOopType); | |
3090 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsIntegerTypeOffset, VMTypeEntry, isIntegerType); | |
3091 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsUnsignedOffset, VMTypeEntry, isUnsigned); | |
3092 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntrySizeOffset, VMTypeEntry, size); | |
3093 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMTypeEntryArrayStride,gHotSpotVMTypes); | |
3094 JNIEXPORT VMIntConstantEntry* gHotSpotVMIntConstants = VMStructs::localHotSpotVMIntConstants; | |
3095 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMIntConstantEntryNameOffset, VMIntConstantEntry, name); | |
3096 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMIntConstantEntryValueOffset, VMIntConstantEntry, value); | |
3097 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMIntConstantEntryArrayStride, gHotSpotVMIntConstants); | |
3098 JNIEXPORT VMLongConstantEntry* gHotSpotVMLongConstants = VMStructs::localHotSpotVMLongConstants; | |
3099 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMLongConstantEntryNameOffset, VMLongConstantEntry, name); | |
3100 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMLongConstantEntryValueOffset, VMLongConstantEntry, value); | |
3101 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMLongConstantEntryArrayStride, gHotSpotVMLongConstants); | |
3102 } | |
3103 | |
3104 #ifdef ASSERT | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3105 static int recursiveFindType(VMTypeEntry* origtypes, const char* typeName, bool isRecurse) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3106 { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3107 VMTypeEntry* types = origtypes; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3108 while (types->typeName != NULL) { |
3939 | 3109 if (strcmp(typeName, types->typeName) == 0) { |
3110 // Found it | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3111 return 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3112 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3113 ++types; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3114 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3115 } |
3939 | 3116 // Search for the base type by peeling off const and * |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3117 size_t len = strlen(typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3118 if (typeName[len-1] == '*') { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3119 char * s = new char[len]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3120 strncpy(s, typeName, len - 1); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3121 s[len-1] = '\0'; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3122 // tty->print_cr("checking \"%s\" for \"%s\"", s, typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3123 if (recursiveFindType(origtypes, s, true) == 1) { |
7584 | 3124 delete [] s; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3125 return 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3126 } |
7584 | 3127 delete [] s; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3128 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3129 const char* start = NULL; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3130 if (strstr(typeName, "GrowableArray<") == typeName) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3131 start = typeName + strlen("GrowableArray<"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3132 } else if (strstr(typeName, "Array<") == typeName) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3133 start = typeName + strlen("Array<"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3134 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6641
diff
changeset
|
3135 if (start != NULL) { |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3136 const char * end = strrchr(typeName, '>'); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3137 int len = end - start + 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3138 char * s = new char[len]; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3139 strncpy(s, start, len - 1); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3140 s[len-1] = '\0'; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3141 // tty->print_cr("checking \"%s\" for \"%s\"", s, typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3142 if (recursiveFindType(origtypes, s, true) == 1) { |
7584 | 3143 delete [] s; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3144 return 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3145 } |
7584 | 3146 delete [] s; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3147 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3148 if (strstr(typeName, "const ") == typeName) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3149 const char * s = typeName + strlen("const "); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3150 // tty->print_cr("checking \"%s\" for \"%s\"", s, typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3151 if (recursiveFindType(origtypes, s, true) == 1) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3152 return 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3153 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3154 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3155 if (strstr(typeName, " const") == typeName + len - 6) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3156 char * s = strdup(typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3157 s[len - 6] = '\0'; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3158 // tty->print_cr("checking \"%s\" for \"%s\"", s, typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3159 if (recursiveFindType(origtypes, s, true) == 1) { |
7584 | 3160 free(s); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3161 return 1; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3162 } |
7584 | 3163 free(s); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3164 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3165 if (!isRecurse) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3166 tty->print_cr("type \"%s\" not found", typeName); |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3167 } |
3940 | 3168 return 0; |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3169 } |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3170 |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3171 |
0 | 3172 int |
3173 VMStructs::findType(const char* typeName) { | |
3174 VMTypeEntry* types = gHotSpotVMTypes; | |
3175 | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2119
diff
changeset
|
3176 return recursiveFindType(types, typeName, false); |
0 | 3177 } |
3178 #endif | |
3179 | |
3180 void vmStructs_init() { | |
3181 debug_only(VMStructs::init()); | |
3182 } | |
7171 | 3183 |
3184 #ifndef PRODUCT | |
3185 void VMStructs::test() { | |
7583 | 3186 // Make sure last entry in the each array is indeed the correct end marker. |
3187 // The reason why these are static is to make sure they are zero initialized. | |
3188 // Putting them on the stack will leave some garbage in the padding of some fields. | |
3189 static VMStructEntry struct_last_entry = GENERATE_VM_STRUCT_LAST_ENTRY(); | |
3190 assert(memcmp(&localHotSpotVMStructs[(sizeof(localHotSpotVMStructs) / sizeof(VMStructEntry)) - 1], | |
3191 &struct_last_entry, | |
3192 sizeof(VMStructEntry)) == 0, "Incorrect last entry in localHotSpotVMStructs"); | |
3193 | |
3194 static VMTypeEntry type_last_entry = GENERATE_VM_TYPE_LAST_ENTRY(); | |
3195 assert(memcmp(&localHotSpotVMTypes[sizeof(localHotSpotVMTypes) / sizeof(VMTypeEntry) - 1], | |
3196 &type_last_entry, | |
3197 sizeof(VMTypeEntry)) == 0, "Incorrect last entry in localHotSpotVMTypes"); | |
3198 | |
3199 static VMIntConstantEntry int_last_entry = GENERATE_VM_INT_CONSTANT_LAST_ENTRY(); | |
3200 assert(memcmp(&localHotSpotVMIntConstants[sizeof(localHotSpotVMIntConstants) / sizeof(VMIntConstantEntry) - 1], | |
3201 &int_last_entry, | |
3202 sizeof(VMIntConstantEntry)) == 0, "Incorrect last entry in localHotSpotVMIntConstants"); | |
3203 | |
3204 static VMLongConstantEntry long_last_entry = GENERATE_VM_LONG_CONSTANT_LAST_ENTRY(); | |
3205 assert(memcmp(&localHotSpotVMLongConstants[sizeof(localHotSpotVMLongConstants) / sizeof(VMLongConstantEntry) - 1], | |
3206 &long_last_entry, | |
3207 sizeof(VMLongConstantEntry)) == 0, "Incorrect last entry in localHotSpotVMLongConstants"); | |
3208 | |
3209 | |
7171 | 3210 // Check for duplicate entries in type array |
3211 for (int i = 0; localHotSpotVMTypes[i].typeName != NULL; i++) { | |
3212 for (int j = i + 1; localHotSpotVMTypes[j].typeName != NULL; j++) { | |
3213 if (strcmp(localHotSpotVMTypes[i].typeName, localHotSpotVMTypes[j].typeName) == 0) { | |
3214 tty->print_cr("Duplicate entries for '%s'", localHotSpotVMTypes[i].typeName); | |
3215 assert(false, "Duplicate types in localHotSpotVMTypes array"); | |
3216 } | |
3217 } | |
3218 } | |
3219 } | |
3220 #endif |