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