26 #define SHARE_VM_OOPS_OOP_HPP |
26 #define SHARE_VM_OOPS_OOP_HPP |
27 |
27 |
28 #include "memory/iterator.hpp" |
28 #include "memory/iterator.hpp" |
29 #include "memory/memRegion.hpp" |
29 #include "memory/memRegion.hpp" |
30 #include "memory/specialized_oop_closures.hpp" |
30 #include "memory/specialized_oop_closures.hpp" |
|
31 #include "oops/metadata.hpp" |
31 #include "utilities/top.hpp" |
32 #include "utilities/top.hpp" |
32 |
33 |
33 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe |
34 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe |
34 // the format of Java objects so the fields can be accessed from C++. |
35 // the format of Java objects so the fields can be accessed from C++. |
35 // oopDesc is abstract. |
36 // oopDesc is abstract. |
38 // no virtual functions allowed |
39 // no virtual functions allowed |
39 |
40 |
40 // store into oop with store check |
41 // store into oop with store check |
41 template <class T> void oop_store(T* p, oop v); |
42 template <class T> void oop_store(T* p, oop v); |
42 template <class T> void oop_store(volatile T* p, oop v); |
43 template <class T> void oop_store(volatile T* p, oop v); |
43 |
|
44 // store into oop without store check |
|
45 template <class T> void oop_store_without_check(T* p, oop v); |
|
46 template <class T> void oop_store_without_check(volatile T* p, oop v); |
|
47 |
44 |
48 extern bool always_do_update_barrier; |
45 extern bool always_do_update_barrier; |
49 |
46 |
50 // Forward declarations. |
47 // Forward declarations. |
51 class OopClosure; |
48 class OopClosure; |
61 class oopDesc { |
58 class oopDesc { |
62 friend class VMStructs; |
59 friend class VMStructs; |
63 private: |
60 private: |
64 volatile markOop _mark; |
61 volatile markOop _mark; |
65 union _metadata { |
62 union _metadata { |
66 wideKlassOop _klass; |
63 Klass* _klass; |
67 narrowOop _compressed_klass; |
64 narrowOop _compressed_klass; |
68 } _metadata; |
65 } _metadata; |
69 |
66 |
70 // Fast access to barrier set. Must be initialized. |
67 // Fast access to barrier set. Must be initialized. |
71 static BarrierSet* _bs; |
68 static BarrierSet* _bs; |
72 |
69 |
73 public: |
70 public: |
74 enum ConcSafeType { |
|
75 IsUnsafeConc = false, |
|
76 IsSafeConc = true |
|
77 }; |
|
78 |
|
79 markOop mark() const { return _mark; } |
71 markOop mark() const { return _mark; } |
80 markOop* mark_addr() const { return (markOop*) &_mark; } |
72 markOop* mark_addr() const { return (markOop*) &_mark; } |
81 |
73 |
82 void set_mark(volatile markOop m) { _mark = m; } |
74 void set_mark(volatile markOop m) { _mark = m; } |
83 |
75 |
86 |
78 |
87 // Used only to re-initialize the mark word (e.g., of promoted |
79 // Used only to re-initialize the mark word (e.g., of promoted |
88 // objects during a GC) -- requires a valid klass pointer |
80 // objects during a GC) -- requires a valid klass pointer |
89 void init_mark(); |
81 void init_mark(); |
90 |
82 |
91 klassOop klass() const; |
83 Klass* klass() const; |
92 klassOop klass_or_null() const volatile; |
84 Klass* klass_or_null() const volatile; |
93 oop* klass_addr(); |
85 Klass** klass_addr(); |
94 narrowOop* compressed_klass_addr(); |
86 narrowOop* compressed_klass_addr(); |
95 |
87 |
96 void set_klass(klassOop k); |
88 void set_klass(Klass* k); |
97 |
89 |
98 // For klass field compression |
90 // For klass field compression |
99 int klass_gap() const; |
91 int klass_gap() const; |
100 void set_klass_gap(int z); |
92 void set_klass_gap(int z); |
101 // For when the klass pointer is being used as a linked list "next" field. |
93 // For when the klass pointer is being used as a linked list "next" field. |
102 void set_klass_to_list_ptr(oop k); |
94 void set_klass_to_list_ptr(oop k); |
|
95 oop list_ptr_from_klass(); |
103 |
96 |
104 // size of object header, aligned to platform wordSize |
97 // size of object header, aligned to platform wordSize |
105 static int header_size() { return sizeof(oopDesc)/HeapWordSize; } |
98 static int header_size() { return sizeof(oopDesc)/HeapWordSize; } |
106 |
99 |
107 Klass* blueprint() const; |
|
108 |
|
109 // Returns whether this is an instance of k or an instance of a subclass of k |
100 // Returns whether this is an instance of k or an instance of a subclass of k |
110 bool is_a(klassOop k) const; |
101 bool is_a(Klass* k) const; |
111 |
102 |
112 // Returns the actual oop size of the object |
103 // Returns the actual oop size of the object |
113 int size(); |
104 int size(); |
114 |
105 |
115 // Sometimes (for complicated concurrency-related reasons), it is useful |
106 // Sometimes (for complicated concurrency-related reasons), it is useful |
116 // to be able to figure out the size of an object knowing its klass. |
107 // to be able to figure out the size of an object knowing its klass. |
117 int size_given_klass(Klass* klass); |
108 int size_given_klass(Klass* klass); |
118 |
|
119 // Some perm gen objects are not parseble immediately after |
|
120 // installation of their klass pointer. |
|
121 bool is_parsable(); |
|
122 |
|
123 // Some perm gen objects that have been allocated and initialized |
|
124 // can be changed by the VM when not at a safe point (class rededfinition |
|
125 // is an example). Such objects should not be examined by the |
|
126 // concurrent processing of a garbage collector if is_conc_safe() |
|
127 // returns false. |
|
128 bool is_conc_safe(); |
|
129 |
109 |
130 // type test operations (inlined in oop.inline.h) |
110 // type test operations (inlined in oop.inline.h) |
131 bool is_instance() const; |
111 bool is_instance() const; |
132 bool is_instanceMirror() const; |
112 bool is_instanceMirror() const; |
133 bool is_instanceRef() const; |
113 bool is_instanceRef() const; |
134 bool is_array() const; |
114 bool is_array() const; |
135 bool is_objArray() const; |
115 bool is_objArray() const; |
136 bool is_klass() const; |
|
137 bool is_thread() const; |
|
138 bool is_method() const; |
|
139 bool is_constMethod() const; |
|
140 bool is_methodData() const; |
|
141 bool is_constantPool() const; |
|
142 bool is_constantPoolCache() const; |
|
143 bool is_typeArray() const; |
116 bool is_typeArray() const; |
144 bool is_javaArray() const; |
|
145 bool is_compiledICHolder() const; |
|
146 |
117 |
147 private: |
118 private: |
148 // field addresses in oop |
119 // field addresses in oop |
149 void* field_base(int offset) const; |
120 void* field_base(int offset) const; |
150 |
121 |
154 jint* int_field_addr(int offset) const; |
125 jint* int_field_addr(int offset) const; |
155 jshort* short_field_addr(int offset) const; |
126 jshort* short_field_addr(int offset) const; |
156 jlong* long_field_addr(int offset) const; |
127 jlong* long_field_addr(int offset) const; |
157 jfloat* float_field_addr(int offset) const; |
128 jfloat* float_field_addr(int offset) const; |
158 jdouble* double_field_addr(int offset) const; |
129 jdouble* double_field_addr(int offset) const; |
159 address* address_field_addr(int offset) const; |
130 Metadata** metadata_field_addr(int offset) const; |
160 |
131 |
161 public: |
132 public: |
162 // Need this as public for garbage collection. |
133 // Need this as public for garbage collection. |
163 template <class T> T* obj_field_addr(int offset) const; |
134 template <class T> T* obj_field_addr(int offset) const; |
164 |
135 |
|
136 // Needed for javaClasses |
|
137 address* address_field_addr(int offset) const; |
|
138 |
165 static bool is_null(oop obj); |
139 static bool is_null(oop obj); |
166 static bool is_null(narrowOop obj); |
140 static bool is_null(narrowOop obj); |
|
141 static bool is_null(Klass* obj); |
167 |
142 |
168 // Decode an oop pointer from a narrowOop if compressed. |
143 // Decode an oop pointer from a narrowOop if compressed. |
169 // These are overloaded for oop and narrowOop as are the other functions |
144 // These are overloaded for oop and narrowOop as are the other functions |
170 // below so that they can be called in template functions. |
145 // below so that they can be called in template functions. |
171 static oop decode_heap_oop_not_null(oop v); |
146 static oop decode_heap_oop_not_null(oop v); |
208 static void release_encode_store_heap_oop(volatile oop* p, oop v); |
183 static void release_encode_store_heap_oop(volatile oop* p, oop v); |
209 |
184 |
210 static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest); |
185 static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest); |
211 static oop atomic_compare_exchange_oop(oop exchange_value, |
186 static oop atomic_compare_exchange_oop(oop exchange_value, |
212 volatile HeapWord *dest, |
187 volatile HeapWord *dest, |
213 oop compare_value); |
188 oop compare_value, |
|
189 bool prebarrier = false); |
|
190 |
|
191 // klass encoding for klass pointer in objects. |
|
192 static narrowOop encode_klass_not_null(Klass* v); |
|
193 static narrowOop encode_klass(Klass* v); |
|
194 |
|
195 static Klass* decode_klass_not_null(narrowOop v); |
|
196 static Klass* decode_klass(narrowOop v); |
214 |
197 |
215 // Access to fields in a instanceOop through these methods. |
198 // Access to fields in a instanceOop through these methods. |
216 oop obj_field(int offset) const; |
199 oop obj_field(int offset) const; |
217 volatile oop obj_field_volatile(int offset) const; |
200 volatile oop obj_field_volatile(int offset) const; |
218 void obj_field_put(int offset, oop value); |
201 void obj_field_put(int offset, oop value); |
219 void obj_field_put_raw(int offset, oop value); |
202 void obj_field_put_raw(int offset, oop value); |
220 void obj_field_put_volatile(int offset, oop value); |
203 void obj_field_put_volatile(int offset, oop value); |
221 |
204 |
|
205 Metadata* metadata_field(int offset) const; |
|
206 void metadata_field_put(int offset, Metadata* value); |
|
207 |
222 jbyte byte_field(int offset) const; |
208 jbyte byte_field(int offset) const; |
223 void byte_field_put(int offset, jbyte contents); |
209 void byte_field_put(int offset, jbyte contents); |
224 |
210 |
225 jchar char_field(int offset) const; |
211 jchar char_field(int offset) const; |
226 void char_field_put(int offset, jchar contents); |
212 void char_field_put(int offset, jchar contents); |
291 char* print_value_string(); |
277 char* print_value_string(); |
292 |
278 |
293 // verification operations |
279 // verification operations |
294 void verify_on(outputStream* st); |
280 void verify_on(outputStream* st); |
295 void verify(); |
281 void verify(); |
296 |
|
297 // tells whether this oop is partially constructed (gc during class loading) |
|
298 bool partially_loaded(); |
|
299 void set_partially_loaded(); |
|
300 |
282 |
301 // locking operations |
283 // locking operations |
302 bool is_locked() const; |
284 bool is_locked() const; |
303 bool is_unlocked() const; |
285 bool is_unlocked() const; |
304 bool has_bias_pattern() const; |
286 bool has_bias_pattern() const; |
313 // garbage collection |
295 // garbage collection |
314 bool is_gc_marked() const; |
296 bool is_gc_marked() const; |
315 // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL |
297 // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL |
316 // reference field in "this". |
298 // reference field in "this". |
317 void follow_contents(void); |
299 void follow_contents(void); |
318 void follow_header(void); |
|
319 |
300 |
320 #ifndef SERIALGC |
301 #ifndef SERIALGC |
321 // Parallel Scavenge |
302 // Parallel Scavenge |
322 void push_contents(PSPromotionManager* pm); |
303 void push_contents(PSPromotionManager* pm); |
323 |
304 |
324 // Parallel Old |
305 // Parallel Old |
325 void update_contents(ParCompactionManager* cm); |
306 void update_contents(ParCompactionManager* cm); |
326 |
307 |
327 void follow_contents(ParCompactionManager* cm); |
308 void follow_contents(ParCompactionManager* cm); |
328 void follow_header(ParCompactionManager* cm); |
|
329 #endif // SERIALGC |
309 #endif // SERIALGC |
330 |
310 |
331 bool is_perm() const; |
|
332 bool is_perm_or_null() const; |
|
333 bool is_scavengable() const; |
311 bool is_scavengable() const; |
334 bool is_shared() const; |
|
335 bool is_shared_readonly() const; |
|
336 bool is_shared_readwrite() const; |
|
337 |
312 |
338 // Forward pointer operations for scavenge |
313 // Forward pointer operations for scavenge |
339 bool is_forwarded() const; |
314 bool is_forwarded() const; |
340 |
315 |
341 void forward_to(oop p); |
316 void forward_to(oop p); |
387 |
361 |
388 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL) |
362 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL) |
389 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL) |
363 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL) |
390 #endif |
364 #endif |
391 |
365 |
392 void oop_iterate_header(OopClosure* blk); |
366 int oop_iterate_no_header(OopClosure* bk); |
393 void oop_iterate_header(OopClosure* blk, MemRegion mr); |
367 int oop_iterate_no_header(OopClosure* bk, MemRegion mr); |
394 |
368 |
395 // identity hash; returns the identity hash key (computes it if necessary) |
369 // identity hash; returns the identity hash key (computes it if necessary) |
396 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a |
370 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a |
397 // safepoint if called on a biased object. Calling code must be aware of that. |
371 // safepoint if called on a biased object. Calling code must be aware of that. |
398 intptr_t identity_hash(); |
372 intptr_t identity_hash(); |
399 intptr_t slow_identity_hash(); |
373 intptr_t slow_identity_hash(); |
400 |
374 |
|
375 // Alternate hashing code if string table is rehashed |
|
376 unsigned int new_hash(jint seed); |
|
377 |
401 // marks are forwarded to stack when object is locked |
378 // marks are forwarded to stack when object is locked |
402 bool has_displaced_mark() const; |
379 bool has_displaced_mark() const; |
403 markOop displaced_mark() const; |
380 markOop displaced_mark() const; |
404 void set_displaced_mark(markOop m); |
381 void set_displaced_mark(markOop m); |
405 |
382 |