|
1 /* |
|
2 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. |
|
8 * |
|
9 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 * version 2 for more details (a copy is included in the LICENSE file that |
|
13 * accompanied this code). |
|
14 * |
|
15 * You should have received a copy of the GNU General Public License version |
|
16 * 2 along with this work; if not, write to the Free Software Foundation, |
|
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 * |
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
20 * or visit www.oracle.com if you need additional information or have any |
|
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; |
|
65 narrowKlass _compressed_klass; |
|
66 } _metadata; |
|
67 |
|
68 // Fast access to barrier set. Must be initialized. |
|
69 static BarrierSet* _bs; |
|
70 |
|
71 public: |
|
72 markOop mark() const { return _mark; } |
|
73 markOop* mark_addr() const { return (markOop*) &_mark; } |
|
74 |
|
75 void set_mark(volatile markOop m) { _mark = m; } |
|
76 |
|
77 inline void release_set_mark(markOop m); |
|
78 inline markOop cas_set_mark(markOop new_mark, markOop old_mark); |
|
79 |
|
80 // Used only to re-initialize the mark word (e.g., of promoted |
|
81 // objects during a GC) -- requires a valid klass pointer |
|
82 inline void init_mark(); |
|
83 |
|
84 inline Klass* klass() const; |
|
85 inline Klass* klass_or_null() const volatile; |
|
86 inline Klass* klass_or_null_acquire() const volatile; |
|
87 inline Klass** klass_addr(); |
|
88 inline narrowKlass* compressed_klass_addr(); |
|
89 |
|
90 inline void set_klass(Klass* k); |
|
91 inline void release_set_klass(Klass* k); |
|
92 |
|
93 // For klass field compression |
|
94 inline int klass_gap() const; |
|
95 inline void set_klass_gap(int z); |
|
96 // For when the klass pointer is being used as a linked list "next" field. |
|
97 inline void set_klass_to_list_ptr(oop k); |
|
98 inline oop list_ptr_from_klass(); |
|
99 |
|
100 // size of object header, aligned to platform wordSize |
|
101 static int header_size() { return sizeof(oopDesc)/HeapWordSize; } |
|
102 |
|
103 // Returns whether this is an instance of k or an instance of a subclass of k |
|
104 inline bool is_a(Klass* k) const; |
|
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 Metadata* metadata_field_acquire(int offset) const; |
|
208 inline void release_metadata_field_put(int offset, Metadata* value); |
|
209 |
|
210 inline jbyte byte_field(int offset) const; |
|
211 inline void byte_field_put(int offset, jbyte contents); |
|
212 |
|
213 inline jchar char_field(int offset) const; |
|
214 inline void char_field_put(int offset, jchar contents); |
|
215 |
|
216 inline jboolean bool_field(int offset) const; |
|
217 inline void bool_field_put(int offset, jboolean contents); |
|
218 |
|
219 inline jint int_field(int offset) const; |
|
220 inline void int_field_put(int offset, jint contents); |
|
221 |
|
222 inline jshort short_field(int offset) const; |
|
223 inline void short_field_put(int offset, jshort contents); |
|
224 |
|
225 inline jlong long_field(int offset) const; |
|
226 inline void long_field_put(int offset, jlong contents); |
|
227 |
|
228 inline jfloat float_field(int offset) const; |
|
229 inline void float_field_put(int offset, jfloat contents); |
|
230 |
|
231 inline jdouble double_field(int offset) const; |
|
232 inline void double_field_put(int offset, jdouble contents); |
|
233 |
|
234 inline address address_field(int offset) const; |
|
235 inline void address_field_put(int offset, address contents); |
|
236 |
|
237 inline oop obj_field_acquire(int offset) const; |
|
238 inline void release_obj_field_put(int offset, oop value); |
|
239 |
|
240 inline jbyte byte_field_acquire(int offset) const; |
|
241 inline void release_byte_field_put(int offset, jbyte contents); |
|
242 |
|
243 inline jchar char_field_acquire(int offset) const; |
|
244 inline void release_char_field_put(int offset, jchar contents); |
|
245 |
|
246 inline jboolean bool_field_acquire(int offset) const; |
|
247 inline void release_bool_field_put(int offset, jboolean contents); |
|
248 |
|
249 inline jint int_field_acquire(int offset) const; |
|
250 inline void release_int_field_put(int offset, jint contents); |
|
251 |
|
252 inline jshort short_field_acquire(int offset) const; |
|
253 inline void release_short_field_put(int offset, jshort contents); |
|
254 |
|
255 inline jlong long_field_acquire(int offset) const; |
|
256 inline void release_long_field_put(int offset, jlong contents); |
|
257 |
|
258 inline jfloat float_field_acquire(int offset) const; |
|
259 inline void release_float_field_put(int offset, jfloat contents); |
|
260 |
|
261 inline jdouble double_field_acquire(int offset) const; |
|
262 inline void release_double_field_put(int offset, jdouble contents); |
|
263 |
|
264 inline address address_field_acquire(int offset) const; |
|
265 inline void release_address_field_put(int offset, address contents); |
|
266 |
|
267 // printing functions for VM debugging |
|
268 void print_on(outputStream* st) const; // First level print |
|
269 void print_value_on(outputStream* st) const; // Second level print. |
|
270 void print_address_on(outputStream* st) const; // Address printing |
|
271 |
|
272 // printing on default output stream |
|
273 void print(); |
|
274 void print_value(); |
|
275 void print_address(); |
|
276 |
|
277 // return the print strings |
|
278 char* print_string(); |
|
279 char* print_value_string(); |
|
280 |
|
281 // verification operations |
|
282 void verify_on(outputStream* st); |
|
283 void verify(); |
|
284 |
|
285 // locking operations |
|
286 inline bool is_locked() const; |
|
287 inline bool is_unlocked() const; |
|
288 inline bool has_bias_pattern() const; |
|
289 |
|
290 // asserts and guarantees |
|
291 static bool is_oop(oop obj, bool ignore_mark_word = false); |
|
292 static bool is_oop_or_null(oop obj, bool ignore_mark_word = false); |
|
293 #ifndef PRODUCT |
|
294 inline bool is_unlocked_oop() const; |
|
295 #endif |
|
296 |
|
297 // garbage collection |
|
298 inline bool is_gc_marked() const; |
|
299 |
|
300 inline bool is_scavengable() const; |
|
301 |
|
302 // Forward pointer operations for scavenge |
|
303 inline bool is_forwarded() const; |
|
304 |
|
305 inline void forward_to(oop p); |
|
306 inline bool cas_forward_to(oop p, markOop compare); |
|
307 |
|
308 #if INCLUDE_ALL_GCS |
|
309 // Like "forward_to", but inserts the forwarding pointer atomically. |
|
310 // Exactly one thread succeeds in inserting the forwarding pointer, and |
|
311 // this call returns "NULL" for that thread; any other thread has the |
|
312 // value of the forwarding pointer returned and does not modify "this". |
|
313 inline oop forward_to_atomic(oop p); |
|
314 #endif // INCLUDE_ALL_GCS |
|
315 |
|
316 inline oop forwardee() const; |
|
317 |
|
318 // Age of object during scavenge |
|
319 inline uint age() const; |
|
320 inline void incr_age(); |
|
321 |
|
322 // mark-sweep support |
|
323 void follow_body(int begin, int end); |
|
324 |
|
325 // Fast access to barrier set |
|
326 static BarrierSet* bs() { return _bs; } |
|
327 static void set_bs(BarrierSet* bs) { _bs = bs; } |
|
328 |
|
329 // Garbage Collection support |
|
330 |
|
331 #if INCLUDE_ALL_GCS |
|
332 // Parallel Compact |
|
333 inline void pc_follow_contents(ParCompactionManager* cm); |
|
334 inline void pc_update_contents(ParCompactionManager* cm); |
|
335 // Parallel Scavenge |
|
336 inline void ps_push_contents(PSPromotionManager* pm); |
|
337 #endif |
|
338 |
|
339 |
|
340 // iterators, returns size of object |
|
341 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ |
|
342 inline void oop_iterate(OopClosureType* blk); \ |
|
343 inline void oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr. |
|
344 |
|
345 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL) |
|
346 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL) |
|
347 |
|
348 #define OOP_ITERATE_SIZE_DECL(OopClosureType, nv_suffix) \ |
|
349 inline int oop_iterate_size(OopClosureType* blk); \ |
|
350 inline int oop_iterate_size(OopClosureType* blk, MemRegion mr); // Only in mr. |
|
351 |
|
352 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_SIZE_DECL) |
|
353 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_SIZE_DECL) |
|
354 |
|
355 |
|
356 #if INCLUDE_ALL_GCS |
|
357 |
|
358 #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ |
|
359 inline void oop_iterate_backwards(OopClosureType* blk); |
|
360 |
|
361 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL) |
|
362 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL) |
|
363 |
|
364 #endif // INCLUDE_ALL_GCS |
|
365 |
|
366 inline int oop_iterate_no_header(OopClosure* bk); |
|
367 inline int oop_iterate_no_header(OopClosure* bk, MemRegion mr); |
|
368 |
|
369 // identity hash; returns the identity hash key (computes it if necessary) |
|
370 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a |
|
371 // safepoint if called on a biased object. Calling code must be aware of that. |
|
372 inline intptr_t identity_hash(); |
|
373 intptr_t slow_identity_hash(); |
|
374 |
|
375 // Alternate hashing code if string table is rehashed |
|
376 unsigned int new_hash(juint seed); |
|
377 |
|
378 // marks are forwarded to stack when object is locked |
|
379 inline bool has_displaced_mark() const; |
|
380 inline markOop displaced_mark() const; |
|
381 inline void set_displaced_mark(markOop m); |
|
382 |
|
383 static bool has_klass_gap(); |
|
384 |
|
385 // for code generation |
|
386 static int mark_offset_in_bytes() { return offset_of(oopDesc, _mark); } |
|
387 static int klass_offset_in_bytes() { return offset_of(oopDesc, _metadata._klass); } |
|
388 static int klass_gap_offset_in_bytes() { |
|
389 assert(has_klass_gap(), "only applicable to compressed klass pointers"); |
|
390 return klass_offset_in_bytes() + sizeof(narrowKlass); |
|
391 } |
|
392 |
|
393 static bool is_archive_object(oop p) NOT_CDS_JAVA_HEAP_RETURN_(false); |
|
394 }; |
|
395 |
|
396 #endif // SHARE_VM_OOPS_OOP_HPP |