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