annotate src/share/vm/runtime/vmStructs.cpp @ 1721:413ad0331a0c

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