21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_OOPS_OOP_HPP
26 #define SHARE_VM_OOPS_OOP_HPP
27
28 #include "gc/shared/specialized_oop_closures.hpp"
29 #include "memory/iterator.hpp"
30 #include "memory/memRegion.hpp"
31 #include "oops/metadata.hpp"
32 #include "utilities/macros.hpp"
33
34 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe
35 // the format of Java objects so the fields can be accessed from C++.
36 // oopDesc is abstract.
37 // (see oopHierarchy for complete oop class hierarchy)
38 //
39 // no virtual functions allowed
40
41 // store into oop with store check
42 template <class T> inline void oop_store(T* p, oop v);
43 template <class T> inline void oop_store(volatile T* p, oop v);
44
45 extern bool always_do_update_barrier;
46
47 // Forward declarations.
48 class OopClosure;
49 class ScanClosure;
50 class FastScanClosure;
51 class FilteringClosure;
52 class BarrierSet;
53 class CMSIsAliveClosure;
54
55 class PSPromotionManager;
56 class ParCompactionManager;
57
58 class oopDesc {
59 friend class VMStructs;
60 friend class JVMCIVMStructs;
61 private:
62 volatile markOop _mark;
63 union _metadata {
64 Klass* _klass;
105
106 // Returns the actual oop size of the object
107 inline int size();
108
109 // Sometimes (for complicated concurrency-related reasons), it is useful
110 // to be able to figure out the size of an object knowing its klass.
111 inline int size_given_klass(Klass* klass);
112
113 // type test operations (inlined in oop.inline.hpp)
114 inline bool is_instance() const;
115 inline bool is_array() const;
116 inline bool is_objArray() const;
117 inline bool is_typeArray() const;
118
119 // type test operations that don't require inclusion of oop.inline.hpp.
120 bool is_instance_noinline() const;
121 bool is_array_noinline() const;
122 bool is_objArray_noinline() const;
123 bool is_typeArray_noinline() const;
124
125 private:
126 // field addresses in oop
127 inline void* field_base(int offset) const;
128
129 inline jbyte* byte_field_addr(int offset) const;
130 inline jchar* char_field_addr(int offset) const;
131 inline jboolean* bool_field_addr(int offset) const;
132 inline jint* int_field_addr(int offset) const;
133 inline jshort* short_field_addr(int offset) const;
134 inline jlong* long_field_addr(int offset) const;
135 inline jfloat* float_field_addr(int offset) const;
136 inline jdouble* double_field_addr(int offset) const;
137 inline Metadata** metadata_field_addr(int offset) const;
138
139 public:
140 // Need this as public for garbage collection.
141 template <class T> inline T* obj_field_addr(int offset) const;
142
143 // Needed for javaClasses
144 inline address* address_field_addr(int offset) const;
145
146 inline static bool is_null(oop obj) { return obj == NULL; }
147 inline static bool is_null(narrowOop obj) { return obj == 0; }
148
149 // Decode an oop pointer from a narrowOop if compressed.
150 // These are overloaded for oop and narrowOop as are the other functions
151 // below so that they can be called in template functions.
152 static inline oop decode_heap_oop_not_null(oop v) { return v; }
153 static inline oop decode_heap_oop_not_null(narrowOop v);
154 static inline oop decode_heap_oop(oop v) { return v; }
155 static inline oop decode_heap_oop(narrowOop v);
156
157 // Encode an oop pointer to a narrow oop. The or_null versions accept
158 // null oop pointer, others do not in order to eliminate the
159 // null checking branches.
160 static inline narrowOop encode_heap_oop_not_null(oop v);
161 static inline narrowOop encode_heap_oop(oop v);
162
163 // Load an oop out of the Java heap as is without decoding.
164 // Called by GC to check for null before decoding.
165 static inline narrowOop load_heap_oop(narrowOop* p) { return *p; }
166 static inline oop load_heap_oop(oop* p) { return *p; }
167
168 // Load an oop out of Java heap and decode it to an uncompressed oop.
169 static inline oop load_decode_heap_oop_not_null(narrowOop* p);
170 static inline oop load_decode_heap_oop_not_null(oop* p) { return *p; }
171 static inline oop load_decode_heap_oop(narrowOop* p);
172 static inline oop load_decode_heap_oop(oop* p) { return *p; }
173
174 // Store already encoded heap oop into the heap.
175 static inline void store_heap_oop(narrowOop* p, narrowOop v) { *p = v; }
176 static inline void store_heap_oop(oop* p, oop v) { *p = v; }
177
178 // Encode oop if UseCompressedOops and store into the heap.
179 static inline void encode_store_heap_oop_not_null(narrowOop* p, oop v);
180 static inline void encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; }
181 static inline void encode_store_heap_oop(narrowOop* p, oop v);
182 static inline void encode_store_heap_oop(oop* p, oop v) { *p = v; }
183
184 static inline void release_store_heap_oop(volatile narrowOop* p, narrowOop v);
185 static inline void release_store_heap_oop(volatile oop* p, oop v);
186
187 static inline void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v);
188 static inline void release_encode_store_heap_oop_not_null(volatile oop* p, oop v);
189 static inline void release_encode_store_heap_oop(volatile narrowOop* p, oop v);
190 static inline void release_encode_store_heap_oop(volatile oop* p, oop v);
191
192 static inline oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest);
193 static inline oop atomic_compare_exchange_oop(oop exchange_value,
194 volatile HeapWord *dest,
195 oop compare_value,
196 bool prebarrier = false);
197
198 // Access to fields in a instanceOop through these methods.
199 inline oop obj_field(int offset) const;
200 inline void obj_field_put(int offset, oop value);
201 inline void obj_field_put_raw(int offset, oop value);
202 inline void obj_field_put_volatile(int offset, oop value);
203
204 inline Metadata* metadata_field(int offset) const;
205 inline void metadata_field_put(int offset, Metadata* value);
206
207 inline jbyte byte_field(int offset) const;
208 inline void byte_field_put(int offset, jbyte contents);
209
210 inline jchar char_field(int offset) const;
211 inline void char_field_put(int offset, jchar contents);
212
213 inline jboolean bool_field(int offset) const;
214 inline void bool_field_put(int offset, jboolean contents);
215
216 inline jint int_field(int offset) const;
217 inline void int_field_put(int offset, jint contents);
218
219 inline jshort short_field(int offset) const;
220 inline void short_field_put(int offset, jshort contents);
221
222 inline jlong long_field(int offset) const;
223 inline void long_field_put(int offset, jlong contents);
224
225 inline jfloat float_field(int offset) const;
226 inline void float_field_put(int offset, jfloat contents);
227
228 inline jdouble double_field(int offset) const;
229 inline void double_field_put(int offset, jdouble contents);
230
231 inline address address_field(int offset) const;
232 inline void address_field_put(int offset, address contents);
233
234 inline oop obj_field_acquire(int offset) const;
235 inline void release_obj_field_put(int offset, oop value);
236
237 inline jbyte byte_field_acquire(int offset) const;
238 inline void release_byte_field_put(int offset, jbyte contents);
239
240 inline jchar char_field_acquire(int offset) const;
241 inline void release_char_field_put(int offset, jchar contents);
242
243 inline jboolean bool_field_acquire(int offset) const;
244 inline void release_bool_field_put(int offset, jboolean contents);
245
246 inline jint int_field_acquire(int offset) const;
247 inline void release_int_field_put(int offset, jint contents);
248
249 inline jshort short_field_acquire(int offset) const;
250 inline void release_short_field_put(int offset, jshort contents);
251
252 inline jlong long_field_acquire(int offset) const;
253 inline void release_long_field_put(int offset, jlong contents);
254
255 inline jfloat float_field_acquire(int offset) const;
256 inline void release_float_field_put(int offset, jfloat contents);
257
258 inline jdouble double_field_acquire(int offset) const;
259 inline void release_double_field_put(int offset, jdouble contents);
260
261 inline address address_field_acquire(int offset) const;
262 inline void release_address_field_put(int offset, address contents);
263
264 // printing functions for VM debugging
265 void print_on(outputStream* st) const; // First level print
266 void print_value_on(outputStream* st) const; // Second level print.
267 void print_address_on(outputStream* st) const; // Address printing
268
269 // printing on default output stream
270 void print();
271 void print_value();
272 void print_address();
273
274 // return the print strings
275 char* print_string();
276 char* print_value_string();
277
278 // verification operations
279 void verify_on(outputStream* st);
280 void verify();
281
282 // locking operations
|
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_OOPS_OOP_HPP
26 #define SHARE_VM_OOPS_OOP_HPP
27
28 #include "gc/shared/specialized_oop_closures.hpp"
29 #include "memory/iterator.hpp"
30 #include "memory/memRegion.hpp"
31 #include "oops/metadata.hpp"
32 #include "utilities/macros.hpp"
33
34 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe
35 // the format of Java objects so the fields can be accessed from C++.
36 // oopDesc is abstract.
37 // (see oopHierarchy for complete oop class hierarchy)
38 //
39 // no virtual functions allowed
40
41 extern bool always_do_update_barrier;
42
43 // Forward declarations.
44 class OopClosure;
45 class ScanClosure;
46 class FastScanClosure;
47 class FilteringClosure;
48 class BarrierSet;
49 class CMSIsAliveClosure;
50
51 class PSPromotionManager;
52 class ParCompactionManager;
53
54 class oopDesc {
55 friend class VMStructs;
56 friend class JVMCIVMStructs;
57 private:
58 volatile markOop _mark;
59 union _metadata {
60 Klass* _klass;
101
102 // Returns the actual oop size of the object
103 inline int size();
104
105 // Sometimes (for complicated concurrency-related reasons), it is useful
106 // to be able to figure out the size of an object knowing its klass.
107 inline int size_given_klass(Klass* klass);
108
109 // type test operations (inlined in oop.inline.hpp)
110 inline bool is_instance() const;
111 inline bool is_array() const;
112 inline bool is_objArray() const;
113 inline bool is_typeArray() const;
114
115 // type test operations that don't require inclusion of oop.inline.hpp.
116 bool is_instance_noinline() const;
117 bool is_array_noinline() const;
118 bool is_objArray_noinline() const;
119 bool is_typeArray_noinline() const;
120
121 protected:
122 inline oop oop_base() const { return const_cast<oopDesc*>(this); }
123
124 private:
125 // field addresses in oop
126 inline void* field_base(int offset) const;
127
128 inline jbyte* byte_field_addr(int offset) const;
129 inline jchar* char_field_addr(int offset) const;
130 inline jboolean* bool_field_addr(int offset) const;
131 inline jint* int_field_addr(int offset) const;
132 inline jshort* short_field_addr(int offset) const;
133 inline jlong* long_field_addr(int offset) const;
134 inline jfloat* float_field_addr(int offset) const;
135 inline jdouble* double_field_addr(int offset) const;
136 inline Metadata** metadata_field_addr(int offset) const;
137
138 public:
139 // Need this as public for garbage collection.
140 template <class T> inline T* obj_field_addr(int offset) const;
141
142 // Needed for javaClasses
143 inline address* address_field_addr(int offset) const;
144
145 inline static bool is_null(oop obj) { return obj == NULL; }
146 inline static bool is_null(narrowOop obj) { return obj == 0; }
147
148 // Decode an oop pointer from a narrowOop if compressed.
149 // These are overloaded for oop and narrowOop as are the other functions
150 // below so that they can be called in template functions.
151 static inline oop decode_heap_oop_not_null(oop v) { return v; }
152 static inline oop decode_heap_oop_not_null(narrowOop v);
153 static inline oop decode_heap_oop(oop v) { return v; }
154 static inline oop decode_heap_oop(narrowOop v);
155
156 // Encode an oop pointer to a narrow oop. The or_null versions accept
157 // null oop pointer, others do not in order to eliminate the
158 // null checking branches.
159 static inline narrowOop encode_heap_oop_not_null(oop v);
160 static inline narrowOop encode_heap_oop(oop v);
161
162 // Load an oop out of the Java heap as is without decoding.
163 // Called by GC to check for null before decoding.
164 static inline narrowOop load_heap_oop(narrowOop* p);
165 static inline oop load_heap_oop(oop* p);
166
167 // Load an oop out of Java heap and decode it to an uncompressed oop.
168 static inline oop load_decode_heap_oop_not_null(narrowOop* p);
169 static inline oop load_decode_heap_oop_not_null(oop* p);
170 static inline oop load_decode_heap_oop(narrowOop* p);
171 static inline oop load_decode_heap_oop(oop* p);
172
173 // Store already encoded heap oop into the heap.
174 static inline void store_heap_oop(narrowOop* p, narrowOop v);
175 static inline void store_heap_oop(oop* p, oop v);
176
177 // Encode oop if UseCompressedOops and store into the heap.
178 static inline void encode_store_heap_oop_not_null(narrowOop* p, oop v);
179 static inline void encode_store_heap_oop_not_null(oop* p, oop v);
180 static inline void encode_store_heap_oop(narrowOop* p, oop v);
181 static inline void encode_store_heap_oop(oop* p, oop v);
182
183 static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest);
184 static oop atomic_compare_exchange_oop(oop exchange_value,
185 volatile HeapWord *dest,
186 oop compare_value);
187
188 // Access to fields in a instanceOop through these methods.
189 oop obj_field(int offset) const;
190 void obj_field_put(int offset, oop value);
191 void obj_field_put_raw(int offset, oop value);
192 void obj_field_put_volatile(int offset, oop value);
193
194 Metadata* metadata_field(int offset) const;
195 void metadata_field_put(int offset, Metadata* value);
196
197 jbyte byte_field(int offset) const;
198 void byte_field_put(int offset, jbyte contents);
199
200 jchar char_field(int offset) const;
201 void char_field_put(int offset, jchar contents);
202
203 jboolean bool_field(int offset) const;
204 void bool_field_put(int offset, jboolean contents);
205
206 jint int_field(int offset) const;
207 void int_field_put(int offset, jint contents);
208
209 jshort short_field(int offset) const;
210 void short_field_put(int offset, jshort contents);
211
212 jlong long_field(int offset) const;
213 void long_field_put(int offset, jlong contents);
214
215 jfloat float_field(int offset) const;
216 void float_field_put(int offset, jfloat contents);
217
218 jdouble double_field(int offset) const;
219 void double_field_put(int offset, jdouble contents);
220
221 address address_field(int offset) const;
222 void address_field_put(int offset, address contents);
223
224 oop obj_field_acquire(int offset) const;
225 void release_obj_field_put(int offset, oop value);
226
227 jbyte byte_field_acquire(int offset) const;
228 void release_byte_field_put(int offset, jbyte contents);
229
230 jchar char_field_acquire(int offset) const;
231 void release_char_field_put(int offset, jchar contents);
232
233 jboolean bool_field_acquire(int offset) const;
234 void release_bool_field_put(int offset, jboolean contents);
235
236 jint int_field_acquire(int offset) const;
237 void release_int_field_put(int offset, jint contents);
238
239 jshort short_field_acquire(int offset) const;
240 void release_short_field_put(int offset, jshort contents);
241
242 jlong long_field_acquire(int offset) const;
243 void release_long_field_put(int offset, jlong contents);
244
245 jfloat float_field_acquire(int offset) const;
246 void release_float_field_put(int offset, jfloat contents);
247
248 jdouble double_field_acquire(int offset) const;
249 void release_double_field_put(int offset, jdouble contents);
250
251 address address_field_acquire(int offset) const;
252 void release_address_field_put(int offset, address contents);
253
254 // printing functions for VM debugging
255 void print_on(outputStream* st) const; // First level print
256 void print_value_on(outputStream* st) const; // Second level print.
257 void print_address_on(outputStream* st) const; // Address printing
258
259 // printing on default output stream
260 void print();
261 void print_value();
262 void print_address();
263
264 // return the print strings
265 char* print_string();
266 char* print_value_string();
267
268 // verification operations
269 void verify_on(outputStream* st);
270 void verify();
271
272 // locking operations
|