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