< prev index next >

src/hotspot/share/oops/oop.hpp

Print this page

 58     Klass*      _klass;
 59     narrowKlass _compressed_klass;
 60   } _metadata;
 61 
 62   // There may be ordering constraints on the initialization of fields that
 63   // make use of the C++ copy/assign incorrect.
 64   NONCOPYABLE(oopDesc);
 65 
 66   inline oop cas_set_forwardee(markWord new_mark, markWord old_mark, atomic_memory_order order);
 67 
 68  public:
 69   // Must be trivial; see verifying static assert after the class.
 70   oopDesc() = default;
 71 
 72   inline markWord  mark()          const;
 73   inline markWord  mark_acquire()  const;
 74   inline markWord* mark_addr() const;
 75 
 76   inline void set_mark(markWord m);
 77   static inline void set_mark(HeapWord* mem, markWord m);

 78   static inline void release_set_mark(HeapWord* mem, markWord m);
 79 
 80   inline void release_set_mark(markWord m);
 81   inline markWord cas_set_mark(markWord new_mark, markWord old_mark);
 82   inline markWord cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order);
 83 
 84   // Returns the prototype mark that should be used for this object.
 85   inline markWord prototype_mark() const;
 86 
 87   // Used only to re-initialize the mark word (e.g., of promoted
 88   // objects during a GC) -- requires a valid klass pointer
 89   inline void init_mark();
 90 
 91   inline Klass* klass() const;
 92   inline Klass* klass_or_null() const;
 93   inline Klass* klass_or_null_acquire() const;
 94   // Get the klass without running any asserts.
 95   inline Klass* klass_without_asserts() const;
 96 
 97   void set_narrow_klass(narrowKlass nk) NOT_CDS_JAVA_HEAP_RETURN;

 99   static inline void release_set_klass(HeapWord* mem, Klass* k);
100 
101   // For klass field compression
102   static inline void set_klass_gap(HeapWord* mem, int z);
103 
104   // Size of object header, aligned to platform wordSize
105   static int header_size() {
106     if (UseCompactObjectHeaders) {
107       return sizeof(markWord) / HeapWordSize;
108     } else {
109       return sizeof(oopDesc)  / HeapWordSize;
110     }
111   }
112 
113   // Returns whether this is an instance of k or an instance of a subclass of k
114   inline bool is_a(Klass* k) const;
115 
116   // Returns the actual oop size of the object in machine words
117   inline size_t size();
118 






















119   // Sometimes (for complicated concurrency-related reasons), it is useful
120   // to be able to figure out the size of an object knowing its klass.
121   inline size_t size_given_klass(Klass* klass);

122 
123   // type test operations (inlined in oop.inline.hpp)
124   inline bool is_instance()    const;
125   inline bool is_instanceRef() const;
126   inline bool is_stackChunk()  const;
127   inline bool is_array()       const;
128   inline bool is_objArray()    const;
129   inline bool is_typeArray()   const;
130 
131   // type test operations that don't require inclusion of oop.inline.hpp.
132   bool is_instance_noinline()    const;
133   bool is_instanceRef_noinline() const;
134   bool is_stackChunk_noinline()  const;
135   bool is_array_noinline()       const;
136   bool is_objArray_noinline()    const;
137   bool is_typeArray_noinline()   const;
138 
139  protected:
140   inline oop        as_oop() const { return const_cast<oopDesc*>(this); }
141 

269   inline bool is_gc_marked() const;
270 
271   // Forward pointer operations for scavenge
272   inline bool is_forwarded() const;
273   inline bool is_self_forwarded() const;
274 
275   inline void forward_to(oop p);
276   inline void forward_to_self();
277 
278   // Like "forward_to", but inserts the forwarding pointer atomically.
279   // Exactly one thread succeeds in inserting the forwarding pointer, and
280   // this call returns null for that thread; any other thread has the
281   // value of the forwarding pointer returned and does not modify "this".
282   inline oop forward_to_atomic(oop p, markWord compare, atomic_memory_order order = memory_order_conservative);
283   inline oop forward_to_self_atomic(markWord compare, atomic_memory_order order = memory_order_conservative);
284 
285   inline oop forwardee() const;
286   inline oop forwardee(markWord header) const;
287 
288   inline void unset_self_forwarded();

289 
290   // Age of object during scavenge
291   inline uint age() const;
292   inline void incr_age();
293 
294   template <typename OopClosureType>
295   inline void oop_iterate(OopClosureType* cl);
296 
297   template <typename OopClosureType>
298   inline void oop_iterate(OopClosureType* cl, MemRegion mr);
299 
300   template <typename OopClosureType>
301   inline size_t oop_iterate_size(OopClosureType* cl);
302 
303   template <typename OopClosureType>
304   inline size_t oop_iterate_size(OopClosureType* cl, MemRegion mr);
305 
306   template <typename OopClosureType>
307   inline void oop_iterate_backwards(OopClosureType* cl);
308 
309   template <typename OopClosureType>
310   inline void oop_iterate_backwards(OopClosureType* cl, Klass* klass);
311 
312   inline static bool is_instanceof_or_null(oop obj, Klass* klass);
313 
314   // identity hash; returns the identity hash key (computes it if necessary)
315   inline intptr_t identity_hash();
316   intptr_t slow_identity_hash();
317   inline bool fast_no_hash_check();
318 






319   // marks are forwarded to stack when object is locked
320   inline bool     has_displaced_mark() const;
321   inline markWord displaced_mark() const;
322   inline void     set_displaced_mark(markWord m);
323 
324   // Checks if the mark word needs to be preserved
325   inline bool mark_must_be_preserved() const;
326   inline bool mark_must_be_preserved(markWord m) const;
327 
328   inline static bool has_klass_gap() {
329     return ObjLayout::oop_has_klass_gap();
330   }
331 
332   // for code generation
333   static int mark_offset_in_bytes()      { return (int)offset_of(oopDesc, _mark); }
334   static int klass_offset_in_bytes()     {
335 #ifdef _LP64
336     if (UseCompactObjectHeaders) {
337       // NOTE: The only places where this is used with compact headers are the C2
338       // compiler and JVMCI.
339       return mark_offset_in_bytes() + markWord::klass_offset_in_bytes;
340     } else
341 #endif
342     {
343       return (int)offset_of(oopDesc, _metadata._klass);
344     }
345   }
346   static int klass_gap_offset_in_bytes() {
347     assert(has_klass_gap(), "only applicable to compressed klass pointers");
348     return klass_offset_in_bytes() + sizeof(narrowKlass);




349   }
350 
351   static int base_offset_in_bytes() {
352     return ObjLayout::oop_base_offset_in_bytes();
353   }
354 
355   // for error reporting
356   static void* load_oop_raw(oop obj, int offset);
357 };
358 
359 // An oopDesc is not initialized via a constructor.  Space is allocated in
360 // the Java heap, and static functions provided here on HeapWord* are used
361 // to fill in certain parts of that memory.  The allocated memory is then
362 // treated as referring to an oopDesc.  For that to be valid, the oopDesc
363 // class must have a trivial default constructor (C++14 3.8/1).
364 static_assert(std::is_trivially_default_constructible<oopDesc>::value, "required");
365 
366 #endif // SHARE_OOPS_OOP_HPP

 58     Klass*      _klass;
 59     narrowKlass _compressed_klass;
 60   } _metadata;
 61 
 62   // There may be ordering constraints on the initialization of fields that
 63   // make use of the C++ copy/assign incorrect.
 64   NONCOPYABLE(oopDesc);
 65 
 66   inline oop cas_set_forwardee(markWord new_mark, markWord old_mark, atomic_memory_order order);
 67 
 68  public:
 69   // Must be trivial; see verifying static assert after the class.
 70   oopDesc() = default;
 71 
 72   inline markWord  mark()          const;
 73   inline markWord  mark_acquire()  const;
 74   inline markWord* mark_addr() const;
 75 
 76   inline void set_mark(markWord m);
 77   static inline void set_mark(HeapWord* mem, markWord m);
 78   inline void set_mark_full(markWord m);
 79   static inline void release_set_mark(HeapWord* mem, markWord m);
 80 
 81   inline void release_set_mark(markWord m);
 82   inline markWord cas_set_mark(markWord new_mark, markWord old_mark);
 83   inline markWord cas_set_mark(markWord new_mark, markWord old_mark, atomic_memory_order order);
 84 
 85   // Returns the prototype mark that should be used for this object.
 86   inline markWord prototype_mark() const;
 87 
 88   // Used only to re-initialize the mark word (e.g., of promoted
 89   // objects during a GC) -- requires a valid klass pointer
 90   inline void init_mark();
 91 
 92   inline Klass* klass() const;
 93   inline Klass* klass_or_null() const;
 94   inline Klass* klass_or_null_acquire() const;
 95   // Get the klass without running any asserts.
 96   inline Klass* klass_without_asserts() const;
 97 
 98   void set_narrow_klass(narrowKlass nk) NOT_CDS_JAVA_HEAP_RETURN;

100   static inline void release_set_klass(HeapWord* mem, Klass* k);
101 
102   // For klass field compression
103   static inline void set_klass_gap(HeapWord* mem, int z);
104 
105   // Size of object header, aligned to platform wordSize
106   static int header_size() {
107     if (UseCompactObjectHeaders) {
108       return sizeof(markWord) / HeapWordSize;
109     } else {
110       return sizeof(oopDesc)  / HeapWordSize;
111     }
112   }
113 
114   // Returns whether this is an instance of k or an instance of a subclass of k
115   inline bool is_a(Klass* k) const;
116 
117   // Returns the actual oop size of the object in machine words
118   inline size_t size();
119 
120   // Returns the size that a copy of this object requires, in machine words.
121   // It can be 1 word larger than its current size to accomodate
122   // an additional 4-byte-field for the identity hash-code.
123   //
124   // size: the current size of this object, we're passing this here for performance
125   //       reasons, because all callers compute this anyway, and we want to avoid
126   //       recomputing it.
127   // mark: the mark-word of this object. Some callers (e.g. G1ParScanThreadState::do_copy_to_survivor_space())
128   //       need to use a known markWord because of racing GC threads that can change
129   //       the markWord at any time.
130   inline size_t copy_size(size_t size, markWord mark) const;
131   // Special version to deal with scratch classes in CDS. There we allocate
132   // temporary scratch classes (which are skeleton versions of InstanceMirrorKlass,
133   // which represent java.lang.Class objects in the CDS archive). At that point, we
134   // don't know whether or not the final archived version will be hashed or expanded,
135   // and therefore we allocate them in the special state not-hashed-but-expanded.
136   // When creating the final copy of those objects, we either populate the hidden hash
137   // field and make the object 'expanded', or we turn it back to 'not-hashed'
138   // and reduce the object's size. We do this by providing a separate method for CDS
139   // so that we don't affect GC performance.
140   inline size_t copy_size_cds(size_t size, markWord mark) const;
141 
142   // Sometimes (for complicated concurrency-related reasons), it is useful
143   // to be able to figure out the size of an object knowing its klass.
144   inline size_t base_size_given_klass(markWord m, const Klass* klass);
145   inline size_t size_given_mark_and_klass(markWord mrk, const Klass* kls);
146 
147   // type test operations (inlined in oop.inline.hpp)
148   inline bool is_instance()    const;
149   inline bool is_instanceRef() const;
150   inline bool is_stackChunk()  const;
151   inline bool is_array()       const;
152   inline bool is_objArray()    const;
153   inline bool is_typeArray()   const;
154 
155   // type test operations that don't require inclusion of oop.inline.hpp.
156   bool is_instance_noinline()    const;
157   bool is_instanceRef_noinline() const;
158   bool is_stackChunk_noinline()  const;
159   bool is_array_noinline()       const;
160   bool is_objArray_noinline()    const;
161   bool is_typeArray_noinline()   const;
162 
163  protected:
164   inline oop        as_oop() const { return const_cast<oopDesc*>(this); }
165 

293   inline bool is_gc_marked() const;
294 
295   // Forward pointer operations for scavenge
296   inline bool is_forwarded() const;
297   inline bool is_self_forwarded() const;
298 
299   inline void forward_to(oop p);
300   inline void forward_to_self();
301 
302   // Like "forward_to", but inserts the forwarding pointer atomically.
303   // Exactly one thread succeeds in inserting the forwarding pointer, and
304   // this call returns null for that thread; any other thread has the
305   // value of the forwarding pointer returned and does not modify "this".
306   inline oop forward_to_atomic(oop p, markWord compare, atomic_memory_order order = memory_order_conservative);
307   inline oop forward_to_self_atomic(markWord compare, atomic_memory_order order = memory_order_conservative);
308 
309   inline oop forwardee() const;
310   inline oop forwardee(markWord header) const;
311 
312   inline void unset_self_forwarded();
313   inline void reset_forwarded();
314 
315   // Age of object during scavenge
316   inline uint age() const;
317   inline void incr_age();
318 
319   template <typename OopClosureType>
320   inline void oop_iterate(OopClosureType* cl);
321 
322   template <typename OopClosureType>
323   inline void oop_iterate(OopClosureType* cl, MemRegion mr);
324 
325   template <typename OopClosureType>
326   inline size_t oop_iterate_size(OopClosureType* cl);
327 
328   template <typename OopClosureType>
329   inline size_t oop_iterate_size(OopClosureType* cl, MemRegion mr);
330 
331   template <typename OopClosureType>
332   inline void oop_iterate_backwards(OopClosureType* cl);
333 
334   template <typename OopClosureType>
335   inline void oop_iterate_backwards(OopClosureType* cl, Klass* klass);
336 
337   inline static bool is_instanceof_or_null(oop obj, Klass* klass);
338 
339   // identity hash; returns the identity hash key (computes it if necessary)
340   inline intptr_t identity_hash();
341   intptr_t slow_identity_hash();
342   inline bool fast_no_hash_check();
343 
344   // Initialize identity hash code in hash word of object copy from original object.
345   // Returns true if the object has been expanded, false otherwise.
346   inline void initialize_hash_if_necessary(oop obj);
347   // For CDS only.
348   void initialize_hash_if_necessary(oop obj, Klass* k, markWord m);
349 
350   // marks are forwarded to stack when object is locked
351   inline bool     has_displaced_mark() const;
352   inline markWord displaced_mark() const;
353   inline void     set_displaced_mark(markWord m);
354 
355   // Checks if the mark word needs to be preserved
356   inline bool mark_must_be_preserved() const;
357   inline bool mark_must_be_preserved(markWord m) const;
358 
359   inline static bool has_klass_gap() {
360     return ObjLayout::oop_has_klass_gap();
361   }
362 
363   // for code generation
364   static int mark_offset_in_bytes()      { return (int)offset_of(oopDesc, _mark); }
365   static int klass_offset_in_bytes()     {
366     assert(!UseCompactObjectHeaders, "don't use this with compact headers");
367     return (int)offset_of(oopDesc, _metadata._klass);








368   }
369   static int klass_gap_offset_in_bytes() {
370     assert(has_klass_gap(), "only applicable to compressed klass pointers");
371     if (UseCompactObjectHeaders) {
372       return base_offset_in_bytes();
373     } else {
374       return klass_offset_in_bytes() + sizeof(narrowKlass);
375     }
376   }
377 
378   static int base_offset_in_bytes() {
379     return ObjLayout::oop_base_offset_in_bytes();
380   }
381 
382   // for error reporting
383   static void* load_oop_raw(oop obj, int offset);
384 };
385 
386 // An oopDesc is not initialized via a constructor.  Space is allocated in
387 // the Java heap, and static functions provided here on HeapWord* are used
388 // to fill in certain parts of that memory.  The allocated memory is then
389 // treated as referring to an oopDesc.  For that to be valid, the oopDesc
390 // class must have a trivial default constructor (C++14 3.8/1).
391 static_assert(std::is_trivially_default_constructible<oopDesc>::value, "required");
392 
393 #endif // SHARE_OOPS_OOP_HPP
< prev index next >