annotate src/share/vm/runtime/vmStructs.cpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank
author ysr
date Wed, 07 Sep 2011 13:55:42 -0700
parents d17bd0b18663
children 7588156f5cf9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2119
d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl
kvn
parents: 2011
diff changeset
2 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
26 #include "classfile/dictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
27 #include "classfile/javaClasses.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
28 #include "classfile/loaderConstraints.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
29 #include "classfile/placeholders.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
30 #include "classfile/symbolTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
31 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
32 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
33 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
34 #include "code/compressedStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
35 #include "code/location.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
36 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
37 #include "code/pcDesc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
38 #include "code/stubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
39 #include "code/vmreg.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
40 #include "compiler/oopMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
41 #include "gc_implementation/concurrentMarkSweep/freeBlockDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
42 #include "gc_implementation/shared/immutableSpace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
43 #include "gc_implementation/shared/markSweep.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
44 #include "gc_implementation/shared/mutableSpace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
45 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
46 #include "interpreter/bytecodeInterpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
47 #include "interpreter/bytecodes.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
48 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
49 #include "memory/cardTableRS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
50 #include "memory/compactPermGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
51 #include "memory/defNewGeneration.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
52 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
53 #include "memory/generation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
54 #include "memory/generationSpec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
55 #include "memory/heap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
56 #include "memory/permGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
57 #include "memory/space.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
58 #include "memory/tenuredGeneration.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
59 #include "memory/universe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
60 #include "memory/watermark.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
61 #include "oops/arrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
62 #include "oops/arrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
63 #include "oops/arrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
64 #include "oops/compiledICHolderKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
65 #include "oops/compiledICHolderOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
66 #include "oops/constMethodKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
67 #include "oops/constMethodOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
68 #include "oops/constantPoolKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
69 #include "oops/constantPoolOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
70 #include "oops/cpCacheKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
71 #include "oops/cpCacheOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
72 #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
73 #include "oops/instanceMirrorKlass.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
74 #include "oops/instanceKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
75 #include "oops/instanceOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
76 #include "oops/klass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
77 #include "oops/klassOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
78 #include "oops/markOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
79 #include "oops/methodDataKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
80 #include "oops/methodDataOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
81 #include "oops/methodKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
82 #include "oops/methodOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
83 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
84 #include "oops/objArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
85 #include "oops/objArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
86 #include "oops/oop.inline.hpp"
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
87 #include "oops/symbol.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
88 #include "oops/typeArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
89 #include "oops/typeArrayKlassKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
90 #include "oops/typeArrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
91 #include "prims/jvmtiAgentThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
92 #include "runtime/arguments.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
93 #include "runtime/globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
94 #include "runtime/java.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
95 #include "runtime/javaCalls.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
96 #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
97 #include "runtime/serviceThread.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
98 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
99 #include "runtime/stubRoutines.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
100 #include "runtime/virtualspace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
101 #include "runtime/vmStructs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
102 #include "utilities/globalDefinitions.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
103 #include "utilities/hashtable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
104 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
105 # include "vmStructs_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
106 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
107 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
108 # include "vmStructs_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
109 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
110 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
111 # include "vmStructs_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
112 #endif
2192
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
113 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
114 # include "vmStructs_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
115 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
116 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
117 # include "vmStructs_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
118 #endif
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
119 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
120 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
121 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
122 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
123 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
124 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
125 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
126 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
127 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
128 #ifdef TARGET_OS_ARCH_linux_x86
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
129 # include "vmStructs_linux_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
130 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
131 #ifdef TARGET_OS_ARCH_linux_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
132 # include "vmStructs_linux_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
133 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
134 #ifdef TARGET_OS_ARCH_linux_zero
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
135 # include "vmStructs_linux_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
136 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
137 #ifdef TARGET_OS_ARCH_solaris_x86
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
138 # include "vmStructs_solaris_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
139 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
140 #ifdef TARGET_OS_ARCH_solaris_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
141 # include "vmStructs_solaris_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
142 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
143 #ifdef TARGET_OS_ARCH_windows_x86
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
144 # include "vmStructs_windows_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
145 #endif
2192
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
146 #ifdef TARGET_OS_ARCH_linux_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
147 # include "vmStructs_linux_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
148 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
149 #ifdef TARGET_OS_ARCH_linux_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
150 # include "vmStructs_linux_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
151 #endif
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
152 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
153 #include "gc_implementation/concurrentMarkSweep/cmsPermGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
154 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
155 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
156 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
157 #include "gc_implementation/concurrentMarkSweep/vmStructs_cms.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
158 #include "gc_implementation/parNew/parNewGeneration.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
159 #include "gc_implementation/parNew/vmStructs_parNew.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
160 #include "gc_implementation/parallelScavenge/asPSOldGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
161 #include "gc_implementation/parallelScavenge/asPSYoungGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
162 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
163 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
164 #include "gc_implementation/parallelScavenge/psPermGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
165 #include "gc_implementation/parallelScavenge/psVirtualspace.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
166 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
167 #include "gc_implementation/parallelScavenge/vmStructs_parallelgc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
168 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
169 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
170 #include "opto/matcher.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
171 #ifdef TARGET_ARCH_MODEL_x86_32
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
172 # include "adfiles/adGlobals_x86_32.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
173 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
174 #ifdef TARGET_ARCH_MODEL_x86_64
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
175 # include "adfiles/adGlobals_x86_64.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
176 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
177 #ifdef TARGET_ARCH_MODEL_sparc
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
178 # include "adfiles/adGlobals_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
179 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
180 #ifdef TARGET_ARCH_MODEL_zero
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
181 # include "adfiles/adGlobals_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
182 #endif
2192
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
183 #ifdef TARGET_ARCH_MODEL_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
184 # include "adfiles/adGlobals_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
185 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
186 #ifdef TARGET_ARCH_MODEL_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
187 # include "adfiles/adGlobals_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository
bobv
parents: 2177
diff changeset
188 #endif
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1917
diff changeset
189 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
190
a61af66fc99e Initial load
duke
parents:
diff changeset
191 // Note: the cross-product of (c1, c2, product, nonproduct, ...),
a61af66fc99e Initial load
duke
parents:
diff changeset
192 // (nonstatic, static), and (unchecked, checked) has not been taken.
a61af66fc99e Initial load
duke
parents:
diff changeset
193 // Only the macros currently needed have been defined.
a61af66fc99e Initial load
duke
parents:
diff changeset
194
a61af66fc99e Initial load
duke
parents:
diff changeset
195 // A field whose type is not checked is given a null string as the
a61af66fc99e Initial load
duke
parents:
diff changeset
196 // type name, indicating an "opaque" type to the serviceability agent.
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 // NOTE: there is an interdependency between this file and
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // HotSpotTypeDataBase.java, which parses the type strings.
a61af66fc99e Initial load
duke
parents:
diff changeset
200
a61af66fc99e Initial load
duke
parents:
diff changeset
201 #ifndef REG_COUNT
a61af66fc99e Initial load
duke
parents:
diff changeset
202 #define REG_COUNT 0
a61af66fc99e Initial load
duke
parents:
diff changeset
203 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
204
a61af66fc99e Initial load
duke
parents:
diff changeset
205 // whole purpose of this function is to work around bug c++/27724 in gcc 4.1.1
a61af66fc99e Initial load
duke
parents:
diff changeset
206 // with optimization turned on it doesn't affect produced code
a61af66fc99e Initial load
duke
parents:
diff changeset
207 static inline uint64_t cast_uint64_t(size_t x)
a61af66fc99e Initial load
duke
parents:
diff changeset
208 {
a61af66fc99e Initial load
duke
parents:
diff changeset
209 return x;
a61af66fc99e Initial load
duke
parents:
diff changeset
210 }
a61af66fc99e Initial load
duke
parents:
diff changeset
211
a61af66fc99e Initial load
duke
parents:
diff changeset
212
a61af66fc99e Initial load
duke
parents:
diff changeset
213 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
214 // VM_STRUCTS
a61af66fc99e Initial load
duke
parents:
diff changeset
215 //
a61af66fc99e Initial load
duke
parents:
diff changeset
216 // This list enumerates all of the fields the serviceability agent
a61af66fc99e Initial load
duke
parents:
diff changeset
217 // needs to know about. Be sure to see also the type table below this one.
a61af66fc99e Initial load
duke
parents:
diff changeset
218 // NOTE that there are platform-specific additions to this table in
a61af66fc99e Initial load
duke
parents:
diff changeset
219 // vmStructs_<os>_<cpu>.hpp.
a61af66fc99e Initial load
duke
parents:
diff changeset
220
a61af66fc99e Initial load
duke
parents:
diff changeset
221 #define VM_STRUCTS(nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
222 static_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
223 unchecked_nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
224 volatile_nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
225 nonproduct_nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
226 c1_nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
227 c2_nonstatic_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
228 unchecked_c1_static_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
229 unchecked_c2_static_field, \
a61af66fc99e Initial load
duke
parents:
diff changeset
230 last_entry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
231 \
a61af66fc99e Initial load
duke
parents:
diff changeset
232 /******************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
233 /* OopDesc and Klass hierarchies (NOTE: methodDataOop incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
234 /******************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
235 \
a61af66fc99e Initial load
duke
parents:
diff changeset
236 volatile_nonstatic_field(oopDesc, _mark, markOop) \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
237 volatile_nonstatic_field(oopDesc, _metadata._klass, wideKlassOop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
238 volatile_nonstatic_field(oopDesc, _metadata._compressed_klass, narrowOop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
239 static_field(oopDesc, _bs, BarrierSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
240 nonstatic_field(arrayKlass, _dimension, int) \
2119
d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl
kvn
parents: 2011
diff changeset
241 volatile_nonstatic_field(arrayKlass, _higher_dimension, klassOop) \
d4fca0a6abde 7011386: race in objArrayKlass::array_klass_impl
kvn
parents: 2011
diff changeset
242 volatile_nonstatic_field(arrayKlass, _lower_dimension, klassOop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
243 nonstatic_field(arrayKlass, _vtable_len, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
244 nonstatic_field(arrayKlass, _alloc_size, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
245 nonstatic_field(arrayKlass, _component_mirror, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
246 nonstatic_field(compiledICHolderKlass, _alloc_size, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
247 nonstatic_field(compiledICHolderOopDesc, _holder_method, methodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
248 nonstatic_field(compiledICHolderOopDesc, _holder_klass, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
249 nonstatic_field(constantPoolOopDesc, _tags, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
250 nonstatic_field(constantPoolOopDesc, _cache, constantPoolCacheOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
251 nonstatic_field(constantPoolOopDesc, _pool_holder, klassOop) \
1917
f42a2f0c16bb 6996563: 6984311 changes forgot to update vmStructs.cpp for new field _operands
jrose
parents: 1913
diff changeset
252 nonstatic_field(constantPoolOopDesc, _operands, typeArrayOop) \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
253 nonstatic_field(constantPoolOopDesc, _length, int) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
254 nonstatic_field(constantPoolCacheOopDesc, _length, int) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
255 nonstatic_field(constantPoolCacheOopDesc, _constant_pool, constantPoolOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
256 nonstatic_field(instanceKlass, _array_klasses, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
257 nonstatic_field(instanceKlass, _methods, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
258 nonstatic_field(instanceKlass, _method_ordering, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
259 nonstatic_field(instanceKlass, _local_interfaces, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
260 nonstatic_field(instanceKlass, _transitive_interfaces, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
261 nonstatic_field(instanceKlass, _nof_implementors, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
262 nonstatic_field(instanceKlass, _implementors[0], klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
263 nonstatic_field(instanceKlass, _fields, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
264 nonstatic_field(instanceKlass, _constants, constantPoolOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
265 nonstatic_field(instanceKlass, _class_loader, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
266 nonstatic_field(instanceKlass, _protection_domain, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
267 nonstatic_field(instanceKlass, _signers, objArrayOop) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
268 nonstatic_field(instanceKlass, _source_file_name, Symbol*) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
269 nonstatic_field(instanceKlass, _source_debug_extension, Symbol*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
270 nonstatic_field(instanceKlass, _inner_classes, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
271 nonstatic_field(instanceKlass, _nonstatic_field_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
272 nonstatic_field(instanceKlass, _static_field_size, int) \
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
273 nonstatic_field(instanceKlass, _static_oop_field_count, int) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
274 nonstatic_field(instanceKlass, _nonstatic_oop_map_size, int) \
975
83c29a26f67c 6879572: SA fails _is_marked_dependent not found
acorn
parents: 973
diff changeset
275 nonstatic_field(instanceKlass, _is_marked_dependent, bool) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
276 nonstatic_field(instanceKlass, _minor_version, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
277 nonstatic_field(instanceKlass, _major_version, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
278 nonstatic_field(instanceKlass, _init_state, instanceKlass::ClassState) \
a61af66fc99e Initial load
duke
parents:
diff changeset
279 nonstatic_field(instanceKlass, _init_thread, Thread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
280 nonstatic_field(instanceKlass, _vtable_len, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
281 nonstatic_field(instanceKlass, _itable_len, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
282 nonstatic_field(instanceKlass, _reference_type, ReferenceType) \
a61af66fc99e Initial load
duke
parents:
diff changeset
283 volatile_nonstatic_field(instanceKlass, _oop_map_cache, OopMapCache*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
284 nonstatic_field(instanceKlass, _jni_ids, JNIid*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
285 nonstatic_field(instanceKlass, _osr_nmethods_head, nmethod*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
286 nonstatic_field(instanceKlass, _breakpoints, BreakpointInfo*) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
287 nonstatic_field(instanceKlass, _generic_signature, Symbol*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
288 nonstatic_field(instanceKlass, _methods_jmethod_ids, jmethodID*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
289 nonstatic_field(instanceKlass, _methods_cached_itable_indices, int*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
290 volatile_nonstatic_field(instanceKlass, _idnum_allocated_count, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
291 nonstatic_field(instanceKlass, _class_annotations, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
292 nonstatic_field(instanceKlass, _fields_annotations, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
293 nonstatic_field(instanceKlass, _methods_annotations, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
294 nonstatic_field(instanceKlass, _methods_parameter_annotations, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
295 nonstatic_field(instanceKlass, _methods_default_annotations, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
296 nonstatic_field(Klass, _super_check_offset, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
297 nonstatic_field(Klass, _secondary_super_cache, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
298 nonstatic_field(Klass, _secondary_supers, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
299 nonstatic_field(Klass, _primary_supers[0], klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
300 nonstatic_field(Klass, _java_mirror, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
301 nonstatic_field(Klass, _modifier_flags, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
302 nonstatic_field(Klass, _super, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
303 nonstatic_field(Klass, _layout_helper, jint) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
304 nonstatic_field(Klass, _name, Symbol*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
305 nonstatic_field(Klass, _access_flags, AccessFlags) \
a61af66fc99e Initial load
duke
parents:
diff changeset
306 nonstatic_field(Klass, _subklass, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
307 nonstatic_field(Klass, _next_sibling, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
308 nonproduct_nonstatic_field(Klass, _verify_count, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
309 nonstatic_field(Klass, _alloc_count, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
310 nonstatic_field(klassKlass, _alloc_size, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
311 nonstatic_field(methodKlass, _alloc_size, juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
312 nonstatic_field(methodDataOopDesc, _size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
313 nonstatic_field(methodDataOopDesc, _method, methodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
314 nonstatic_field(methodOopDesc, _constMethod, constMethodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
315 nonstatic_field(methodOopDesc, _constants, constantPoolOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
316 c2_nonstatic_field(methodOopDesc, _method_data, methodDataOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
317 c2_nonstatic_field(methodOopDesc, _interpreter_invocation_count, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
318 nonstatic_field(methodOopDesc, _access_flags, AccessFlags) \
a61af66fc99e Initial load
duke
parents:
diff changeset
319 nonstatic_field(methodOopDesc, _vtable_index, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
320 nonstatic_field(methodOopDesc, _method_size, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
321 nonstatic_field(methodOopDesc, _max_stack, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
322 nonstatic_field(methodOopDesc, _max_locals, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
323 nonstatic_field(methodOopDesc, _size_of_parameters, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
324 c2_nonstatic_field(methodOopDesc, _interpreter_throwout_count, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
325 nonstatic_field(methodOopDesc, _number_of_breakpoints, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
326 nonstatic_field(methodOopDesc, _invocation_counter, InvocationCounter) \
a61af66fc99e Initial load
duke
parents:
diff changeset
327 nonstatic_field(methodOopDesc, _backedge_counter, InvocationCounter) \
a61af66fc99e Initial load
duke
parents:
diff changeset
328 nonproduct_nonstatic_field(methodOopDesc, _compiled_invocation_count, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
329 volatile_nonstatic_field(methodOopDesc, _code, nmethod*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
330 nonstatic_field(methodOopDesc, _i2i_entry, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
331 nonstatic_field(methodOopDesc, _adapter, AdapterHandlerEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
332 volatile_nonstatic_field(methodOopDesc, _from_compiled_entry, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
333 volatile_nonstatic_field(methodOopDesc, _from_interpreted_entry, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
334 volatile_nonstatic_field(constMethodOopDesc, _fingerprint, uint64_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
335 nonstatic_field(constMethodOopDesc, _method, methodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
336 nonstatic_field(constMethodOopDesc, _stackmap_data, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
337 nonstatic_field(constMethodOopDesc, _exception_table, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
338 nonstatic_field(constMethodOopDesc, _constMethod_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
339 nonstatic_field(constMethodOopDesc, _interpreter_kind, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
340 nonstatic_field(constMethodOopDesc, _flags, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
341 nonstatic_field(constMethodOopDesc, _code_size, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
342 nonstatic_field(constMethodOopDesc, _name_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
343 nonstatic_field(constMethodOopDesc, _signature_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
344 nonstatic_field(constMethodOopDesc, _method_idnum, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
345 nonstatic_field(constMethodOopDesc, _generic_signature_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
346 nonstatic_field(objArrayKlass, _element_klass, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
347 nonstatic_field(objArrayKlass, _bottom_klass, klassOop) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
348 volatile_nonstatic_field(Symbol, _refcount, int) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
349 nonstatic_field(Symbol, _identity_hash, int) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
350 nonstatic_field(Symbol, _length, unsigned short) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
351 unchecked_nonstatic_field(Symbol, _body, sizeof(jbyte)) /* NOTE: no type */ \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
352 nonstatic_field(typeArrayKlass, _max_length, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
353 \
a61af66fc99e Initial load
duke
parents:
diff changeset
354 /***********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
355 /* Constant Pool Cache */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
356 /***********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
357 \
a61af66fc99e Initial load
duke
parents:
diff changeset
358 volatile_nonstatic_field(ConstantPoolCacheEntry, _indices, intx) \
a61af66fc99e Initial load
duke
parents:
diff changeset
359 volatile_nonstatic_field(ConstantPoolCacheEntry, _f1, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
360 volatile_nonstatic_field(ConstantPoolCacheEntry, _f2, intx) \
a61af66fc99e Initial load
duke
parents:
diff changeset
361 volatile_nonstatic_field(ConstantPoolCacheEntry, _flags, intx) \
a61af66fc99e Initial load
duke
parents:
diff changeset
362 \
a61af66fc99e Initial load
duke
parents:
diff changeset
363 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
364 /* MethodOop-related structures */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
365 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
366 \
a61af66fc99e Initial load
duke
parents:
diff changeset
367 nonstatic_field(CheckedExceptionElement, class_cp_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
368 nonstatic_field(LocalVariableTableElement, start_bci, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
369 nonstatic_field(LocalVariableTableElement, length, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
370 nonstatic_field(LocalVariableTableElement, name_cp_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
371 nonstatic_field(LocalVariableTableElement, descriptor_cp_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
372 nonstatic_field(LocalVariableTableElement, signature_cp_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
373 nonstatic_field(LocalVariableTableElement, slot, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
374 nonstatic_field(BreakpointInfo, _orig_bytecode, Bytecodes::Code) \
a61af66fc99e Initial load
duke
parents:
diff changeset
375 nonstatic_field(BreakpointInfo, _bci, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
376 nonstatic_field(BreakpointInfo, _name_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
377 nonstatic_field(BreakpointInfo, _signature_index, u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
378 nonstatic_field(BreakpointInfo, _next, BreakpointInfo*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
379 /***********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
380 /* JNI IDs */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
381 /***********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
382 \
a61af66fc99e Initial load
duke
parents:
diff changeset
383 nonstatic_field(JNIid, _holder, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
384 nonstatic_field(JNIid, _next, JNIid*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
385 nonstatic_field(JNIid, _offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
386 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
387 /* Universe */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
388 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
389 \
a61af66fc99e Initial load
duke
parents:
diff changeset
390 static_field(Universe, _boolArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
391 static_field(Universe, _byteArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
392 static_field(Universe, _charArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
393 static_field(Universe, _intArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
394 static_field(Universe, _shortArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
395 static_field(Universe, _longArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
396 static_field(Universe, _singleArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
397 static_field(Universe, _doubleArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
398 static_field(Universe, _methodKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
399 static_field(Universe, _constMethodKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
400 static_field(Universe, _methodDataKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
401 static_field(Universe, _klassKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
402 static_field(Universe, _arrayKlassKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
403 static_field(Universe, _objArrayKlassKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
404 static_field(Universe, _typeArrayKlassKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
405 static_field(Universe, _instanceKlassKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
406 static_field(Universe, _constantPoolKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
407 static_field(Universe, _constantPoolCacheKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
408 static_field(Universe, _compiledICHolderKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
409 static_field(Universe, _systemObjArrayKlassObj, klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
410 static_field(Universe, _mirrors[0], oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
411 static_field(Universe, _main_thread_group, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
412 static_field(Universe, _system_thread_group, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
413 static_field(Universe, _the_empty_byte_array, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
414 static_field(Universe, _the_empty_short_array, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
415 static_field(Universe, _the_empty_int_array, typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
416 static_field(Universe, _the_empty_system_obj_array, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
417 static_field(Universe, _the_empty_class_klass_array, objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
418 static_field(Universe, _out_of_memory_error_java_heap, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
419 static_field(Universe, _out_of_memory_error_perm_gen, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
420 static_field(Universe, _out_of_memory_error_array_size, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
421 static_field(Universe, _out_of_memory_error_gc_overhead_limit, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
422 static_field(Universe, _null_ptr_exception_instance, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
423 static_field(Universe, _arithmetic_exception_instance, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
424 static_field(Universe, _vm_exception, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
425 static_field(Universe, _collectedHeap, CollectedHeap*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
426 static_field(Universe, _base_vtable_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
427 static_field(Universe, _bootstrapping, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
428 static_field(Universe, _fully_initialized, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
429 static_field(Universe, _verify_count, int) \
642
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 365
diff changeset
430 static_field(Universe, _narrow_oop._base, address) \
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 365
diff changeset
431 static_field(Universe, _narrow_oop._shift, int) \
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 365
diff changeset
432 static_field(Universe, _narrow_oop._use_implicit_null_checks, bool) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
433 \
a61af66fc99e Initial load
duke
parents:
diff changeset
434 /**********************************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
435 /* Generation and Space hierarchies */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
436 /**********************************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
437 \
a61af66fc99e Initial load
duke
parents:
diff changeset
438 unchecked_nonstatic_field(ageTable, sizes, sizeof(ageTable::sizes)) \
a61af66fc99e Initial load
duke
parents:
diff changeset
439 \
a61af66fc99e Initial load
duke
parents:
diff changeset
440 nonstatic_field(BarrierSet, _max_covered_regions, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
441 nonstatic_field(BlockOffsetTable, _bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
442 nonstatic_field(BlockOffsetTable, _end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
443 \
a61af66fc99e Initial load
duke
parents:
diff changeset
444 nonstatic_field(BlockOffsetSharedArray, _reserved, MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
445 nonstatic_field(BlockOffsetSharedArray, _end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
446 nonstatic_field(BlockOffsetSharedArray, _vs, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
447 nonstatic_field(BlockOffsetSharedArray, _offset_array, u_char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
448 \
a61af66fc99e Initial load
duke
parents:
diff changeset
449 nonstatic_field(BlockOffsetArray, _array, BlockOffsetSharedArray*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
450 nonstatic_field(BlockOffsetArray, _sp, Space*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
451 nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_threshold, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
452 nonstatic_field(BlockOffsetArrayContigSpace, _next_offset_index, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
453 \
a61af66fc99e Initial load
duke
parents:
diff changeset
454 nonstatic_field(BlockOffsetArrayNonContigSpace, _unallocated_block, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
455 \
a61af66fc99e Initial load
duke
parents:
diff changeset
456 nonstatic_field(CardGeneration, _rs, GenRemSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
457 nonstatic_field(CardGeneration, _bts, BlockOffsetSharedArray*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
458 \
a61af66fc99e Initial load
duke
parents:
diff changeset
459 nonstatic_field(CardTableModRefBS, _whole_heap, const MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
460 nonstatic_field(CardTableModRefBS, _guard_index, const size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
461 nonstatic_field(CardTableModRefBS, _last_valid_index, const size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
462 nonstatic_field(CardTableModRefBS, _page_size, const size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
463 nonstatic_field(CardTableModRefBS, _byte_map_size, const size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
464 nonstatic_field(CardTableModRefBS, _byte_map, jbyte*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
465 nonstatic_field(CardTableModRefBS, _cur_covered_regions, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
466 nonstatic_field(CardTableModRefBS, _covered, MemRegion*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
467 nonstatic_field(CardTableModRefBS, _committed, MemRegion*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
468 nonstatic_field(CardTableModRefBS, _guard_region, MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
469 nonstatic_field(CardTableModRefBS, byte_map_base, jbyte*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
470 \
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
471 nonstatic_field(CardTableRS, _ct_bs, CardTableModRefBSForCTRS*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
472 \
a61af66fc99e Initial load
duke
parents:
diff changeset
473 nonstatic_field(CollectedHeap, _reserved, MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
474 nonstatic_field(SharedHeap, _perm_gen, PermGen*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
475 nonstatic_field(CollectedHeap, _barrier_set, BarrierSet*) \
1166
7b0e9cba0307 6896647: card marks can be deferred too long
ysr
parents: 1144
diff changeset
476 nonstatic_field(CollectedHeap, _defer_initial_card_mark, bool) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
477 nonstatic_field(CollectedHeap, _is_gc_active, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
478 nonstatic_field(CompactibleSpace, _compaction_top, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
479 nonstatic_field(CompactibleSpace, _first_dead, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
480 nonstatic_field(CompactibleSpace, _end_of_live, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
481 \
a61af66fc99e Initial load
duke
parents:
diff changeset
482 nonstatic_field(CompactingPermGen, _gen, OneContigSpaceCardGeneration*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
483 \
a61af66fc99e Initial load
duke
parents:
diff changeset
484 nonstatic_field(ContiguousSpace, _top, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
485 nonstatic_field(ContiguousSpace, _concurrent_iteration_safe_limit, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
486 nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
487 \
a61af66fc99e Initial load
duke
parents:
diff changeset
488 nonstatic_field(DefNewGeneration, _next_gen, Generation*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
489 nonstatic_field(DefNewGeneration, _tenuring_threshold, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
490 nonstatic_field(DefNewGeneration, _age_table, ageTable) \
a61af66fc99e Initial load
duke
parents:
diff changeset
491 nonstatic_field(DefNewGeneration, _eden_space, EdenSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
492 nonstatic_field(DefNewGeneration, _from_space, ContiguousSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
493 nonstatic_field(DefNewGeneration, _to_space, ContiguousSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
494 \
a61af66fc99e Initial load
duke
parents:
diff changeset
495 nonstatic_field(EdenSpace, _gen, DefNewGeneration*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
496 \
a61af66fc99e Initial load
duke
parents:
diff changeset
497 nonstatic_field(Generation, _reserved, MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
498 nonstatic_field(Generation, _virtual_space, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
499 nonstatic_field(Generation, _level, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
500 nonstatic_field(Generation, _stat_record, Generation::StatRecord) \
a61af66fc99e Initial load
duke
parents:
diff changeset
501 \
a61af66fc99e Initial load
duke
parents:
diff changeset
502 nonstatic_field(Generation::StatRecord, invocations, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
503 nonstatic_field(Generation::StatRecord, accumulated_time, elapsedTimer) \
a61af66fc99e Initial load
duke
parents:
diff changeset
504 \
a61af66fc99e Initial load
duke
parents:
diff changeset
505 nonstatic_field(GenerationSpec, _name, Generation::Name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
506 nonstatic_field(GenerationSpec, _init_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
507 nonstatic_field(GenerationSpec, _max_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
508 \
a61af66fc99e Initial load
duke
parents:
diff changeset
509 static_field(GenCollectedHeap, _gch, GenCollectedHeap*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
510 nonstatic_field(GenCollectedHeap, _n_gens, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
511 unchecked_nonstatic_field(GenCollectedHeap, _gens, sizeof(GenCollectedHeap::_gens)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
512 nonstatic_field(GenCollectedHeap, _gen_specs, GenerationSpec**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
513 \
a61af66fc99e Initial load
duke
parents:
diff changeset
514 nonstatic_field(HeapWord, i, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
515 \
a61af66fc99e Initial load
duke
parents:
diff changeset
516 nonstatic_field(MemRegion, _start, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
517 nonstatic_field(MemRegion, _word_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
518 \
a61af66fc99e Initial load
duke
parents:
diff changeset
519 nonstatic_field(OffsetTableContigSpace, _offsets, BlockOffsetArray) \
a61af66fc99e Initial load
duke
parents:
diff changeset
520 \
a61af66fc99e Initial load
duke
parents:
diff changeset
521 nonstatic_field(OneContigSpaceCardGeneration, _min_heap_delta_bytes, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
522 nonstatic_field(OneContigSpaceCardGeneration, _the_space, ContiguousSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
523 nonstatic_field(OneContigSpaceCardGeneration, _last_gc, WaterMark) \
a61af66fc99e Initial load
duke
parents:
diff changeset
524 \
a61af66fc99e Initial load
duke
parents:
diff changeset
525 nonstatic_field(CompactingPermGenGen, _ro_vs, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
526 nonstatic_field(CompactingPermGenGen, _rw_vs, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
527 nonstatic_field(CompactingPermGenGen, _md_vs, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
528 nonstatic_field(CompactingPermGenGen, _mc_vs, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
529 nonstatic_field(CompactingPermGenGen, _ro_space, OffsetTableContigSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
530 nonstatic_field(CompactingPermGenGen, _rw_space, OffsetTableContigSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
531 static_field(CompactingPermGenGen, unshared_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
532 static_field(CompactingPermGenGen, unshared_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
533 static_field(CompactingPermGenGen, shared_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
534 static_field(CompactingPermGenGen, readonly_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
535 static_field(CompactingPermGenGen, readonly_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
536 static_field(CompactingPermGenGen, readwrite_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
537 static_field(CompactingPermGenGen, readwrite_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
538 static_field(CompactingPermGenGen, miscdata_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
539 static_field(CompactingPermGenGen, miscdata_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
540 static_field(CompactingPermGenGen, misccode_bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
541 static_field(CompactingPermGenGen, misccode_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
542 static_field(CompactingPermGenGen, shared_end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
543 \
a61af66fc99e Initial load
duke
parents:
diff changeset
544 nonstatic_field(PermGen, _capacity_expansion_limit, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
545 \
a61af66fc99e Initial load
duke
parents:
diff changeset
546 nonstatic_field(PermanentGenerationSpec, _name, PermGen::Name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
547 nonstatic_field(PermanentGenerationSpec, _init_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
548 nonstatic_field(PermanentGenerationSpec, _max_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
549 \
a61af66fc99e Initial load
duke
parents:
diff changeset
550 nonstatic_field(Space, _bottom, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
551 nonstatic_field(Space, _end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
552 \
a61af66fc99e Initial load
duke
parents:
diff changeset
553 nonstatic_field(TenuredGeneration, _shrink_factor, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
554 nonstatic_field(TenuredGeneration, _capacity_at_prologue, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
555 nonstatic_field(ThreadLocalAllocBuffer, _start, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
556 nonstatic_field(ThreadLocalAllocBuffer, _top, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
557 nonstatic_field(ThreadLocalAllocBuffer, _end, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
558 nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
559 nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
560 static_field(ThreadLocalAllocBuffer, _target_refills, unsigned) \
a61af66fc99e Initial load
duke
parents:
diff changeset
561 nonstatic_field(VirtualSpace, _low_boundary, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
562 nonstatic_field(VirtualSpace, _high_boundary, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
563 nonstatic_field(VirtualSpace, _low, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
564 nonstatic_field(VirtualSpace, _high, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
565 nonstatic_field(VirtualSpace, _lower_high, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
566 nonstatic_field(VirtualSpace, _middle_high, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
567 nonstatic_field(VirtualSpace, _upper_high, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
568 nonstatic_field(WaterMark, _point, HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
569 nonstatic_field(WaterMark, _space, Space*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
570 \
a61af66fc99e Initial load
duke
parents:
diff changeset
571 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
572 /* PerfMemory - jvmstat */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
573 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
574 \
a61af66fc99e Initial load
duke
parents:
diff changeset
575 nonstatic_field(PerfDataPrologue, magic, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
576 nonstatic_field(PerfDataPrologue, byte_order, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
577 nonstatic_field(PerfDataPrologue, major_version, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
578 nonstatic_field(PerfDataPrologue, minor_version, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
579 nonstatic_field(PerfDataPrologue, accessible, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
580 nonstatic_field(PerfDataPrologue, used, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
581 nonstatic_field(PerfDataPrologue, overflow, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
582 nonstatic_field(PerfDataPrologue, mod_time_stamp, jlong) \
a61af66fc99e Initial load
duke
parents:
diff changeset
583 nonstatic_field(PerfDataPrologue, entry_offset, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
584 nonstatic_field(PerfDataPrologue, num_entries, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
585 \
a61af66fc99e Initial load
duke
parents:
diff changeset
586 nonstatic_field(PerfDataEntry, entry_length, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
587 nonstatic_field(PerfDataEntry, name_offset, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
588 nonstatic_field(PerfDataEntry, vector_length, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
589 nonstatic_field(PerfDataEntry, data_type, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
590 nonstatic_field(PerfDataEntry, flags, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
591 nonstatic_field(PerfDataEntry, data_units, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
592 nonstatic_field(PerfDataEntry, data_variability, jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
593 nonstatic_field(PerfDataEntry, data_offset, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
594 \
a61af66fc99e Initial load
duke
parents:
diff changeset
595 static_field(PerfMemory, _start, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
596 static_field(PerfMemory, _end, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
597 static_field(PerfMemory, _top, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
598 static_field(PerfMemory, _capacity, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
599 static_field(PerfMemory, _prologue, PerfDataPrologue*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
600 static_field(PerfMemory, _initialized, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
601 \
a61af66fc99e Initial load
duke
parents:
diff changeset
602 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
603 /* SymbolTable */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
604 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
605 \
a61af66fc99e Initial load
duke
parents:
diff changeset
606 static_field(SymbolTable, _the_table, SymbolTable*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
607 \
a61af66fc99e Initial load
duke
parents:
diff changeset
608 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
609 /* StringTable */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
610 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
611 \
a61af66fc99e Initial load
duke
parents:
diff changeset
612 static_field(StringTable, _the_table, StringTable*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
613 \
a61af66fc99e Initial load
duke
parents:
diff changeset
614 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
615 /* SystemDictionary */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
616 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
617 \
a61af66fc99e Initial load
duke
parents:
diff changeset
618 static_field(SystemDictionary, _dictionary, Dictionary*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
619 static_field(SystemDictionary, _placeholders, PlaceholderTable*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
620 static_field(SystemDictionary, _shared_dictionary, Dictionary*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
621 static_field(SystemDictionary, _system_loader_lock_obj, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
622 static_field(SystemDictionary, _loader_constraints, LoaderConstraintTable*) \
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
623 static_field(SystemDictionary, WK_KLASS(Object_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
624 static_field(SystemDictionary, WK_KLASS(String_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
625 static_field(SystemDictionary, WK_KLASS(Class_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
626 static_field(SystemDictionary, WK_KLASS(Cloneable_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
627 static_field(SystemDictionary, WK_KLASS(ClassLoader_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
628 static_field(SystemDictionary, WK_KLASS(Serializable_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
629 static_field(SystemDictionary, WK_KLASS(System_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
630 static_field(SystemDictionary, WK_KLASS(Throwable_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
631 static_field(SystemDictionary, WK_KLASS(ThreadDeath_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
632 static_field(SystemDictionary, WK_KLASS(Error_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
633 static_field(SystemDictionary, WK_KLASS(Exception_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
634 static_field(SystemDictionary, WK_KLASS(RuntimeException_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
635 static_field(SystemDictionary, WK_KLASS(ClassNotFoundException_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
636 static_field(SystemDictionary, WK_KLASS(NoClassDefFoundError_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
637 static_field(SystemDictionary, WK_KLASS(LinkageError_klass), klassOop) \
147
83c868b757c0 6701024: SAJDI functionality is broken
jrose
parents: 132
diff changeset
638 static_field(SystemDictionary, WK_KLASS(ClassCastException_klass), klassOop) \
83c868b757c0 6701024: SAJDI functionality is broken
jrose
parents: 132
diff changeset
639 static_field(SystemDictionary, WK_KLASS(ArrayStoreException_klass), klassOop) \
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
640 static_field(SystemDictionary, WK_KLASS(VirtualMachineError_klass), klassOop) \
147
83c868b757c0 6701024: SAJDI functionality is broken
jrose
parents: 132
diff changeset
641 static_field(SystemDictionary, WK_KLASS(OutOfMemoryError_klass), klassOop) \
83c868b757c0 6701024: SAJDI functionality is broken
jrose
parents: 132
diff changeset
642 static_field(SystemDictionary, WK_KLASS(StackOverflowError_klass), klassOop) \
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
643 static_field(SystemDictionary, WK_KLASS(ProtectionDomain_klass), klassOop) \
147
83c868b757c0 6701024: SAJDI functionality is broken
jrose
parents: 132
diff changeset
644 static_field(SystemDictionary, WK_KLASS(AccessControlContext_klass), klassOop) \
1142
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
645 static_field(SystemDictionary, WK_KLASS(Reference_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
646 static_field(SystemDictionary, WK_KLASS(SoftReference_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
647 static_field(SystemDictionary, WK_KLASS(WeakReference_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
648 static_field(SystemDictionary, WK_KLASS(FinalReference_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
649 static_field(SystemDictionary, WK_KLASS(PhantomReference_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
650 static_field(SystemDictionary, WK_KLASS(Finalizer_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
651 static_field(SystemDictionary, WK_KLASS(Thread_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
652 static_field(SystemDictionary, WK_KLASS(ThreadGroup_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
653 static_field(SystemDictionary, WK_KLASS(Properties_klass), klassOop) \
4ce7240d622c 6914300: ciEnv should export all well known classes
never
parents: 1040
diff changeset
654 static_field(SystemDictionary, WK_KLASS(StringBuffer_klass), klassOop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
655 static_field(SystemDictionary, _box_klasses[0], klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
656 static_field(SystemDictionary, _java_system_loader, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
657 \
a61af66fc99e Initial load
duke
parents:
diff changeset
658 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
659 /* HashtableBucket */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
660 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
661 \
a61af66fc99e Initial load
duke
parents:
diff changeset
662 nonstatic_field(HashtableBucket, _entry, BasicHashtableEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
663 \
a61af66fc99e Initial load
duke
parents:
diff changeset
664 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
665 /* HashtableEntry */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
666 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
667 \
a61af66fc99e Initial load
duke
parents:
diff changeset
668 nonstatic_field(BasicHashtableEntry, _next, BasicHashtableEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
669 nonstatic_field(BasicHashtableEntry, _hash, unsigned int) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
670 nonstatic_field(HashtableEntry<intptr_t>, _literal, intptr_t) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
671 \
a61af66fc99e Initial load
duke
parents:
diff changeset
672 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
673 /* Hashtable */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
674 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
675 \
a61af66fc99e Initial load
duke
parents:
diff changeset
676 nonstatic_field(BasicHashtable, _table_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
677 nonstatic_field(BasicHashtable, _buckets, HashtableBucket*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
678 nonstatic_field(BasicHashtable, _free_list, BasicHashtableEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
679 nonstatic_field(BasicHashtable, _first_free_entry, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
680 nonstatic_field(BasicHashtable, _end_block, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
681 nonstatic_field(BasicHashtable, _entry_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
682 \
a61af66fc99e Initial load
duke
parents:
diff changeset
683 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
684 /* DictionaryEntry */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
685 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
686 \
a61af66fc99e Initial load
duke
parents:
diff changeset
687 nonstatic_field(DictionaryEntry, _loader, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
688 nonstatic_field(DictionaryEntry, _pd_set, ProtectionDomainEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
689 \
a61af66fc99e Initial load
duke
parents:
diff changeset
690 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
691 \
a61af66fc99e Initial load
duke
parents:
diff changeset
692 nonstatic_field(PlaceholderEntry, _loader, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
693 \
a61af66fc99e Initial load
duke
parents:
diff changeset
694 /**************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
695 /* ProctectionDomainEntry */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
696 /**************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
697 \
a61af66fc99e Initial load
duke
parents:
diff changeset
698 nonstatic_field(ProtectionDomainEntry, _next, ProtectionDomainEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
699 nonstatic_field(ProtectionDomainEntry, _protection_domain, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
700 \
a61af66fc99e Initial load
duke
parents:
diff changeset
701 /*************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
702 /* LoaderConstraintEntry */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
703 /*************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
704 \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
705 nonstatic_field(LoaderConstraintEntry, _name, Symbol*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
706 nonstatic_field(LoaderConstraintEntry, _num_loaders, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
707 nonstatic_field(LoaderConstraintEntry, _max_loaders, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
708 nonstatic_field(LoaderConstraintEntry, _loaders, oop*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
709 \
a61af66fc99e Initial load
duke
parents:
diff changeset
710 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
711 /* CodeCache (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
712 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
713 \
a61af66fc99e Initial load
duke
parents:
diff changeset
714 static_field(CodeCache, _heap, CodeHeap*) \
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 931
diff changeset
715 static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
716 \
a61af66fc99e Initial load
duke
parents:
diff changeset
717 /*******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
718 /* CodeHeap (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
719 /*******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
720 \
a61af66fc99e Initial load
duke
parents:
diff changeset
721 nonstatic_field(CodeHeap, _memory, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
722 nonstatic_field(CodeHeap, _segmap, VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
723 nonstatic_field(CodeHeap, _log2_segment_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
724 nonstatic_field(HeapBlock, _header, HeapBlock::Header) \
a61af66fc99e Initial load
duke
parents:
diff changeset
725 nonstatic_field(HeapBlock::Header, _length, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
726 nonstatic_field(HeapBlock::Header, _used, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
727 \
a61af66fc99e Initial load
duke
parents:
diff changeset
728 /**********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
729 /* Interpreter (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
730 /**********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
731 \
a61af66fc99e Initial load
duke
parents:
diff changeset
732 static_field(AbstractInterpreter, _code, StubQueue*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
733 \
a61af66fc99e Initial load
duke
parents:
diff changeset
734 /****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
735 /* Stubs (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
736 /****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
737 \
a61af66fc99e Initial load
duke
parents:
diff changeset
738 nonstatic_field(StubQueue, _stub_buffer, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
739 nonstatic_field(StubQueue, _buffer_limit, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
740 nonstatic_field(StubQueue, _queue_begin, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
741 nonstatic_field(StubQueue, _queue_end, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
742 nonstatic_field(StubQueue, _number_of_stubs, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
743 nonstatic_field(InterpreterCodelet, _size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
744 nonstatic_field(InterpreterCodelet, _description, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
745 nonstatic_field(InterpreterCodelet, _bytecode, Bytecodes::Code) \
a61af66fc99e Initial load
duke
parents:
diff changeset
746 \
a61af66fc99e Initial load
duke
parents:
diff changeset
747 /***********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
748 /* StubRoutines (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
749 /***********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
750 \
a61af66fc99e Initial load
duke
parents:
diff changeset
751 static_field(StubRoutines, _call_stub_return_address, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
752 \
a61af66fc99e Initial load
duke
parents:
diff changeset
753 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
754 /* PcDesc and other compiled code info */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
755 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
756 \
a61af66fc99e Initial load
duke
parents:
diff changeset
757 nonstatic_field(PcDesc, _pc_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
758 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
759 nonstatic_field(PcDesc, _obj_decode_offset, int) \
931
72088be4b386 6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents: 844
diff changeset
760 nonstatic_field(PcDesc, _flags, PcDesc::PcDescFlags) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
761 \
a61af66fc99e Initial load
duke
parents:
diff changeset
762 /***************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
763 /* CodeBlobs (NOTE: incomplete, but only a little) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
764 /***************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
765 \
a61af66fc99e Initial load
duke
parents:
diff changeset
766 nonstatic_field(CodeBlob, _name, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
767 nonstatic_field(CodeBlob, _size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
768 nonstatic_field(CodeBlob, _header_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
769 nonstatic_field(CodeBlob, _relocation_size, int) \
1748
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1644
diff changeset
770 nonstatic_field(CodeBlob, _content_offset, int) \
3e8fbc61cee8 6978355: renaming for 6961697
twisti
parents: 1644
diff changeset
771 nonstatic_field(CodeBlob, _code_offset, int) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
772 nonstatic_field(CodeBlob, _frame_complete_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
773 nonstatic_field(CodeBlob, _data_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
774 nonstatic_field(CodeBlob, _frame_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
775 nonstatic_field(CodeBlob, _oop_maps, OopMapSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
776 \
a61af66fc99e Initial load
duke
parents:
diff changeset
777 /**************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
778 /* NMethods (NOTE: incomplete, but only a little) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
779 /**************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
780 \
a61af66fc99e Initial load
duke
parents:
diff changeset
781 nonstatic_field(nmethod, _method, methodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
782 nonstatic_field(nmethod, _entry_bci, int) \
989
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 931
diff changeset
783 nonstatic_field(nmethod, _osr_link, nmethod*) \
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 931
diff changeset
784 nonstatic_field(nmethod, _scavenge_root_link, nmethod*) \
148e5441d916 6863023: need non-perm oops in code cache for JSR 292
jrose
parents: 931
diff changeset
785 nonstatic_field(nmethod, _scavenge_root_state, jbyte) \
3388
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
786 nonstatic_field(nmethod, _state, unsigned char) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
787 nonstatic_field(nmethod, _exception_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
788 nonstatic_field(nmethod, _deoptimize_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
789 nonstatic_field(nmethod, _orig_pc_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
790 nonstatic_field(nmethod, _stub_offset, int) \
1563
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 1166
diff changeset
791 nonstatic_field(nmethod, _consts_offset, int) \
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents: 1166
diff changeset
792 nonstatic_field(nmethod, _oops_offset, int) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
793 nonstatic_field(nmethod, _scopes_data_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
794 nonstatic_field(nmethod, _scopes_pcs_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
795 nonstatic_field(nmethod, _dependencies_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
796 nonstatic_field(nmethod, _handler_table_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
797 nonstatic_field(nmethod, _nul_chk_table_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
798 nonstatic_field(nmethod, _nmethod_end_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
799 nonstatic_field(nmethod, _entry_point, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
800 nonstatic_field(nmethod, _verified_entry_point, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
801 nonstatic_field(nmethod, _osr_entry_point, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
802 nonstatic_field(nmethod, _lock_count, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
803 nonstatic_field(nmethod, _stack_traversal_mark, long) \
3388
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
804 nonstatic_field(nmethod, _compile_id, int) \
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
805 nonstatic_field(nmethod, _marked_for_deoptimization, bool) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
806 \
a61af66fc99e Initial load
duke
parents:
diff changeset
807 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
808 /* JavaCalls (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
809 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
810 \
a61af66fc99e Initial load
duke
parents:
diff changeset
811 nonstatic_field(JavaCallWrapper, _anchor, JavaFrameAnchor) \
a61af66fc99e Initial load
duke
parents:
diff changeset
812 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
813 /* JavaFrameAnchor (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
814 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
815 volatile_nonstatic_field(JavaFrameAnchor, _last_Java_sp, intptr_t*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
816 volatile_nonstatic_field(JavaFrameAnchor, _last_Java_pc, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
817 \
a61af66fc99e Initial load
duke
parents:
diff changeset
818 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
819 /* Threads (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
820 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
821 \
a61af66fc99e Initial load
duke
parents:
diff changeset
822 static_field(Threads, _thread_list, JavaThread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
823 static_field(Threads, _number_of_threads, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
824 static_field(Threads, _number_of_non_daemon_threads, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
825 static_field(Threads, _return_code, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
826 \
a61af66fc99e Initial load
duke
parents:
diff changeset
827 volatile_nonstatic_field(Thread, _suspend_flags, uint32_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
828 nonstatic_field(Thread, _active_handles, JNIHandleBlock*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
829 nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \
a61af66fc99e Initial load
duke
parents:
diff changeset
830 nonstatic_field(Thread, _current_pending_monitor, ObjectMonitor*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
831 nonstatic_field(Thread, _current_pending_monitor_is_from_java, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
832 nonstatic_field(Thread, _current_waiting_monitor, ObjectMonitor*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
833 nonstatic_field(NamedThread, _name, char*) \
1119
547f81740344 6361589: Print out stack trace for target thread of GC crash
minqi
parents: 1040
diff changeset
834 nonstatic_field(NamedThread, _processed_thread, JavaThread*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
835 nonstatic_field(JavaThread, _next, JavaThread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
836 nonstatic_field(JavaThread, _threadObj, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
837 nonstatic_field(JavaThread, _anchor, JavaFrameAnchor) \
a61af66fc99e Initial load
duke
parents:
diff changeset
838 volatile_nonstatic_field(JavaThread, _thread_state, JavaThreadState) \
a61af66fc99e Initial load
duke
parents:
diff changeset
839 nonstatic_field(JavaThread, _osthread, OSThread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
840 nonstatic_field(JavaThread, _stack_base, address) \
a61af66fc99e Initial load
duke
parents:
diff changeset
841 nonstatic_field(JavaThread, _stack_size, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
842 \
a61af66fc99e Initial load
duke
parents:
diff changeset
843 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
844 /* OSThread */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
845 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
846 \
2386
083f13976b51 6535709: interrupt of wait()ing thread isn't triggerring InterruptedException - test intwait3
dholmes
parents: 2260
diff changeset
847 volatile_nonstatic_field(OSThread, _interrupted, jint) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
848 \
a61af66fc99e Initial load
duke
parents:
diff changeset
849 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
850 /* OopMap and OopMapSet */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
851 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
852 \
a61af66fc99e Initial load
duke
parents:
diff changeset
853 nonstatic_field(OopMap, _pc_offset, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
854 nonstatic_field(OopMap, _omv_count, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
855 nonstatic_field(OopMap, _omv_data_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
856 nonstatic_field(OopMap, _omv_data, unsigned char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
857 nonstatic_field(OopMap, _write_stream, CompressedWriteStream*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
858 nonstatic_field(OopMapSet, _om_count, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
859 nonstatic_field(OopMapSet, _om_size, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
860 nonstatic_field(OopMapSet, _om_data, OopMap**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
861 \
a61af66fc99e Initial load
duke
parents:
diff changeset
862 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
863 /* JNIHandles and JNIHandleBlock */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
864 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
865 static_field(JNIHandles, _global_handles, JNIHandleBlock*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
866 static_field(JNIHandles, _weak_global_handles, JNIHandleBlock*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
867 static_field(JNIHandles, _deleted_handle, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
868 \
a61af66fc99e Initial load
duke
parents:
diff changeset
869 unchecked_nonstatic_field(JNIHandleBlock, _handles, JNIHandleBlock::block_size_in_oops * sizeof(Oop)) /* Note: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
870 nonstatic_field(JNIHandleBlock, _top, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
871 nonstatic_field(JNIHandleBlock, _next, JNIHandleBlock*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
872 \
a61af66fc99e Initial load
duke
parents:
diff changeset
873 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
874 /* CompressedStream */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
875 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
876 \
a61af66fc99e Initial load
duke
parents:
diff changeset
877 nonstatic_field(CompressedStream, _buffer, u_char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
878 nonstatic_field(CompressedStream, _position, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
879 \
a61af66fc99e Initial load
duke
parents:
diff changeset
880 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
881 /* VMRegImpl (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
882 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
883 \
a61af66fc99e Initial load
duke
parents:
diff changeset
884 static_field(VMRegImpl, regName[0], const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
885 static_field(VMRegImpl, stack0, VMReg) \
a61af66fc99e Initial load
duke
parents:
diff changeset
886 \
a61af66fc99e Initial load
duke
parents:
diff changeset
887 /*******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
888 /* Runtime1 (NOTE: incomplete) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
889 /*******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
890 \
a61af66fc99e Initial load
duke
parents:
diff changeset
891 unchecked_c1_static_field(Runtime1, _blobs, sizeof(Runtime1::_blobs)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
892 \
a61af66fc99e Initial load
duke
parents:
diff changeset
893 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
894 /* Monitors */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
895 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
896 \
a61af66fc99e Initial load
duke
parents:
diff changeset
897 volatile_nonstatic_field(ObjectMonitor, _header, markOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
898 unchecked_nonstatic_field(ObjectMonitor, _object, sizeof(void *)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
899 unchecked_nonstatic_field(ObjectMonitor, _owner, sizeof(void *)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
900 volatile_nonstatic_field(ObjectMonitor, _count, intptr_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
901 volatile_nonstatic_field(ObjectMonitor, _waiters, intptr_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
902 volatile_nonstatic_field(ObjectMonitor, _recursions, intptr_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
903 nonstatic_field(ObjectMonitor, FreeNext, ObjectMonitor*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
904 volatile_nonstatic_field(BasicLock, _displaced_header, markOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
905 nonstatic_field(BasicObjectLock, _lock, BasicLock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
906 nonstatic_field(BasicObjectLock, _obj, oop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
907 static_field(ObjectSynchronizer, gBlockList, ObjectMonitor*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
908 \
a61af66fc99e Initial load
duke
parents:
diff changeset
909 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
910 /* Matcher (C2 only) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
911 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
912 \
a61af66fc99e Initial load
duke
parents:
diff changeset
913 unchecked_c2_static_field(Matcher, _regEncode, sizeof(Matcher::_regEncode)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
914 \
a61af66fc99e Initial load
duke
parents:
diff changeset
915 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
916 /* -XX flags */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
917 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
918 \
a61af66fc99e Initial load
duke
parents:
diff changeset
919 nonstatic_field(Flag, type, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
920 nonstatic_field(Flag, name, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
921 unchecked_nonstatic_field(Flag, addr, sizeof(void*)) /* NOTE: no type */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
922 nonstatic_field(Flag, kind, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
923 static_field(Flag, flags, Flag*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
924 static_field(Flag, numFlags, size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
925 \
a61af66fc99e Initial load
duke
parents:
diff changeset
926 /*************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
927 /* JDK / VM version info */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
928 /*************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
929 \
a61af66fc99e Initial load
duke
parents:
diff changeset
930 static_field(Abstract_VM_Version, _s_vm_release, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
931 static_field(Abstract_VM_Version, _s_internal_vm_info_string, const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
932 static_field(Abstract_VM_Version, _vm_major_version, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
933 static_field(Abstract_VM_Version, _vm_minor_version, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
934 static_field(Abstract_VM_Version, _vm_build_number, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
935 \
242
d95b224e9f17 6721093: -XX:AppendRatio=N not supported
kamg
parents: 196
diff changeset
936 static_field(JDK_Version, _current, JDK_Version) \
d95b224e9f17 6721093: -XX:AppendRatio=N not supported
kamg
parents: 196
diff changeset
937 nonstatic_field(JDK_Version, _partially_initialized, bool) \
d95b224e9f17 6721093: -XX:AppendRatio=N not supported
kamg
parents: 196
diff changeset
938 nonstatic_field(JDK_Version, _major, unsigned char) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
939 \
a61af66fc99e Initial load
duke
parents:
diff changeset
940 \
a61af66fc99e Initial load
duke
parents:
diff changeset
941 \
a61af66fc99e Initial load
duke
parents:
diff changeset
942 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
943 /* Arguments */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
944 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
945 \
a61af66fc99e Initial load
duke
parents:
diff changeset
946 static_field(Arguments, _jvm_flags_array, char**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
947 static_field(Arguments, _num_jvm_flags, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
948 static_field(Arguments, _jvm_args_array, char**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
949 static_field(Arguments, _num_jvm_args, int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
950 static_field(Arguments, _java_command, char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
951 \
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
952 /*********************************/ \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
953 /* java_lang_Class fields */ \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
954 /*********************************/ \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
955 \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
956 static_field(java_lang_Class, klass_offset, int) \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
957 static_field(java_lang_Class, resolved_constructor_offset, int) \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
958 static_field(java_lang_Class, array_klass_offset, int) \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
959 static_field(java_lang_Class, oop_size_offset, int) \
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
960 static_field(java_lang_Class, static_oop_field_count_offset, int) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
961 \
a61af66fc99e Initial load
duke
parents:
diff changeset
962 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
963 /* Miscellaneous fields */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
964 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
965 \
a61af66fc99e Initial load
duke
parents:
diff changeset
966 nonstatic_field(AccessFlags, _flags, jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
967 nonstatic_field(elapsedTimer, _counter, jlong) \
a61af66fc99e Initial load
duke
parents:
diff changeset
968 nonstatic_field(elapsedTimer, _active, bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
969 nonstatic_field(InvocationCounter, _counter, unsigned int)
a61af66fc99e Initial load
duke
parents:
diff changeset
970
a61af66fc99e Initial load
duke
parents:
diff changeset
971 /* NOTE that we do not use the last_entry() macro here; it is used */
a61af66fc99e Initial load
duke
parents:
diff changeset
972 /* in vmStructs_<os>_<cpu>.hpp's VM_STRUCTS_OS_CPU macro (and must */
a61af66fc99e Initial load
duke
parents:
diff changeset
973 /* be present there) */
a61af66fc99e Initial load
duke
parents:
diff changeset
974
a61af66fc99e Initial load
duke
parents:
diff changeset
975 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
976 // VM_TYPES
a61af66fc99e Initial load
duke
parents:
diff changeset
977 //
a61af66fc99e Initial load
duke
parents:
diff changeset
978 // This list must enumerate at least all of the types in the above
a61af66fc99e Initial load
duke
parents:
diff changeset
979 // list. For the types in the above list, the entry below must have
a61af66fc99e Initial load
duke
parents:
diff changeset
980 // exactly the same spacing since string comparisons are done in the
a61af66fc99e Initial load
duke
parents:
diff changeset
981 // code which verifies the consistency of these tables (in the debug
a61af66fc99e Initial load
duke
parents:
diff changeset
982 // build).
a61af66fc99e Initial load
duke
parents:
diff changeset
983 //
a61af66fc99e Initial load
duke
parents:
diff changeset
984 // In addition to the above types, this list is required to enumerate
a61af66fc99e Initial load
duke
parents:
diff changeset
985 // the JNI's java types, which are used to indicate the size of Java
a61af66fc99e Initial load
duke
parents:
diff changeset
986 // fields in this VM to the SA. Further, oop types are currently
a61af66fc99e Initial load
duke
parents:
diff changeset
987 // distinguished by name (i.e., ends with "oop") over in the SA.
a61af66fc99e Initial load
duke
parents:
diff changeset
988 //
a61af66fc99e Initial load
duke
parents:
diff changeset
989 // The declare_toplevel_type macro should be used to declare types
a61af66fc99e Initial load
duke
parents:
diff changeset
990 // which do not have a superclass.
a61af66fc99e Initial load
duke
parents:
diff changeset
991 //
a61af66fc99e Initial load
duke
parents:
diff changeset
992 // The declare_integer_type and declare_unsigned_integer_type macros
a61af66fc99e Initial load
duke
parents:
diff changeset
993 // are required in order to properly identify C integer types over in
a61af66fc99e Initial load
duke
parents:
diff changeset
994 // the SA. They should be used for any type which is otherwise opaque
a61af66fc99e Initial load
duke
parents:
diff changeset
995 // and which it is necessary to coerce into an integer value. This
a61af66fc99e Initial load
duke
parents:
diff changeset
996 // includes, for example, the type uintptr_t. Note that while they
a61af66fc99e Initial load
duke
parents:
diff changeset
997 // will properly identify the type's size regardless of the platform,
a61af66fc99e Initial load
duke
parents:
diff changeset
998 // since it is does not seem possible to deduce or check signedness at
a61af66fc99e Initial load
duke
parents:
diff changeset
999 // compile time using the pointer comparison tricks, it is currently
a61af66fc99e Initial load
duke
parents:
diff changeset
1000 // required that the given types have the same signedness across all
a61af66fc99e Initial load
duke
parents:
diff changeset
1001 // platforms.
a61af66fc99e Initial load
duke
parents:
diff changeset
1002 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1003 // NOTE that there are platform-specific additions to this table in
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 // vmStructs_<os>_<cpu>.hpp.
a61af66fc99e Initial load
duke
parents:
diff changeset
1005
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 #define VM_TYPES(declare_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 declare_toplevel_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1008 declare_oop_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 declare_integer_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1010 declare_unsigned_integer_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 declare_c1_toplevel_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 declare_c2_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 declare_c2_toplevel_type, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1014 last_entry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 /*************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1017 /* Java primitive types -- required by the SA implementation */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 /* in order to determine the size of Java fields in this VM */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 /* (the implementation looks up these names specifically) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1020 /* NOTE: since we fetch these sizes from the remote VM, we */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 /* have a bootstrapping sequence during which it is not */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 /* valid to fetch Java values from the remote process, only */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1023 /* C integer values (of known size). NOTE also that we do */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1024 /* NOT include "Java unsigned" types like juint here; since */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1025 /* Java does not have unsigned primitive types, those can */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1026 /* not be mapped directly and are considered to be C integer */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 /* types in this system (see the "other types" section, */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1028 /* below.) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1029 /*************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1031 declare_toplevel_type(jboolean) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 declare_toplevel_type(jbyte) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 declare_toplevel_type(jchar) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1034 declare_toplevel_type(jdouble) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1035 declare_toplevel_type(jfloat) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1036 declare_toplevel_type(jint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 declare_toplevel_type(jlong) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1038 declare_toplevel_type(jshort) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1039 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 /*********************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 /* C integer types. User-defined typedefs (like "size_t" or */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1042 /* "intptr_t") are guaranteed to be present with the same names over */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1043 /* in the SA's type database. Names like "unsigned short" are not */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1044 /* guaranteed to be visible through the SA's type database lookup */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1045 /* mechanism, though they will have a Type object created for them */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1046 /* and are valid types for Fields. */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1047 /*********************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 declare_integer_type(bool) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 declare_integer_type(int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1050 declare_integer_type(long) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 declare_integer_type(char) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1052 declare_unsigned_integer_type(unsigned char) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1053 declare_unsigned_integer_type(unsigned int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1054 declare_unsigned_integer_type(unsigned short) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1055 declare_unsigned_integer_type(unsigned long) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1056 /* The compiler thinks this is a different type than */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1057 /* unsigned short on Win32 */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1058 declare_unsigned_integer_type(u2) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1059 declare_unsigned_integer_type(unsigned) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1060 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1061 /*****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1062 /* C primitive pointer types */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 /*****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1064 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1065 declare_toplevel_type(int*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1066 declare_toplevel_type(char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 declare_toplevel_type(char**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 declare_toplevel_type(const char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 declare_toplevel_type(u_char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1070 declare_toplevel_type(unsigned char*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1072 /*******************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 /* Types which it will be handy to have available over in the SA */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 /* in order to do platform-independent address -> integer coercion */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 /* (note: these will be looked up by name) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 /*******************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 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
1079 declare_integer_type(ssize_t) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 declare_unsigned_integer_type(const size_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1081 declare_integer_type(intx) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 declare_integer_type(intptr_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 declare_unsigned_integer_type(uintx) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 declare_unsigned_integer_type(uintptr_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1085 declare_unsigned_integer_type(uint32_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1086 declare_unsigned_integer_type(uint64_t) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1087 declare_integer_type(const int) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1088 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1089 /*******************************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1090 /* OopDesc and Klass hierarchies (NOTE: missing methodDataOop-related classes) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1091 /*******************************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1092 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 declare_toplevel_type(oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1094 declare_toplevel_type(Klass_vtbl) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 declare_type(Klass, Klass_vtbl) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 declare_type(arrayKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1097 declare_type(arrayKlassKlass, klassKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1098 declare_type(arrayOopDesc, oopDesc) \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1099 declare_type(compiledICHolderKlass, Klass) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1100 declare_type(compiledICHolderOopDesc, oopDesc) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1101 declare_type(constantPoolKlass, Klass) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1102 declare_type(constantPoolOopDesc, oopDesc) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1103 declare_type(constantPoolCacheKlass, Klass) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1104 declare_type(constantPoolCacheOopDesc, oopDesc) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 declare_type(instanceKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1106 declare_type(instanceKlassKlass, klassKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1107 declare_type(instanceOopDesc, oopDesc) \
2411
63997f575155 7031614: jmap -permstat fails with java.lang.InternalError in sun.jvm.hotspot.oops.OopField.getValue
never
parents: 2388
diff changeset
1108 declare_type(instanceMirrorKlass, instanceKlass) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1109 declare_type(instanceRefKlass, instanceKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1110 declare_type(klassKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1111 declare_type(klassOopDesc, oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1112 declare_type(markOopDesc, oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1113 declare_type(methodDataKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1114 declare_type(methodDataOopDesc, oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1115 declare_type(methodKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1116 declare_type(constMethodKlass, Klass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1117 declare_type(methodOopDesc, oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1118 declare_type(objArrayKlass, arrayKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1119 declare_type(objArrayKlassKlass, arrayKlassKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 declare_type(objArrayOopDesc, arrayOopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1121 declare_type(constMethodOopDesc, oopDesc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 declare_type(typeArrayKlass, arrayKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1123 declare_type(typeArrayKlassKlass, arrayKlassKlass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1124 declare_type(typeArrayOopDesc, arrayOopDesc) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1125 declare_toplevel_type(Symbol) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1126 declare_toplevel_type(Symbol*) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1127 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1128 /********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1129 /* Oops */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1130 /********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1132 declare_oop_type(constantPoolOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1133 declare_oop_type(constantPoolCacheOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1134 declare_oop_type(klassOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1135 declare_oop_type(markOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 declare_oop_type(methodOop) \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1137 declare_oop_type(methodDataOop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1138 declare_oop_type(objArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1139 declare_oop_type(oop) \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1140 declare_oop_type(narrowOop) \
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1141 declare_oop_type(wideKlassOop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1142 declare_oop_type(constMethodOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1143 declare_oop_type(typeArrayOop) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1144 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1145 /*************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1146 /* MethodOop-related data structures */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1147 /*************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1148 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 declare_toplevel_type(CheckedExceptionElement) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1150 declare_toplevel_type(LocalVariableTableElement) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1151 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 /******************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1153 /* Generation and space hierarchies */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1154 /* (needed for run-time type information) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1155 /******************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1156 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1157 declare_toplevel_type(CollectedHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1158 declare_type(SharedHeap, CollectedHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 declare_type(GenCollectedHeap, SharedHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 declare_toplevel_type(Generation) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1161 declare_type(DefNewGeneration, Generation) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1162 declare_type(CardGeneration, Generation) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1163 declare_type(OneContigSpaceCardGeneration, CardGeneration) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 declare_type(TenuredGeneration, OneContigSpaceCardGeneration) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1165 declare_type(CompactingPermGenGen, OneContigSpaceCardGeneration) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1166 declare_toplevel_type(Space) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1167 declare_toplevel_type(BitMap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1168 declare_type(CompactibleSpace, Space) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1169 declare_type(ContiguousSpace, CompactibleSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1170 declare_type(EdenSpace, ContiguousSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1171 declare_type(OffsetTableContigSpace, ContiguousSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 declare_type(TenuredSpace, OffsetTableContigSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1173 declare_type(ContigPermSpace, OffsetTableContigSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1174 declare_toplevel_type(PermGen) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 declare_type(CompactingPermGen, PermGen) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1176 declare_toplevel_type(BarrierSet) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 declare_type(ModRefBarrierSet, BarrierSet) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 declare_type(CardTableModRefBS, ModRefBarrierSet) \
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
1179 declare_type(CardTableModRefBSForCTRS, CardTableModRefBS) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 declare_toplevel_type(GenRemSet) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 declare_type(CardTableRS, GenRemSet) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1182 declare_toplevel_type(BlockOffsetSharedArray) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 declare_toplevel_type(BlockOffsetTable) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 declare_type(BlockOffsetArray, BlockOffsetTable) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1185 declare_type(BlockOffsetArrayContigSpace, BlockOffsetArray) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 declare_type(BlockOffsetArrayNonContigSpace, BlockOffsetArray) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1187 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 /* Miscellaneous other GC types */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 declare_toplevel_type(ageTable) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1191 declare_toplevel_type(Generation::StatRecord) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 declare_toplevel_type(GenerationSpec) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1193 declare_toplevel_type(HeapWord) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1194 declare_toplevel_type(MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1195 declare_toplevel_type(const MemRegion) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 declare_toplevel_type(PermanentGenerationSpec) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1197 declare_toplevel_type(ThreadLocalAllocBuffer) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 declare_toplevel_type(VirtualSpace) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1199 declare_toplevel_type(WaterMark) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1201 /* Pointers to Garbage Collection types */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1203 declare_toplevel_type(BarrierSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1204 declare_toplevel_type(BlockOffsetSharedArray*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1205 declare_toplevel_type(GenRemSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1206 declare_toplevel_type(CardTableRS*) \
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
1207 declare_toplevel_type(CardTableModRefBS*) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
1208 declare_toplevel_type(CardTableModRefBS**) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
1209 declare_toplevel_type(CardTableModRefBSForCTRS*) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 147
diff changeset
1210 declare_toplevel_type(CardTableModRefBSForCTRS**) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1211 declare_toplevel_type(CollectedHeap*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1212 declare_toplevel_type(ContiguousSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1213 declare_toplevel_type(DefNewGeneration*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1214 declare_toplevel_type(EdenSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1215 declare_toplevel_type(GenCollectedHeap*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1216 declare_toplevel_type(Generation*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1217 declare_toplevel_type(GenerationSpec**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1218 declare_toplevel_type(HeapWord*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1219 declare_toplevel_type(MemRegion*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1220 declare_toplevel_type(OffsetTableContigSpace*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1221 declare_toplevel_type(OneContigSpaceCardGeneration*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1222 declare_toplevel_type(PermGen*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1223 declare_toplevel_type(Space*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1224 declare_toplevel_type(ThreadLocalAllocBuffer*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1225 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1226 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1227 /* PerfMemory - jvmstat */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1228 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1229 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1230 declare_toplevel_type(PerfDataPrologue) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1231 declare_toplevel_type(PerfDataPrologue*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1232 declare_toplevel_type(PerfDataEntry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1233 declare_toplevel_type(PerfMemory) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1234 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1235 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1236 /* SymbolTable, SystemDictionary */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1237 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1238 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1239 declare_toplevel_type(BasicHashtable) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1240 declare_type(Hashtable<intptr_t>, BasicHashtable) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1241 declare_type(SymbolTable, Hashtable<Symbol*>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1242 declare_type(StringTable, Hashtable<oop>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1243 declare_type(LoaderConstraintTable, Hashtable<klassOop>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1244 declare_type(TwoOopHashtable<klassOop>, Hashtable<klassOop>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1245 declare_type(Dictionary, TwoOopHashtable<klassOop>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1246 declare_type(PlaceholderTable, TwoOopHashtable<Symbol*>) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1247 declare_toplevel_type(BasicHashtableEntry) \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1248 declare_type(HashtableEntry<intptr_t>, BasicHashtableEntry) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1249 declare_type(DictionaryEntry, HashtableEntry<klassOop>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1250 declare_type(PlaceholderEntry, HashtableEntry<Symbol*>) \
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1251 declare_type(LoaderConstraintEntry, HashtableEntry<klassOop>) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1252 declare_toplevel_type(HashtableBucket) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1253 declare_toplevel_type(SystemDictionary) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1254 declare_toplevel_type(ProtectionDomainEntry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1255 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1256 /***********************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1257 /* Thread hierarchy (needed for run-time type information) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1258 /***********************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1260 declare_toplevel_type(Threads) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1261 declare_toplevel_type(ThreadShadow) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1262 declare_type(Thread, ThreadShadow) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1263 declare_type(NamedThread, Thread) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1264 declare_type(WatcherThread, Thread) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1265 declare_type(JavaThread, Thread) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1266 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
1267 declare_type(ServiceThread, JavaThread) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1268 declare_type(CompilerThread, JavaThread) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1269 declare_toplevel_type(OSThread) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1270 declare_toplevel_type(JavaFrameAnchor) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1271 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1272 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1273 /* Interpreter */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1274 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1275 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1276 declare_toplevel_type(AbstractInterpreter) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1277 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1278 /*********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1279 /* Stubs */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1280 /*********/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1281 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 declare_toplevel_type(StubQueue) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1283 declare_toplevel_type(StubRoutines) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 declare_toplevel_type(Stub) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 declare_type(InterpreterCodelet, Stub) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1287 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1288 /* JavaCalls */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1291 declare_toplevel_type(JavaCallWrapper) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1293 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1294 /* CodeCache */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 declare_toplevel_type(CodeCache) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1298 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1299 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1300 /* CodeHeap */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1301 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1302 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1303 declare_toplevel_type(CodeHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1304 declare_toplevel_type(CodeHeap*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1305 declare_toplevel_type(HeapBlock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1306 declare_toplevel_type(HeapBlock::Header) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1307 declare_type(FreeBlock, HeapBlock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1308 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1309 /*************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1310 /* CodeBlob hierarchy (needed for run-time type information) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1311 /*************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1312 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1313 declare_toplevel_type(CodeBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1314 declare_type(BufferBlob, CodeBlob) \
3388
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
1315 declare_type(AdapterBlob, BufferBlob) \
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
1316 declare_type(nmethod, CodeBlob) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1317 declare_type(RuntimeStub, CodeBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1318 declare_type(SingletonBlob, CodeBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1319 declare_type(SafepointBlob, SingletonBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1320 declare_type(DeoptimizationBlob, SingletonBlob) \
3388
a80577f854f9 7045513: JSR 292 inlining causes crashes in methodHandleWalk.cpp
never
parents: 2411
diff changeset
1321 declare_type(RicochetBlob, SingletonBlob) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1322 declare_c2_type(ExceptionBlob, SingletonBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1323 declare_c2_type(UncommonTrapBlob, CodeBlob) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1324 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1325 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1326 /* PcDesc and other compiled code info */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1327 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1328 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1329 declare_toplevel_type(PcDesc) \
931
72088be4b386 6873116: Modify reexecute implementation to use pcDesc to record the reexecute bit
cfang
parents: 844
diff changeset
1330 declare_integer_type(PcDesc::PcDescFlags) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1331 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1332 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1333 /* OopMap and OopMapSet */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1334 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1335 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1336 declare_toplevel_type(OopMap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1337 declare_toplevel_type(OopMapSet) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1338 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1339 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1340 /* CompressedStream */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1341 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1342 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1343 declare_toplevel_type(CompressedStream) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1344 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1345 /**************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1346 /* VMRegImpl */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1347 /**************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1349 declare_toplevel_type(VMRegImpl) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1350 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1351 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1352 /* JNIHandles and JNIHandleBlock */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1353 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1354 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1355 declare_toplevel_type(JNIHandles) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 declare_toplevel_type(JNIHandleBlock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1357 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 /**********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1359 /* Runtime1 (C1 only) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 /**********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1361 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 declare_c1_toplevel_type(Runtime1) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 /* Monitors */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 /************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1367 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 declare_toplevel_type(ObjectMonitor) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 declare_toplevel_type(ObjectSynchronizer) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 declare_toplevel_type(BasicLock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 declare_toplevel_type(BasicObjectLock) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 /* Matcher (C2 only) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1375 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1377 /* NOTE: this is not really a toplevel type, but we only need */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 /* this one -- FIXME later if necessary */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1379 declare_c2_toplevel_type(Matcher) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 /* Adapter Blob Entries */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1383 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1384 declare_toplevel_type(AdapterHandlerEntry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1385 declare_toplevel_type(AdapterHandlerEntry*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1386 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1387 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1388 /* -XX flags */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1389 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1391 declare_toplevel_type(Flag) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1392 declare_toplevel_type(Flag*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1393 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1395 /* JDK/VM version */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1396 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1397 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 declare_toplevel_type(Abstract_VM_Version) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 declare_toplevel_type(JDK_Version) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1400 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1402 /* Arguments */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 /*************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1405 declare_toplevel_type(Arguments) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1406 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1408 /* Other types */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1409 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 /* all enum types */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1412 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 declare_integer_type(Bytecodes::Code) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1414 declare_integer_type(Generation::Name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 declare_integer_type(instanceKlass::ClassState) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 declare_integer_type(JavaThreadState) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1417 declare_integer_type(Location::Type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 declare_integer_type(Location::Where) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 declare_integer_type(PermGen::Name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1420 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1421 declare_integer_type(AccessFlags) /* FIXME: wrong type (not integer) */\
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 declare_toplevel_type(address) /* FIXME: should this be an integer type? */\
a61af66fc99e Initial load
duke
parents:
diff changeset
1423 declare_toplevel_type(BreakpointInfo) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1424 declare_toplevel_type(BreakpointInfo*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1425 declare_toplevel_type(CodeBlob*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1426 declare_toplevel_type(CompressedWriteStream*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1427 declare_toplevel_type(ConstantPoolCacheEntry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1428 declare_toplevel_type(elapsedTimer) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1429 declare_toplevel_type(intptr_t*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 declare_unsigned_integer_type(InvocationCounter) /* FIXME: wrong type (not integer) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1431 declare_toplevel_type(JavaThread*) \
2376
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 2260
diff changeset
1432 declare_toplevel_type(java_lang_Class) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1433 declare_toplevel_type(jbyte*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1434 declare_toplevel_type(jbyte**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1435 declare_toplevel_type(jint*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1436 declare_toplevel_type(jniIdMapBase*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1437 declare_unsigned_integer_type(juint) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1438 declare_unsigned_integer_type(julong) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1439 declare_toplevel_type(JNIHandleBlock*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1440 declare_toplevel_type(JNIid) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 declare_toplevel_type(JNIid*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1442 declare_toplevel_type(jmethodID*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 declare_toplevel_type(Mutex*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1444 declare_toplevel_type(nmethod*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1445 declare_toplevel_type(ObjectMonitor*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1446 declare_toplevel_type(oop*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1447 declare_toplevel_type(OopMap**) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1448 declare_toplevel_type(OopMapCache*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1449 declare_toplevel_type(OopMapSet*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1450 declare_toplevel_type(VMReg) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1451 declare_toplevel_type(OSThread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1452 declare_integer_type(ReferenceType) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1453 declare_toplevel_type(StubQueue*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1454 declare_toplevel_type(Thread*) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1455 declare_toplevel_type(Universe)
a61af66fc99e Initial load
duke
parents:
diff changeset
1456
a61af66fc99e Initial load
duke
parents:
diff changeset
1457 /* NOTE that we do not use the last_entry() macro here; it is used */
a61af66fc99e Initial load
duke
parents:
diff changeset
1458 /* in vmStructs_<os>_<cpu>.hpp's VM_TYPES_OS_CPU macro (and must be */
a61af66fc99e Initial load
duke
parents:
diff changeset
1459 /* present there) */
a61af66fc99e Initial load
duke
parents:
diff changeset
1460
a61af66fc99e Initial load
duke
parents:
diff changeset
1461 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1462 // VM_INT_CONSTANTS
a61af66fc99e Initial load
duke
parents:
diff changeset
1463 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1464 // This table contains integer constants required over in the
a61af66fc99e Initial load
duke
parents:
diff changeset
1465 // serviceability agent. The "declare_constant" macro is used for all
a61af66fc99e Initial load
duke
parents:
diff changeset
1466 // enums, etc., while "declare_preprocessor_constant" must be used for
a61af66fc99e Initial load
duke
parents:
diff changeset
1467 // all #defined constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
1468
a61af66fc99e Initial load
duke
parents:
diff changeset
1469 #define VM_INT_CONSTANTS(declare_constant, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 declare_preprocessor_constant, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1471 declare_c1_constant, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 declare_c2_constant, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1473 declare_c2_preprocessor_constant, \
a61af66fc99e Initial load
duke
parents:
diff changeset
1474 last_entry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1475 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1476 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1477 /* Useful globals */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1478 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 declare_constant(UseTLAB) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1481 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 /**************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1483 /* Stack bias */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 /**************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 declare_preprocessor_constant("STACK_BIAS", STACK_BIAS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 /****************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1489 /* Object sizes */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1490 /****************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1491 \
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 0
diff changeset
1492 declare_constant(oopSize) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 declare_constant(LogBytesPerWord) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1494 declare_constant(BytesPerLong) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1496 /********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 /* Generation and Space Hierarchy Constants */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1498 /********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 declare_constant(ageTable::table_size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1501 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1502 declare_constant(BarrierSet::ModRef) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1503 declare_constant(BarrierSet::CardTableModRef) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 declare_constant(BarrierSet::Other) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 declare_constant(BlockOffsetSharedArray::LogN) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1507 declare_constant(BlockOffsetSharedArray::LogN_words) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 declare_constant(BlockOffsetSharedArray::N_bytes) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1509 declare_constant(BlockOffsetSharedArray::N_words) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1510 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1511 declare_constant(BlockOffsetArray::N_words) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1512 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 declare_constant(CardTableModRefBS::clean_card) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1514 declare_constant(CardTableModRefBS::last_card) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1515 declare_constant(CardTableModRefBS::dirty_card) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1516 declare_constant(CardTableModRefBS::Precise) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 declare_constant(CardTableModRefBS::ObjHeadPreciseArray) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1518 declare_constant(CardTableModRefBS::card_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1519 declare_constant(CardTableModRefBS::card_size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1520 declare_constant(CardTableModRefBS::card_size_in_words) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 declare_constant(CardTableRS::youngergen_card) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1523 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1524 declare_constant(CollectedHeap::Abstract) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1525 declare_constant(CollectedHeap::SharedHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1526 declare_constant(CollectedHeap::GenCollectedHeap) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1527 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1528 declare_constant(GenCollectedHeap::max_gens) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1529 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1530 /* constants from Generation::Name enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1531 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1532 declare_constant(Generation::DefNew) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1533 declare_constant(Generation::MarkSweepCompact) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1534 declare_constant(Generation::Other) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1535 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1536 declare_constant(Generation::LogOfGenGrain) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1537 declare_constant(Generation::GenGrain) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1538 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1539 declare_constant(HeapWordSize) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1540 declare_constant(LogHeapWordSize) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1541 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1542 /* constants from PermGen::Name enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1543 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1544 declare_constant(PermGen::MarkSweepCompact) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1545 declare_constant(PermGen::MarkSweep) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1546 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1547 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1548 /* PerfMemory - jvmstat */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1549 /************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1550 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1551 declare_preprocessor_constant("PERFDATA_MAJOR_VERSION", PERFDATA_MAJOR_VERSION) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1552 declare_preprocessor_constant("PERFDATA_MINOR_VERSION", PERFDATA_MINOR_VERSION) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1553 declare_preprocessor_constant("PERFDATA_BIG_ENDIAN", PERFDATA_BIG_ENDIAN) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1554 declare_preprocessor_constant("PERFDATA_LITTLE_ENDIAN", PERFDATA_LITTLE_ENDIAN) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1555 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1556 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1557 /* SymbolTable */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1558 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1559 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1560 declare_constant(SymbolTable::symbol_table_size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1561 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1562 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1563 /* SystemDictionary */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1564 /********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1565 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1566 declare_constant(SystemDictionary::_loader_constraint_size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1567 declare_constant(SystemDictionary::_nof_buckets) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1568 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1569 /***********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1570 /* LoaderConstraintTable constants */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1571 /***********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1572 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1573 declare_constant(LoaderConstraintTable::_loader_constraint_size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1574 declare_constant(LoaderConstraintTable::_nof_buckets) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1575 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1576 /************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1577 /* HotSpot specific JVM_ACC constants from global anon enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1578 /************************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1579 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1580 declare_constant(JVM_ACC_WRITTEN_FLAGS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1581 declare_constant(JVM_ACC_MONITOR_MATCH) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1582 declare_constant(JVM_ACC_HAS_MONITOR_BYTECODES) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1583 declare_constant(JVM_ACC_HAS_LOOPS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1584 declare_constant(JVM_ACC_LOOPS_FLAG_INIT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1585 declare_constant(JVM_ACC_QUEUED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1586 declare_constant(JVM_ACC_NOT_OSR_COMPILABLE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1587 declare_constant(JVM_ACC_HAS_LINE_NUMBER_TABLE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1588 declare_constant(JVM_ACC_HAS_CHECKED_EXCEPTIONS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1589 declare_constant(JVM_ACC_HAS_JSRS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1590 declare_constant(JVM_ACC_IS_OLD) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1591 declare_constant(JVM_ACC_IS_OBSOLETE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1592 declare_constant(JVM_ACC_IS_PREFIXED_NATIVE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1593 declare_constant(JVM_ACC_HAS_MIRANDA_METHODS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1594 declare_constant(JVM_ACC_HAS_VANILLA_CONSTRUCTOR) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1595 declare_constant(JVM_ACC_HAS_FINALIZER) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1596 declare_constant(JVM_ACC_IS_CLONEABLE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1597 declare_constant(JVM_ACC_HAS_LOCAL_VARIABLE_TABLE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1598 declare_constant(JVM_ACC_PROMOTED_FLAGS) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1599 declare_constant(JVM_ACC_FIELD_ACCESS_WATCHED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1600 declare_constant(JVM_ACC_FIELD_MODIFICATION_WATCHED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1601 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1602 /*****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1603 /* Thread::SuspendFlags enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1604 /*****************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1605 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1606 declare_constant(Thread::_external_suspend) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1607 declare_constant(Thread::_ext_suspended) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1608 declare_constant(Thread::_has_async_exception) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1609 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1610 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1611 /* JavaThreadState */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1612 /*******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1613 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1614 declare_constant(_thread_uninitialized) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1615 declare_constant(_thread_new) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1616 declare_constant(_thread_new_trans) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1617 declare_constant(_thread_in_native) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1618 declare_constant(_thread_in_native_trans) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1619 declare_constant(_thread_in_vm) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1620 declare_constant(_thread_in_vm_trans) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1621 declare_constant(_thread_in_Java) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1622 declare_constant(_thread_in_Java_trans) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1623 declare_constant(_thread_blocked) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1624 declare_constant(_thread_blocked_trans) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1625 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1626 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1627 /* Klass misc. enum constants */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1628 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1629 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1630 declare_constant(Klass::_primary_super_limit) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1631 declare_constant(Klass::_lh_instance_slow_path_bit) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1632 declare_constant(Klass::_lh_log2_element_size_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1633 declare_constant(Klass::_lh_element_type_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1634 declare_constant(Klass::_lh_header_size_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1635 declare_constant(Klass::_lh_array_tag_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1636 declare_constant(Klass::_lh_array_tag_type_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1637 declare_constant(Klass::_lh_array_tag_obj_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1638 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1639 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1640 /* constMethodOopDesc anon-enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1641 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1642 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1643 declare_constant(constMethodOopDesc::_has_linenumber_table) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1644 declare_constant(constMethodOopDesc::_has_checked_exceptions) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1645 declare_constant(constMethodOopDesc::_has_localvariable_table) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1646 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1647 /*************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1648 /* instanceKlass FieldOffset enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1649 /*************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1650 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1651 declare_constant(instanceKlass::access_flags_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1652 declare_constant(instanceKlass::name_index_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1653 declare_constant(instanceKlass::signature_index_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1654 declare_constant(instanceKlass::initval_index_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1655 declare_constant(instanceKlass::low_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1656 declare_constant(instanceKlass::high_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1657 declare_constant(instanceKlass::generic_signature_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1658 declare_constant(instanceKlass::next_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1659 declare_constant(instanceKlass::implementors_limit) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1660 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1661 /************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1662 /* instanceKlass InnerClassAttributeOffset enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1663 /************************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1664 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1665 declare_constant(instanceKlass::inner_class_inner_class_info_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1666 declare_constant(instanceKlass::inner_class_outer_class_info_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1667 declare_constant(instanceKlass::inner_class_inner_name_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1668 declare_constant(instanceKlass::inner_class_access_flags_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1669 declare_constant(instanceKlass::inner_class_next_offset) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1670 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1671 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1672 /* instanceKlass ClassState enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1673 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1674 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1675 declare_constant(instanceKlass::unparsable_by_gc) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1676 declare_constant(instanceKlass::allocated) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1677 declare_constant(instanceKlass::loaded) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1678 declare_constant(instanceKlass::linked) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1679 declare_constant(instanceKlass::being_initialized) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1680 declare_constant(instanceKlass::fully_initialized) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1681 declare_constant(instanceKlass::initialization_error) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1682 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1683 /*********************************/ \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1684 /* Symbol* - symbol max length */ \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1685 /*********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1686 \
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
1687 declare_constant(Symbol::max_symbol_length) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1688 \
1913
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1689 /*************************************************/ \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1690 /* constantPoolOop layout enum for InvokeDynamic */ \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1691 /*************************************************/ \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1692 \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1693 declare_constant(constantPoolOopDesc::_indy_bsm_offset) \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1694 declare_constant(constantPoolOopDesc::_indy_argc_offset) \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1695 declare_constant(constantPoolOopDesc::_indy_argv_offset) \
3b2dea75431e 6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents: 1748
diff changeset
1696 \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1697 /*********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1698 /* ConstantPoolCacheEntry FlagBitValues enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1699 /*********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1700 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1701 declare_constant(ConstantPoolCacheEntry::hotSwapBit) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1702 declare_constant(ConstantPoolCacheEntry::methodInterface) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1703 declare_constant(ConstantPoolCacheEntry::volatileField) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1704 declare_constant(ConstantPoolCacheEntry::vfinalMethod) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1705 declare_constant(ConstantPoolCacheEntry::finalField) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1706 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1707 /******************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1708 /* ConstantPoolCacheEntry FlagValues enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1709 /******************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1710 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1711 declare_constant(ConstantPoolCacheEntry::tosBits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1712 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1713 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1714 /* java_lang_Thread::ThreadStatus enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1715 /***************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1716 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1717 declare_constant(java_lang_Thread::NEW) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1718 declare_constant(java_lang_Thread::RUNNABLE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1719 declare_constant(java_lang_Thread::SLEEPING) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1720 declare_constant(java_lang_Thread::IN_OBJECT_WAIT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1721 declare_constant(java_lang_Thread::IN_OBJECT_WAIT_TIMED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1722 declare_constant(java_lang_Thread::PARKED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1723 declare_constant(java_lang_Thread::PARKED_TIMED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1724 declare_constant(java_lang_Thread::BLOCKED_ON_MONITOR_ENTER) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1725 declare_constant(java_lang_Thread::TERMINATED) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1726 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1727 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1728 /* Debug info */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1729 /******************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1730 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1731 declare_constant(Location::OFFSET_MASK) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1732 declare_constant(Location::OFFSET_SHIFT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1733 declare_constant(Location::TYPE_MASK) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1734 declare_constant(Location::TYPE_SHIFT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1735 declare_constant(Location::WHERE_MASK) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1736 declare_constant(Location::WHERE_SHIFT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1737 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1738 /* constants from Location::Type enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1739 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1740 declare_constant(Location::normal) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1741 declare_constant(Location::oop) \
331
cecd8eb4e0ca 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 304
diff changeset
1742 declare_constant(Location::narrowoop) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1743 declare_constant(Location::int_in_long) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1744 declare_constant(Location::lng) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1745 declare_constant(Location::float_in_dbl) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1746 declare_constant(Location::dbl) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1747 declare_constant(Location::addr) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1748 declare_constant(Location::invalid) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1749 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1750 /* constants from Location::Where enum */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1751 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1752 declare_constant(Location::on_stack) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1753 declare_constant(Location::in_register) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1754 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1755 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1756 /* Matcher (C2 only) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1757 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1758 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1759 declare_c2_preprocessor_constant("Matcher::interpreter_frame_pointer_reg", Matcher::interpreter_frame_pointer_reg()) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1760 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1761 /*********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1762 /* MethodCompilation (globalDefinitions.hpp) */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1763 /*********************************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1764 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1765 declare_constant(InvocationEntryBci) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1766 declare_constant(InvalidOSREntryBci) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1767 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1768 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1769 /* OopMapValue */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1770 /***************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1771 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1772 declare_constant(OopMapValue::type_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1773 declare_constant(OopMapValue::register_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1774 declare_constant(OopMapValue::type_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1775 declare_constant(OopMapValue::register_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1776 declare_constant(OopMapValue::type_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1777 declare_constant(OopMapValue::type_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1778 declare_constant(OopMapValue::register_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1779 declare_constant(OopMapValue::register_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1780 declare_constant(OopMapValue::unused_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1781 declare_constant(OopMapValue::oop_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1782 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
1783 declare_constant(OopMapValue::narrowoop_value) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1784 declare_constant(OopMapValue::callee_saved_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1785 declare_constant(OopMapValue::derived_oop_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1786 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1787 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1788 /* JNIHandleBlock */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1789 /******************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1790 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1791 declare_constant(JNIHandleBlock::block_size_in_oops) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1792 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1793 /**********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1794 /* ObjectSynchronizer */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1795 /**********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1796 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1797 declare_constant(ObjectSynchronizer::_BLOCKSIZE) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1798 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1799 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1800 /* Calling convention constants */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1801 /********************************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1802 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1803 declare_constant(RegisterImpl::number_of_registers) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1804 declare_constant(ConcreteRegisterImpl::number_of_registers) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1805 declare_preprocessor_constant("REG_COUNT", REG_COUNT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1806 declare_c2_preprocessor_constant("SAVED_ON_ENTRY_REG_COUNT", SAVED_ON_ENTRY_REG_COUNT) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1807 declare_c2_preprocessor_constant("C_SAVED_ON_ENTRY_REG_COUNT", C_SAVED_ON_ENTRY_REG_COUNT)
a61af66fc99e Initial load
duke
parents:
diff changeset
1808
a61af66fc99e Initial load
duke
parents:
diff changeset
1809 /* NOTE that we do not use the last_entry() macro here; it is used */
a61af66fc99e Initial load
duke
parents:
diff changeset
1810 /* in vmStructs_<os>_<cpu>.hpp's VM_INT_CONSTANTS_OS_CPU macro (and */
a61af66fc99e Initial load
duke
parents:
diff changeset
1811 /* must be present there) */
a61af66fc99e Initial load
duke
parents:
diff changeset
1812
a61af66fc99e Initial load
duke
parents:
diff changeset
1813 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1814 // VM_LONG_CONSTANTS
a61af66fc99e Initial load
duke
parents:
diff changeset
1815 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1816 // This table contains long constants required over in the
a61af66fc99e Initial load
duke
parents:
diff changeset
1817 // serviceability agent. The "declare_constant" macro is used for all
a61af66fc99e Initial load
duke
parents:
diff changeset
1818 // enums, etc., while "declare_preprocessor_constant" must be used for
a61af66fc99e Initial load
duke
parents:
diff changeset
1819 // all #defined constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
1820
a61af66fc99e Initial load
duke
parents:
diff changeset
1821 #define VM_LONG_CONSTANTS(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant, last_entry) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1822 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1823 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1824 /* MarkOop constants */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1825 /*********************/ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1826 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1827 /* Note: some of these are declared as long constants just for */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1828 /* consistency. The mask constants are the only ones requiring */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1829 /* 64 bits (on 64-bit platforms). */ \
a61af66fc99e Initial load
duke
parents:
diff changeset
1830 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1831 declare_constant(markOopDesc::age_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1832 declare_constant(markOopDesc::lock_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1833 declare_constant(markOopDesc::biased_lock_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1834 declare_constant(markOopDesc::max_hash_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1835 declare_constant(markOopDesc::hash_bits) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1836 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1837 declare_constant(markOopDesc::lock_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1838 declare_constant(markOopDesc::biased_lock_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1839 declare_constant(markOopDesc::age_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1840 declare_constant(markOopDesc::hash_shift) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1841 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1842 declare_constant(markOopDesc::lock_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1843 declare_constant(markOopDesc::lock_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1844 declare_constant(markOopDesc::biased_lock_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1845 declare_constant(markOopDesc::biased_lock_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1846 declare_constant(markOopDesc::biased_lock_bit_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1847 declare_constant(markOopDesc::age_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1848 declare_constant(markOopDesc::age_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1849 declare_constant(markOopDesc::hash_mask) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1850 declare_constant(markOopDesc::hash_mask_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1851 declare_constant(markOopDesc::biased_lock_alignment) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1852 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1853 declare_constant(markOopDesc::locked_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1854 declare_constant(markOopDesc::unlocked_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1855 declare_constant(markOopDesc::monitor_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1856 declare_constant(markOopDesc::marked_value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1857 declare_constant(markOopDesc::biased_lock_pattern) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1858 \
a61af66fc99e Initial load
duke
parents:
diff changeset
1859 declare_constant(markOopDesc::no_hash) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1860 declare_constant(markOopDesc::no_hash_in_place) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1861 declare_constant(markOopDesc::no_lock_in_place) \
187
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1862 declare_constant(markOopDesc::max_age) \
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1863 \
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1864 /* Constants in markOop used by CMS. */ \
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1865 declare_constant(markOopDesc::cms_shift) \
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1866 declare_constant(markOopDesc::cms_mask) \
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
1867 declare_constant(markOopDesc::size_shift) \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1868
a61af66fc99e Initial load
duke
parents:
diff changeset
1869 /* NOTE that we do not use the last_entry() macro here; it is used */
a61af66fc99e Initial load
duke
parents:
diff changeset
1870 /* in vmStructs_<os>_<cpu>.hpp's VM_LONG_CONSTANTS_OS_CPU macro (and */
a61af66fc99e Initial load
duke
parents:
diff changeset
1871 /* must be present there) */
a61af66fc99e Initial load
duke
parents:
diff changeset
1872
a61af66fc99e Initial load
duke
parents:
diff changeset
1873
a61af66fc99e Initial load
duke
parents:
diff changeset
1874 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1875 // Macros operating on the above lists
a61af66fc99e Initial load
duke
parents:
diff changeset
1876 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1877
a61af66fc99e Initial load
duke
parents:
diff changeset
1878 // This utility macro quotes the passed string
a61af66fc99e Initial load
duke
parents:
diff changeset
1879 #define QUOTE(x) #x
a61af66fc99e Initial load
duke
parents:
diff changeset
1880
a61af66fc99e Initial load
duke
parents:
diff changeset
1881 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1882 // VMStructEntry macros
a61af66fc99e Initial load
duke
parents:
diff changeset
1883 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1884
a61af66fc99e Initial load
duke
parents:
diff changeset
1885 // This macro generates a VMStructEntry line for a nonstatic field
a61af66fc99e Initial load
duke
parents:
diff changeset
1886 #define GENERATE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1887 { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 0, cast_uint64_t(offset_of(typeName, fieldName)), NULL },
a61af66fc99e Initial load
duke
parents:
diff changeset
1888
a61af66fc99e Initial load
duke
parents:
diff changeset
1889 // This macro generates a VMStructEntry line for a static field
a61af66fc99e Initial load
duke
parents:
diff changeset
1890 #define GENERATE_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1891 { QUOTE(typeName), QUOTE(fieldName), QUOTE(type), 1, 0, &typeName::fieldName },
a61af66fc99e Initial load
duke
parents:
diff changeset
1892
a61af66fc99e Initial load
duke
parents:
diff changeset
1893 // This macro generates a VMStructEntry line for an unchecked
a61af66fc99e Initial load
duke
parents:
diff changeset
1894 // nonstatic field, in which the size of the type is also specified.
a61af66fc99e Initial load
duke
parents:
diff changeset
1895 // The type string is given as NULL, indicating an "opaque" type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1896 #define GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1897 { QUOTE(typeName), QUOTE(fieldName), NULL, 0, cast_uint64_t(offset_of(typeName, fieldName)), NULL },
a61af66fc99e Initial load
duke
parents:
diff changeset
1898
a61af66fc99e Initial load
duke
parents:
diff changeset
1899 // This macro generates a VMStructEntry line for an unchecked
a61af66fc99e Initial load
duke
parents:
diff changeset
1900 // static field, in which the size of the type is also specified.
a61af66fc99e Initial load
duke
parents:
diff changeset
1901 // The type string is given as NULL, indicating an "opaque" type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1902 #define GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, size) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1903 { QUOTE(typeName), QUOTE(fieldName), NULL, 1, 0, (void*) &typeName::fieldName },
a61af66fc99e Initial load
duke
parents:
diff changeset
1904
a61af66fc99e Initial load
duke
parents:
diff changeset
1905 // This macro generates the sentinel value indicating the end of the list
a61af66fc99e Initial load
duke
parents:
diff changeset
1906 #define GENERATE_VM_STRUCT_LAST_ENTRY() \
a61af66fc99e Initial load
duke
parents:
diff changeset
1907 { NULL, NULL, NULL, 0, 0, NULL }
a61af66fc99e Initial load
duke
parents:
diff changeset
1908
a61af66fc99e Initial load
duke
parents:
diff changeset
1909 // This macro checks the type of a VMStructEntry by comparing pointer types
a61af66fc99e Initial load
duke
parents:
diff changeset
1910 #define CHECK_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1911 {typeName *dummyObj = NULL; type* dummy = &dummyObj->fieldName; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1912
a61af66fc99e Initial load
duke
parents:
diff changeset
1913 // This macro checks the type of a volatile VMStructEntry by comparing pointer types
a61af66fc99e Initial load
duke
parents:
diff changeset
1914 #define CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1915 {typedef type dummyvtype; typeName *dummyObj = NULL; volatile dummyvtype* dummy = &dummyObj->fieldName; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1916
a61af66fc99e Initial load
duke
parents:
diff changeset
1917 // This macro checks the type of a VMStructEntry by comparing pointer types
a61af66fc99e Initial load
duke
parents:
diff changeset
1918 #define CHECK_STATIC_VM_STRUCT_ENTRY(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1919 {type* dummy = &typeName::fieldName; }
a61af66fc99e Initial load
duke
parents:
diff changeset
1920
a61af66fc99e Initial load
duke
parents:
diff changeset
1921 // This macro ensures the type of a field and its containing type are
a61af66fc99e Initial load
duke
parents:
diff changeset
1922 // present in the type table. The assertion string is shorter than
a61af66fc99e Initial load
duke
parents:
diff changeset
1923 // preferable because (incredibly) of a bug in Solstice NFS client
a61af66fc99e Initial load
duke
parents:
diff changeset
1924 // which seems to prevent very long lines from compiling. This assertion
a61af66fc99e Initial load
duke
parents:
diff changeset
1925 // means that an entry in VMStructs::localHotSpotVMStructs[] was not
a61af66fc99e Initial load
duke
parents:
diff changeset
1926 // found in VMStructs::localHotSpotVMTypes[].
a61af66fc99e Initial load
duke
parents:
diff changeset
1927 #define ENSURE_FIELD_TYPE_PRESENT(typeName, fieldName, type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1928 { assert(findType(QUOTE(typeName)) != 0, "type \"" QUOTE(typeName) "\" not found in type table"); \
a61af66fc99e Initial load
duke
parents:
diff changeset
1929 assert(findType(QUOTE(type)) != 0, "type \"" QUOTE(type) "\" not found in type table"); }
a61af66fc99e Initial load
duke
parents:
diff changeset
1930
a61af66fc99e Initial load
duke
parents:
diff changeset
1931 // This is a no-op macro for unchecked fields
a61af66fc99e Initial load
duke
parents:
diff changeset
1932 #define CHECK_NO_OP(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1933
a61af66fc99e Initial load
duke
parents:
diff changeset
1934 // This is a no-op macro for the sentinel value
a61af66fc99e Initial load
duke
parents:
diff changeset
1935 #define CHECK_SENTINEL()
a61af66fc99e Initial load
duke
parents:
diff changeset
1936
a61af66fc99e Initial load
duke
parents:
diff changeset
1937 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1938 // Build-specific macros:
a61af66fc99e Initial load
duke
parents:
diff changeset
1939 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1940
a61af66fc99e Initial load
duke
parents:
diff changeset
1941 // Generate and check a nonstatic field in non-product builds
a61af66fc99e Initial load
duke
parents:
diff changeset
1942 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
1943 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1944 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1945 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1946 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1947 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1948 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1949 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
1950 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1951 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1952 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1953 # define GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1954 # define CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1955 # define ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1956 #endif /* PRODUCT */
a61af66fc99e Initial load
duke
parents:
diff changeset
1957
a61af66fc99e Initial load
duke
parents:
diff changeset
1958 // Generate and check a nonstatic field in C1 builds
a61af66fc99e Initial load
duke
parents:
diff changeset
1959 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
1960 # define GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1961 # define CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1962 # define ENSURE_C1_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1963 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
1964 # define GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1965 # define CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1966 # define ENSURE_C1_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1967 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
1968 // Generate and check a nonstatic field in C2 builds
a61af66fc99e Initial load
duke
parents:
diff changeset
1969 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
1970 # define GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1971 # define CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c) CHECK_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1972 # define ENSURE_C2_FIELD_TYPE_PRESENT(a, b, c) ENSURE_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1973 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
1974 # define GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1975 # define CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1976 # define ENSURE_C2_FIELD_TYPE_PRESENT(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1977 #endif /* COMPILER2 */
a61af66fc99e Initial load
duke
parents:
diff changeset
1978
a61af66fc99e Initial load
duke
parents:
diff changeset
1979 // Generate but do not check a static field in C1 builds
a61af66fc99e Initial load
duke
parents:
diff changeset
1980 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
1981 # define GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1982 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
1983 # define GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1984 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
1985
a61af66fc99e Initial load
duke
parents:
diff changeset
1986 // Generate but do not check a static field in C2 builds
a61af66fc99e Initial load
duke
parents:
diff changeset
1987 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
1988 # define GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c) GENERATE_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1989 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
1990 # define GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY(a, b, c)
a61af66fc99e Initial load
duke
parents:
diff changeset
1991 #endif /* COMPILER2 */
a61af66fc99e Initial load
duke
parents:
diff changeset
1992
a61af66fc99e Initial load
duke
parents:
diff changeset
1993 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1994 // VMTypeEntry macros
a61af66fc99e Initial load
duke
parents:
diff changeset
1995 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1996
a61af66fc99e Initial load
duke
parents:
diff changeset
1997 #define GENERATE_VM_TYPE_ENTRY(type, superclass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
1998 { QUOTE(type), QUOTE(superclass), 0, 0, 0, sizeof(type) },
a61af66fc99e Initial load
duke
parents:
diff changeset
1999
a61af66fc99e Initial load
duke
parents:
diff changeset
2000 #define GENERATE_TOPLEVEL_VM_TYPE_ENTRY(type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2001 { QUOTE(type), NULL, 0, 0, 0, sizeof(type) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2002
a61af66fc99e Initial load
duke
parents:
diff changeset
2003 #define GENERATE_OOP_VM_TYPE_ENTRY(type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2004 { QUOTE(type), NULL, 1, 0, 0, sizeof(type) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2005
a61af66fc99e Initial load
duke
parents:
diff changeset
2006 #define GENERATE_INTEGER_VM_TYPE_ENTRY(type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2007 { QUOTE(type), NULL, 0, 1, 0, sizeof(type) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2008
a61af66fc99e Initial load
duke
parents:
diff changeset
2009 #define GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY(type) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2010 { QUOTE(type), NULL, 0, 1, 1, sizeof(type) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2011
a61af66fc99e Initial load
duke
parents:
diff changeset
2012 #define GENERATE_VM_TYPE_LAST_ENTRY() \
a61af66fc99e Initial load
duke
parents:
diff changeset
2013 { NULL, NULL, 0, 0, 0, 0 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2014
a61af66fc99e Initial load
duke
parents:
diff changeset
2015 #define CHECK_VM_TYPE_ENTRY(type, superclass) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2016 { type* dummyObj = NULL; superclass* dummySuperObj = dummyObj; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2017
a61af66fc99e Initial load
duke
parents:
diff changeset
2018 #define CHECK_VM_TYPE_NO_OP(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2019 #define CHECK_SINGLE_ARG_VM_TYPE_NO_OP(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2020
a61af66fc99e Initial load
duke
parents:
diff changeset
2021 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2022 // Build-specific macros:
a61af66fc99e Initial load
duke
parents:
diff changeset
2023 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2024
a61af66fc99e Initial load
duke
parents:
diff changeset
2025 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
2026 # define GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY(a) GENERATE_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2027 # define CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2028 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2029 # define GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2030 # define CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2031 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2032
a61af66fc99e Initial load
duke
parents:
diff changeset
2033 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
2034 # define GENERATE_C2_VM_TYPE_ENTRY(a, b) GENERATE_VM_TYPE_ENTRY(a, b)
a61af66fc99e Initial load
duke
parents:
diff changeset
2035 # define CHECK_C2_VM_TYPE_ENTRY(a, b) CHECK_VM_TYPE_ENTRY(a, b)
a61af66fc99e Initial load
duke
parents:
diff changeset
2036 # define GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY(a) GENERATE_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2037 # define CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2038 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2039 # define GENERATE_C2_VM_TYPE_ENTRY(a, b)
a61af66fc99e Initial load
duke
parents:
diff changeset
2040 # define CHECK_C2_VM_TYPE_ENTRY(a, b)
a61af66fc99e Initial load
duke
parents:
diff changeset
2041 # define GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2042 # define CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY(a)
a61af66fc99e Initial load
duke
parents:
diff changeset
2043 #endif /* COMPILER2 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2044
a61af66fc99e Initial load
duke
parents:
diff changeset
2045
a61af66fc99e Initial load
duke
parents:
diff changeset
2046 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2047 // VMIntConstantEntry macros
a61af66fc99e Initial load
duke
parents:
diff changeset
2048 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2049
a61af66fc99e Initial load
duke
parents:
diff changeset
2050 #define GENERATE_VM_INT_CONSTANT_ENTRY(name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2051 { QUOTE(name), (int32_t) name },
a61af66fc99e Initial load
duke
parents:
diff changeset
2052
a61af66fc99e Initial load
duke
parents:
diff changeset
2053 #define GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2054 { name, (int32_t) value },
a61af66fc99e Initial load
duke
parents:
diff changeset
2055
a61af66fc99e Initial load
duke
parents:
diff changeset
2056 // This macro generates the sentinel value indicating the end of the list
a61af66fc99e Initial load
duke
parents:
diff changeset
2057 #define GENERATE_VM_INT_CONSTANT_LAST_ENTRY() \
a61af66fc99e Initial load
duke
parents:
diff changeset
2058 { NULL, 0 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2059
a61af66fc99e Initial load
duke
parents:
diff changeset
2060
a61af66fc99e Initial load
duke
parents:
diff changeset
2061 // Generate an int constant for a C1 build
a61af66fc99e Initial load
duke
parents:
diff changeset
2062 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
2063 # define GENERATE_C1_VM_INT_CONSTANT_ENTRY(name) GENERATE_VM_INT_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2064 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2065 # define GENERATE_C1_VM_INT_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2066 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2067
a61af66fc99e Initial load
duke
parents:
diff changeset
2068 // Generate an int constant for a C2 build
a61af66fc99e Initial load
duke
parents:
diff changeset
2069 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
2070 # define GENERATE_C2_VM_INT_CONSTANT_ENTRY(name) GENERATE_VM_INT_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2071 # define GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value) GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value)
a61af66fc99e Initial load
duke
parents:
diff changeset
2072 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2073 # define GENERATE_C2_VM_INT_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2074 # define GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY(name, value)
a61af66fc99e Initial load
duke
parents:
diff changeset
2075 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2076
a61af66fc99e Initial load
duke
parents:
diff changeset
2077 //--------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2078 // VMLongConstantEntry macros
a61af66fc99e Initial load
duke
parents:
diff changeset
2079 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2080
a61af66fc99e Initial load
duke
parents:
diff changeset
2081 #define GENERATE_VM_LONG_CONSTANT_ENTRY(name) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2082 { QUOTE(name), cast_uint64_t(name) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2083
a61af66fc99e Initial load
duke
parents:
diff changeset
2084 #define GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2085 { name, cast_uint64_t(value) },
a61af66fc99e Initial load
duke
parents:
diff changeset
2086
a61af66fc99e Initial load
duke
parents:
diff changeset
2087 // This macro generates the sentinel value indicating the end of the list
a61af66fc99e Initial load
duke
parents:
diff changeset
2088 #define GENERATE_VM_LONG_CONSTANT_LAST_ENTRY() \
a61af66fc99e Initial load
duke
parents:
diff changeset
2089 { NULL, 0 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2090
a61af66fc99e Initial load
duke
parents:
diff changeset
2091 // Generate a long constant for a C1 build
a61af66fc99e Initial load
duke
parents:
diff changeset
2092 #ifdef COMPILER1
a61af66fc99e Initial load
duke
parents:
diff changeset
2093 # define GENERATE_C1_VM_LONG_CONSTANT_ENTRY(name) GENERATE_VM_LONG_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2094 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2095 # define GENERATE_C1_VM_LONG_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2096 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2097
a61af66fc99e Initial load
duke
parents:
diff changeset
2098 // Generate a long constant for a C2 build
a61af66fc99e Initial load
duke
parents:
diff changeset
2099 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
2100 # define GENERATE_C2_VM_LONG_CONSTANT_ENTRY(name) GENERATE_VM_LONG_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2101 # define GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value) GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value)
a61af66fc99e Initial load
duke
parents:
diff changeset
2102 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 # define GENERATE_C2_VM_LONG_CONSTANT_ENTRY(name)
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 # define GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY(name, value)
a61af66fc99e Initial load
duke
parents:
diff changeset
2105 #endif /* COMPILER1 */
a61af66fc99e Initial load
duke
parents:
diff changeset
2106
a61af66fc99e Initial load
duke
parents:
diff changeset
2107 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 // Instantiation of VMStructEntries, VMTypeEntries and VMIntConstantEntries
a61af66fc99e Initial load
duke
parents:
diff changeset
2109 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2110
a61af66fc99e Initial load
duke
parents:
diff changeset
2111 // These initializers are allowed to access private fields in classes
a61af66fc99e Initial load
duke
parents:
diff changeset
2112 // as long as class VMStructs is a friend
a61af66fc99e Initial load
duke
parents:
diff changeset
2113 VMStructEntry VMStructs::localHotSpotVMStructs[] = {
a61af66fc99e Initial load
duke
parents:
diff changeset
2114
a61af66fc99e Initial load
duke
parents:
diff changeset
2115 VM_STRUCTS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2116 GENERATE_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2117 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2118 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2119 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2120 GENERATE_C1_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2121 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2122 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2123 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2124 GENERATE_VM_STRUCT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2125
a61af66fc99e Initial load
duke
parents:
diff changeset
2126 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2127 VM_STRUCTS_PARALLELGC(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2128 GENERATE_STATIC_VM_STRUCT_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2129
a61af66fc99e Initial load
duke
parents:
diff changeset
2130 VM_STRUCTS_CMS(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
187
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
2131 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2132 GENERATE_STATIC_VM_STRUCT_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2133 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2134
a61af66fc99e Initial load
duke
parents:
diff changeset
2135 VM_STRUCTS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2136 GENERATE_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2137 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2138 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2139 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2140 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2141 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2142 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2143 GENERATE_VM_STRUCT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2144
a61af66fc99e Initial load
duke
parents:
diff changeset
2145 VM_STRUCTS_OS_CPU(GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2146 GENERATE_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2147 GENERATE_UNCHECKED_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2148 GENERATE_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2149 GENERATE_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2150 GENERATE_C2_NONSTATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2151 GENERATE_C1_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2152 GENERATE_C2_UNCHECKED_STATIC_VM_STRUCT_ENTRY, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2153 GENERATE_VM_STRUCT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2154 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2155
a61af66fc99e Initial load
duke
parents:
diff changeset
2156 VMTypeEntry VMStructs::localHotSpotVMTypes[] = {
a61af66fc99e Initial load
duke
parents:
diff changeset
2157
a61af66fc99e Initial load
duke
parents:
diff changeset
2158 VM_TYPES(GENERATE_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2159 GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2160 GENERATE_OOP_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2161 GENERATE_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2162 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2163 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2164 GENERATE_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2165 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2166 GENERATE_VM_TYPE_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2167
a61af66fc99e Initial load
duke
parents:
diff changeset
2168 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2169 VM_TYPES_PARALLELGC(GENERATE_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2170 GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2171
a61af66fc99e Initial load
duke
parents:
diff changeset
2172 VM_TYPES_CMS(GENERATE_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2173 GENERATE_TOPLEVEL_VM_TYPE_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2174
a61af66fc99e Initial load
duke
parents:
diff changeset
2175 VM_TYPES_PARNEW(GENERATE_VM_TYPE_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2176 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2177
a61af66fc99e Initial load
duke
parents:
diff changeset
2178 VM_TYPES_CPU(GENERATE_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2179 GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2180 GENERATE_OOP_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2181 GENERATE_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2182 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2183 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2184 GENERATE_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2185 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2186 GENERATE_VM_TYPE_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2187
a61af66fc99e Initial load
duke
parents:
diff changeset
2188 VM_TYPES_OS_CPU(GENERATE_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2189 GENERATE_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2190 GENERATE_OOP_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2191 GENERATE_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2192 GENERATE_UNSIGNED_INTEGER_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2193 GENERATE_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2194 GENERATE_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2195 GENERATE_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2196 GENERATE_VM_TYPE_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2197 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2198
a61af66fc99e Initial load
duke
parents:
diff changeset
2199 VMIntConstantEntry VMStructs::localHotSpotVMIntConstants[] = {
a61af66fc99e Initial load
duke
parents:
diff changeset
2200
a61af66fc99e Initial load
duke
parents:
diff changeset
2201 VM_INT_CONSTANTS(GENERATE_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2202 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2203 GENERATE_C1_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2204 GENERATE_C2_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2205 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2206 GENERATE_VM_INT_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2207
a61af66fc99e Initial load
duke
parents:
diff changeset
2208 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2209 VM_INT_CONSTANTS_CMS(GENERATE_VM_INT_CONSTANT_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2210
a61af66fc99e Initial load
duke
parents:
diff changeset
2211 VM_INT_CONSTANTS_PARNEW(GENERATE_VM_INT_CONSTANT_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2212 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2213
a61af66fc99e Initial load
duke
parents:
diff changeset
2214 VM_INT_CONSTANTS_CPU(GENERATE_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2215 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2216 GENERATE_C1_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2217 GENERATE_C2_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2218 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2219 GENERATE_VM_INT_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2220
a61af66fc99e Initial load
duke
parents:
diff changeset
2221 VM_INT_CONSTANTS_OS_CPU(GENERATE_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2222 GENERATE_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2223 GENERATE_C1_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2224 GENERATE_C2_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2225 GENERATE_C2_PREPROCESSOR_VM_INT_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2226 GENERATE_VM_INT_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2227 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2228
a61af66fc99e Initial load
duke
parents:
diff changeset
2229 VMLongConstantEntry VMStructs::localHotSpotVMLongConstants[] = {
a61af66fc99e Initial load
duke
parents:
diff changeset
2230
a61af66fc99e Initial load
duke
parents:
diff changeset
2231 VM_LONG_CONSTANTS(GENERATE_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2232 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2233 GENERATE_C1_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2234 GENERATE_C2_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2235 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2236 GENERATE_VM_LONG_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2237
a61af66fc99e Initial load
duke
parents:
diff changeset
2238 VM_LONG_CONSTANTS_CPU(GENERATE_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2239 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2240 GENERATE_C1_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2241 GENERATE_C2_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2242 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2243 GENERATE_VM_LONG_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2244
a61af66fc99e Initial load
duke
parents:
diff changeset
2245 VM_LONG_CONSTANTS_OS_CPU(GENERATE_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2246 GENERATE_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2247 GENERATE_C1_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2248 GENERATE_C2_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2249 GENERATE_C2_PREPROCESSOR_VM_LONG_CONSTANT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2250 GENERATE_VM_LONG_CONSTANT_LAST_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2251 };
a61af66fc99e Initial load
duke
parents:
diff changeset
2252
a61af66fc99e Initial load
duke
parents:
diff changeset
2253 // This is used both to check the types of referenced fields and, in
a61af66fc99e Initial load
duke
parents:
diff changeset
2254 // debug builds, to ensure that all of the field types are present.
a61af66fc99e Initial load
duke
parents:
diff changeset
2255 void
a61af66fc99e Initial load
duke
parents:
diff changeset
2256 VMStructs::init() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2257 VM_STRUCTS(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2258 CHECK_STATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2259 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2260 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2261 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2262 CHECK_C1_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2263 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2264 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2265 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2266 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2267
a61af66fc99e Initial load
duke
parents:
diff changeset
2268 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2269 VM_STRUCTS_PARALLELGC(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2270 CHECK_STATIC_VM_STRUCT_ENTRY);
a61af66fc99e Initial load
duke
parents:
diff changeset
2271
a61af66fc99e Initial load
duke
parents:
diff changeset
2272 VM_STRUCTS_CMS(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
187
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
2273 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2274 CHECK_STATIC_VM_STRUCT_ENTRY);
a61af66fc99e Initial load
duke
parents:
diff changeset
2275 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2276
a61af66fc99e Initial load
duke
parents:
diff changeset
2277 VM_STRUCTS_CPU(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2278 CHECK_STATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2279 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2280 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2281 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2282 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2283 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2284 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2285 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2286
a61af66fc99e Initial load
duke
parents:
diff changeset
2287 VM_STRUCTS_OS_CPU(CHECK_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2288 CHECK_STATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2289 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2290 CHECK_VOLATILE_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2291 CHECK_NONPRODUCT_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2292 CHECK_C2_NONSTATIC_VM_STRUCT_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2293 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2294 CHECK_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2295 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2296
a61af66fc99e Initial load
duke
parents:
diff changeset
2297 VM_TYPES(CHECK_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2298 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2299 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2300 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2301 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2302 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2303 CHECK_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2304 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2305 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2306
a61af66fc99e Initial load
duke
parents:
diff changeset
2307 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2308 VM_TYPES_PARALLELGC(CHECK_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2309 CHECK_SINGLE_ARG_VM_TYPE_NO_OP);
a61af66fc99e Initial load
duke
parents:
diff changeset
2310
a61af66fc99e Initial load
duke
parents:
diff changeset
2311 VM_TYPES_CMS(CHECK_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2312 CHECK_SINGLE_ARG_VM_TYPE_NO_OP);
a61af66fc99e Initial load
duke
parents:
diff changeset
2313
a61af66fc99e Initial load
duke
parents:
diff changeset
2314 VM_TYPES_PARNEW(CHECK_VM_TYPE_ENTRY)
a61af66fc99e Initial load
duke
parents:
diff changeset
2315 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2316
a61af66fc99e Initial load
duke
parents:
diff changeset
2317 VM_TYPES_CPU(CHECK_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2318 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2319 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2320 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2321 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2322 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2323 CHECK_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2324 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2325 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2326
a61af66fc99e Initial load
duke
parents:
diff changeset
2327 VM_TYPES_OS_CPU(CHECK_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2328 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2329 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2330 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2331 CHECK_SINGLE_ARG_VM_TYPE_NO_OP,
a61af66fc99e Initial load
duke
parents:
diff changeset
2332 CHECK_C1_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2333 CHECK_C2_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2334 CHECK_C2_TOPLEVEL_VM_TYPE_ENTRY,
a61af66fc99e Initial load
duke
parents:
diff changeset
2335 CHECK_SENTINEL);
a61af66fc99e Initial load
duke
parents:
diff changeset
2336
a61af66fc99e Initial load
duke
parents:
diff changeset
2337 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2338 // Split VM_STRUCTS() invocation into two parts to allow MS VC++ 6.0
a61af66fc99e Initial load
duke
parents:
diff changeset
2339 // to build with the source mounted over SNC3.2. Symptom was that
a61af66fc99e Initial load
duke
parents:
diff changeset
2340 // debug build failed with an internal compiler error. Has been seen
a61af66fc99e Initial load
duke
parents:
diff changeset
2341 // mounting sources from Solaris 2.6 and 2.7 hosts, but so far not
a61af66fc99e Initial load
duke
parents:
diff changeset
2342 // 2.8 hosts. Appears to occur because line is too long.
a61af66fc99e Initial load
duke
parents:
diff changeset
2343 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2344 // If an assertion failure is triggered here it means that an entry
a61af66fc99e Initial load
duke
parents:
diff changeset
2345 // in VMStructs::localHotSpotVMStructs[] was not found in
a61af66fc99e Initial load
duke
parents:
diff changeset
2346 // VMStructs::localHotSpotVMTypes[]. (The assertion itself had to be
a61af66fc99e Initial load
duke
parents:
diff changeset
2347 // made less descriptive because of this above bug -- see the
a61af66fc99e Initial load
duke
parents:
diff changeset
2348 // definition of ENSURE_FIELD_TYPE_PRESENT.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2349 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2350 // NOTE: taken out because this was just not working on everyone's
a61af66fc99e Initial load
duke
parents:
diff changeset
2351 // Solstice NFS setup. If everyone switches to local workspaces on
a61af66fc99e Initial load
duke
parents:
diff changeset
2352 // Win32, we can put this back in.
a61af66fc99e Initial load
duke
parents:
diff changeset
2353 #ifndef _WINDOWS
a61af66fc99e Initial load
duke
parents:
diff changeset
2354 debug_only(VM_STRUCTS(ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2355 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2356 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2357 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2358 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2359 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2360 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2361 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2362 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2363 CHECK_SENTINEL));
a61af66fc99e Initial load
duke
parents:
diff changeset
2364 debug_only(VM_STRUCTS(CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2365 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2366 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2367 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2368 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2369 ENSURE_C1_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2370 ENSURE_C2_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2371 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2372 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2373 CHECK_SENTINEL));
a61af66fc99e Initial load
duke
parents:
diff changeset
2374 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2375 debug_only(VM_STRUCTS_PARALLELGC(ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2376 ENSURE_FIELD_TYPE_PRESENT));
a61af66fc99e Initial load
duke
parents:
diff changeset
2377 debug_only(VM_STRUCTS_CMS(ENSURE_FIELD_TYPE_PRESENT, \
187
790e66e5fbac 6687581: Make CMS work with compressed oops
coleenp
parents: 147
diff changeset
2378 ENSURE_FIELD_TYPE_PRESENT, \
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2379 ENSURE_FIELD_TYPE_PRESENT));
a61af66fc99e Initial load
duke
parents:
diff changeset
2380 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
2381 debug_only(VM_STRUCTS_CPU(ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2382 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2383 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2384 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2385 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2386 ENSURE_C2_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2387 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2388 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2389 CHECK_SENTINEL));
a61af66fc99e Initial load
duke
parents:
diff changeset
2390 debug_only(VM_STRUCTS_OS_CPU(ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2391 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2392 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2393 ENSURE_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2394 ENSURE_NONPRODUCT_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2395 ENSURE_C2_FIELD_TYPE_PRESENT, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2396 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2397 CHECK_NO_OP, \
a61af66fc99e Initial load
duke
parents:
diff changeset
2398 CHECK_SENTINEL));
a61af66fc99e Initial load
duke
parents:
diff changeset
2399 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
2400 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2401
a61af66fc99e Initial load
duke
parents:
diff changeset
2402 extern "C" {
a61af66fc99e Initial load
duke
parents:
diff changeset
2403
a61af66fc99e Initial load
duke
parents:
diff changeset
2404 // see comments on cast_uint64_t at the top of this file
a61af66fc99e Initial load
duke
parents:
diff changeset
2405 #define ASSIGN_CONST_TO_64BIT_VAR(var, expr) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2406 JNIEXPORT uint64_t var = cast_uint64_t(expr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2407 #define ASSIGN_OFFSET_TO_64BIT_VAR(var, type, field) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2408 ASSIGN_CONST_TO_64BIT_VAR(var, offset_of(type, field))
a61af66fc99e Initial load
duke
parents:
diff changeset
2409 #define ASSIGN_STRIDE_TO_64BIT_VAR(var, array) \
a61af66fc99e Initial load
duke
parents:
diff changeset
2410 ASSIGN_CONST_TO_64BIT_VAR(var, (char*)&array[1] - (char*)&array[0])
a61af66fc99e Initial load
duke
parents:
diff changeset
2411
a61af66fc99e Initial load
duke
parents:
diff changeset
2412 JNIEXPORT VMStructEntry* gHotSpotVMStructs = VMStructs::localHotSpotVMStructs;
a61af66fc99e Initial load
duke
parents:
diff changeset
2413 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryTypeNameOffset, VMStructEntry, typeName);
a61af66fc99e Initial load
duke
parents:
diff changeset
2414 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryFieldNameOffset, VMStructEntry, fieldName);
a61af66fc99e Initial load
duke
parents:
diff changeset
2415 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryTypeStringOffset, VMStructEntry, typeString);
a61af66fc99e Initial load
duke
parents:
diff changeset
2416 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryIsStaticOffset, VMStructEntry, isStatic);
a61af66fc99e Initial load
duke
parents:
diff changeset
2417 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryOffsetOffset, VMStructEntry, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2418 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMStructEntryAddressOffset, VMStructEntry, address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2419 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMStructEntryArrayStride, gHotSpotVMStructs);
a61af66fc99e Initial load
duke
parents:
diff changeset
2420 JNIEXPORT VMTypeEntry* gHotSpotVMTypes = VMStructs::localHotSpotVMTypes;
a61af66fc99e Initial load
duke
parents:
diff changeset
2421 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryTypeNameOffset, VMTypeEntry, typeName);
a61af66fc99e Initial load
duke
parents:
diff changeset
2422 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntrySuperclassNameOffset, VMTypeEntry, superclassName);
a61af66fc99e Initial load
duke
parents:
diff changeset
2423 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsOopTypeOffset, VMTypeEntry, isOopType);
a61af66fc99e Initial load
duke
parents:
diff changeset
2424 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsIntegerTypeOffset, VMTypeEntry, isIntegerType);
a61af66fc99e Initial load
duke
parents:
diff changeset
2425 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntryIsUnsignedOffset, VMTypeEntry, isUnsigned);
a61af66fc99e Initial load
duke
parents:
diff changeset
2426 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMTypeEntrySizeOffset, VMTypeEntry, size);
a61af66fc99e Initial load
duke
parents:
diff changeset
2427 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMTypeEntryArrayStride,gHotSpotVMTypes);
a61af66fc99e Initial load
duke
parents:
diff changeset
2428 JNIEXPORT VMIntConstantEntry* gHotSpotVMIntConstants = VMStructs::localHotSpotVMIntConstants;
a61af66fc99e Initial load
duke
parents:
diff changeset
2429 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMIntConstantEntryNameOffset, VMIntConstantEntry, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
2430 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMIntConstantEntryValueOffset, VMIntConstantEntry, value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2431 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMIntConstantEntryArrayStride, gHotSpotVMIntConstants);
a61af66fc99e Initial load
duke
parents:
diff changeset
2432 JNIEXPORT VMLongConstantEntry* gHotSpotVMLongConstants = VMStructs::localHotSpotVMLongConstants;
a61af66fc99e Initial load
duke
parents:
diff changeset
2433 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMLongConstantEntryNameOffset, VMLongConstantEntry, name);
a61af66fc99e Initial load
duke
parents:
diff changeset
2434 ASSIGN_OFFSET_TO_64BIT_VAR(gHotSpotVMLongConstantEntryValueOffset, VMLongConstantEntry, value);
a61af66fc99e Initial load
duke
parents:
diff changeset
2435 ASSIGN_STRIDE_TO_64BIT_VAR(gHotSpotVMLongConstantEntryArrayStride, gHotSpotVMLongConstants);
a61af66fc99e Initial load
duke
parents:
diff changeset
2436 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2437
a61af66fc99e Initial load
duke
parents:
diff changeset
2438 #ifdef ASSERT
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2439 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
2440 {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2441 VMTypeEntry* types = origtypes;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2442 while (types->typeName != NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2443 if (!strcmp(typeName, types->typeName)) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2444 return 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2445 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2446 ++types;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2447 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2448 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2449 size_t len = strlen(typeName);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2450 if (typeName[len-1] == '*') {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2451 char * s = new char[len];
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2452 strncpy(s, typeName, len - 1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2453 s[len-1] = '\0';
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2454 // 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
2455 if (recursiveFindType(origtypes, s, true) == 1) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2456 delete s;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2457 return 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2458 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2459 delete s;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2460 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2461 if (strstr(typeName, "GrowableArray<") == typeName) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2462 const char * start = typeName + strlen("GrowableArray<");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2463 const char * end = strrchr(typeName, '>');
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2464 int len = end - start + 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2465 char * s = new char[len];
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2466 strncpy(s, start, len - 1);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2467 s[len-1] = '\0';
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2468 // 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
2469 if (recursiveFindType(origtypes, s, true) == 1) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2470 delete s;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2471 return 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2472 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2473 delete s;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2474 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2475 if (strstr(typeName, "const ") == typeName) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2476 const char * s = typeName + strlen("const ");
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2477 // 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
2478 if (recursiveFindType(origtypes, s, true) == 1) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2479 return 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2480 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2481 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2482 if (strstr(typeName, " const") == typeName + len - 6) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2483 char * s = strdup(typeName);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2484 s[len - 6] = '\0';
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2485 // 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
2486 if (recursiveFindType(origtypes, s, true) == 1) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2487 return 1;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2488 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2489 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2490 if (!isRecurse) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2491 tty->print_cr("type \"%s\" not found", typeName);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2492 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2493 return 2;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2494 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2495
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2496
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2497 int
a61af66fc99e Initial load
duke
parents:
diff changeset
2498 VMStructs::findType(const char* typeName) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2499 VMTypeEntry* types = gHotSpotVMTypes;
a61af66fc99e Initial load
duke
parents:
diff changeset
2500
2177
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 2119
diff changeset
2501 return recursiveFindType(types, typeName, false);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2502 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2503 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
2504
a61af66fc99e Initial load
duke
parents:
diff changeset
2505 void vmStructs_init() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2506 debug_only(VMStructs::init());
a61af66fc99e Initial load
duke
parents:
diff changeset
2507 }