1 /*

        2  * Copyright (c) 1997, 2009, 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 // oopDesc is the top baseclass for objects classes.  The {name}Desc classes describe

       26 // the format of Java objects so the fields can be accessed from C++.

       27 // oopDesc is abstract.

       28 // (see oopHierarchy for complete oop class hierarchy)

       29 //

       30 // no virtual functions allowed

       31 

       32 // store into oop with store check

       33 template <class T> inline void oop_store(T* p, oop v);

       34 template <class T> inline void oop_store(volatile T* p, oop v);

       35 

       36 // store into oop without store check

       37 template <class T> inline void oop_store_without_check(T* p, oop v);

       38 template <class T> inline void oop_store_without_check(volatile T* p, oop v);

       39 

       40 extern bool always_do_update_barrier;

       41 

       42 // Forward declarations.

       43 class OopClosure;

       44 class ScanClosure;

       45 class FastScanClosure;

       46 class FilteringClosure;

       47 class BarrierSet;

       48 class CMSIsAliveClosure;

       49 

       50 class PSPromotionManager;

       51 class ParCompactionManager;

       52 

       53 class oopDesc {

       54   friend class VMStructs;

       55  private:

       56   volatile markOop  _mark;

       57   union _metadata {

       58     wideKlassOop    _klass;

       59     narrowOop       _compressed_klass;

       60   } _metadata;

       61 

       62   // Fast access to barrier set.  Must be initialized.

       63   static BarrierSet* _bs;

       64 

       65  public:

       66   markOop  mark() const         { return _mark; }

       67   markOop* mark_addr() const    { return (markOop*) &_mark; }

       68 

       69   void set_mark(volatile markOop m)      { _mark = m;   }

       70 

       71   void    release_set_mark(markOop m);

       72   markOop cas_set_mark(markOop new_mark, markOop old_mark);

       73 

       74   // Used only to re-initialize the mark word (e.g., of promoted

       75   // objects during a GC) -- requires a valid klass pointer

       76   void init_mark();

       77 

       78   klassOop klass() const;

       79   klassOop klass_or_null() const volatile;

       80   oop* klass_addr();

       81   narrowOop* compressed_klass_addr();

       82 

       83   void set_klass(klassOop k);

       84 

       85   // For klass field compression

       86   int klass_gap() const;

       87   void set_klass_gap(int z);

       88   // For when the klass pointer is being used as a linked list "next" field.

       89   void set_klass_to_list_ptr(oop k);

       90 

       91   // size of object header, aligned to platform wordSize

       92   static int header_size()          { return sizeof(oopDesc)/HeapWordSize; }

       93 

       94   Klass* blueprint() const;

       95 

       96   // Returns whether this is an instance of k or an instance of a subclass of k

       97   bool is_a(klassOop k)  const;

       98 

       99   // Returns the actual oop size of the object

      100   int size();

      101 

      102   // Sometimes (for complicated concurrency-related reasons), it is useful

      103   // to be able to figure out the size of an object knowing its klass.

      104   int size_given_klass(Klass* klass);

      105 

      106   // Some perm gen objects are not parseble immediately after

      107   // installation of their klass pointer.

      108   bool is_parsable();

      109 

      110   // Some perm gen objects that have been allocated and initialized

      111   // can be changed by the VM when not at a safe point (class rededfinition

      112   // is an example).  Such objects should not be examined by the

      113   // concurrent processing of a garbage collector if is_conc_safe()

      114   // returns false.

      115   bool is_conc_safe();

      116 

      117   // type test operations (inlined in oop.inline.h)

      118   bool is_instance()           const;

      119   bool is_instanceRef()        const;

      120   bool is_array()              const;

      121   bool is_objArray()           const;

      122   bool is_symbol()             const;

      123   bool is_klass()              const;

      124   bool is_thread()             const;

      125   bool is_method()             const;

      126   bool is_constMethod()        const;

      127   bool is_methodData()         const;

      128   bool is_constantPool()       const;

      129   bool is_constantPoolCache()  const;

      130   bool is_typeArray()          const;

      131   bool is_javaArray()          const;

      132   bool is_compiledICHolder()   const;

      133 

      134  private:

      135   // field addresses in oop

      136   void*     field_base(int offset)        const;

      137 

      138   jbyte*    byte_field_addr(int offset)   const;

      139   jchar*    char_field_addr(int offset)   const;

      140   jboolean* bool_field_addr(int offset)   const;

      141   jint*     int_field_addr(int offset)    const;

      142   jshort*   short_field_addr(int offset)  const;

      143   jlong*    long_field_addr(int offset)   const;

      144   jfloat*   float_field_addr(int offset)  const;

      145   jdouble*  double_field_addr(int offset) const;

      146   address*  address_field_addr(int offset) const;

      147 

      148  public:

      149   // Need this as public for garbage collection.

      150   template <class T> T* obj_field_addr(int offset) const;

      151 

      152   static bool is_null(oop obj);

      153   static bool is_null(narrowOop obj);

      154 

      155   // Decode an oop pointer from a narrowOop if compressed.

      156   // These are overloaded for oop and narrowOop as are the other functions

      157   // below so that they can be called in template functions.

      158   static oop decode_heap_oop_not_null(oop v);

      159   static oop decode_heap_oop_not_null(narrowOop v);

      160   static oop decode_heap_oop(oop v);

      161   static oop decode_heap_oop(narrowOop v);

      162 

      163   // Encode an oop pointer to a narrow oop.  The or_null versions accept

      164   // null oop pointer, others do not in order to eliminate the

      165   // null checking branches.

      166   static narrowOop encode_heap_oop_not_null(oop v);

      167   static narrowOop encode_heap_oop(oop v);

      168 

      169   // Load an oop out of the Java heap

      170   static narrowOop load_heap_oop(narrowOop* p);

      171   static oop       load_heap_oop(oop* p);

      172 

      173   // Load an oop out of Java heap and decode it to an uncompressed oop.

      174   static oop load_decode_heap_oop_not_null(narrowOop* p);

      175   static oop load_decode_heap_oop_not_null(oop* p);

      176   static oop load_decode_heap_oop(narrowOop* p);

      177   static oop load_decode_heap_oop(oop* p);

      178 

      179   // Store an oop into the heap.

      180   static void store_heap_oop(narrowOop* p, narrowOop v);

      181   static void store_heap_oop(oop* p, oop v);

      182 

      183   // Encode oop if UseCompressedOops and store into the heap.

      184   static void encode_store_heap_oop_not_null(narrowOop* p, oop v);

      185   static void encode_store_heap_oop_not_null(oop* p, oop v);

      186   static void encode_store_heap_oop(narrowOop* p, oop v);

      187   static void encode_store_heap_oop(oop* p, oop v);

      188 

      189   static void release_store_heap_oop(volatile narrowOop* p, narrowOop v);

      190   static void release_store_heap_oop(volatile oop* p, oop v);

      191 

      192   static void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v);

      193   static void release_encode_store_heap_oop_not_null(volatile oop* p, oop v);

      194   static void release_encode_store_heap_oop(volatile narrowOop* p, oop v);

      195   static void release_encode_store_heap_oop(volatile oop* p, oop v);

      196 

      197   static oop atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest);

      198   static oop atomic_compare_exchange_oop(oop exchange_value,

      199                                          volatile HeapWord *dest,

      200                                          oop compare_value);

      201 

      202   // Access to fields in a instanceOop through these methods.

      203   oop obj_field(int offset) const;

      204   void obj_field_put(int offset, oop value);

      205   void obj_field_raw_put(int offset, oop value);

      206 

      207   jbyte byte_field(int offset) const;

      208   void byte_field_put(int offset, jbyte contents);

      209 

      210   jchar char_field(int offset) const;

      211   void char_field_put(int offset, jchar contents);

      212 

      213   jboolean bool_field(int offset) const;

      214   void bool_field_put(int offset, jboolean contents);

      215 

      216   jint int_field(int offset) const;

      217   void int_field_put(int offset, jint contents);

      218 

      219   jshort short_field(int offset) const;

      220   void short_field_put(int offset, jshort contents);

      221 

      222   jlong long_field(int offset) const;

      223   void long_field_put(int offset, jlong contents);

      224 

      225   jfloat float_field(int offset) const;

      226   void float_field_put(int offset, jfloat contents);

      227 

      228   jdouble double_field(int offset) const;

      229   void double_field_put(int offset, jdouble contents);

      230 

      231   address address_field(int offset) const;

      232   void address_field_put(int offset, address contents);

      233 

      234   oop obj_field_acquire(int offset) const;

      235   void release_obj_field_put(int offset, oop value);

      236 

      237   jbyte byte_field_acquire(int offset) const;

      238   void release_byte_field_put(int offset, jbyte contents);

      239 

      240   jchar char_field_acquire(int offset) const;

      241   void release_char_field_put(int offset, jchar contents);

      242 

      243   jboolean bool_field_acquire(int offset) const;

      244   void release_bool_field_put(int offset, jboolean contents);

      245 

      246   jint int_field_acquire(int offset) const;

      247   void release_int_field_put(int offset, jint contents);

      248 

      249   jshort short_field_acquire(int offset) const;

      250   void release_short_field_put(int offset, jshort contents);

      251 

      252   jlong long_field_acquire(int offset) const;

      253   void release_long_field_put(int offset, jlong contents);

      254 

      255   jfloat float_field_acquire(int offset) const;

      256   void release_float_field_put(int offset, jfloat contents);

      257 

      258   jdouble double_field_acquire(int offset) const;

      259   void release_double_field_put(int offset, jdouble contents);

      260 

      261   address address_field_acquire(int offset) const;

      262   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   void verify_old_oop(oop* p, bool allow_dirty);

      282   void verify_old_oop(narrowOop* p, bool allow_dirty);

      283 

      284   // tells whether this oop is partially constructed (gc during class loading)

      285   bool partially_loaded();

      286   void set_partially_loaded();

      287 

      288   // locking operations

      289   bool is_locked()   const;

      290   bool is_unlocked() const;

      291   bool has_bias_pattern() const;

      292 

      293   // asserts

      294   bool is_oop(bool ignore_mark_word = false) const;

      295   bool is_oop_or_null(bool ignore_mark_word = false) const;

      296 #ifndef PRODUCT

      297   bool is_unlocked_oop() const;

      298 #endif

      299 

      300   // garbage collection

      301   bool is_gc_marked() const;

      302   // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL

      303   // reference field in "this".

      304   void follow_contents(void);

      305   void follow_header(void);

      306 

      307 #ifndef SERIALGC

      308   // Parallel Scavenge

      309   void copy_contents(PSPromotionManager* pm);

      310   void push_contents(PSPromotionManager* pm);

      311 

      312   // Parallel Old

      313   void update_contents(ParCompactionManager* cm);

      314   void update_contents(ParCompactionManager* cm,

      315                        HeapWord* begin_limit,

      316                        HeapWord* end_limit);

      317   void update_contents(ParCompactionManager* cm,

      318                        klassOop old_klass,

      319                        HeapWord* begin_limit,

      320                        HeapWord* end_limit);

      321 

      322   void follow_contents(ParCompactionManager* cm);

      323   void follow_header(ParCompactionManager* cm);

      324 #endif // SERIALGC

      325 

      326   bool is_perm() const;

      327   bool is_perm_or_null() const;

      328   bool is_scavengable() const;

      329   bool is_shared() const;

      330   bool is_shared_readonly() const;

      331   bool is_shared_readwrite() const;

      332 

      333   // Forward pointer operations for scavenge

      334   bool is_forwarded() const;

      335 

      336   void forward_to(oop p);

      337   bool cas_forward_to(oop p, markOop compare);

      338 

      339 #ifndef SERIALGC

      340   // Like "forward_to", but inserts the forwarding pointer atomically.

      341   // Exactly one thread succeeds in inserting the forwarding pointer, and

      342   // this call returns "NULL" for that thread; any other thread has the

      343   // value of the forwarding pointer returned and does not modify "this".

      344   oop forward_to_atomic(oop p);

      345 #endif // SERIALGC

      346 

      347   oop forwardee() const;

      348 

      349   // Age of object during scavenge

      350   int age() const;

      351   void incr_age();

      352 

      353   // Adjust all pointers in this object to point at it's forwarded location and

      354   // return the size of this oop.  This is used by the MarkSweep collector.

      355   int adjust_pointers();

      356   void adjust_header();

      357 

      358 #ifndef SERIALGC

      359   // Parallel old

      360   void update_header();

      361   void update_header(HeapWord* beg_addr, HeapWord* end_addr);

      362 #endif // SERIALGC

      363 

      364   // mark-sweep support

      365   void follow_body(int begin, int end);

      366 

      367   // Fast access to barrier set

      368   static BarrierSet* bs()            { return _bs; }

      369   static void set_bs(BarrierSet* bs) { _bs = bs; }

      370 

      371   // iterators, returns size of object

      372 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix)                      \

      373   int oop_iterate(OopClosureType* blk);                                  \

      374   int oop_iterate(OopClosureType* blk, MemRegion mr);  // Only in mr.

      375 

      376   ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)

      377   ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL)

      378 

      379 #ifndef SERIALGC

      380 

      381 #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)            \

      382   int oop_iterate_backwards(OopClosureType* blk);

      383 

      384   ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL)

      385   ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL)

      386 #endif

      387 

      388   void oop_iterate_header(OopClosure* blk);

      389   void oop_iterate_header(OopClosure* blk, MemRegion mr);

      390 

      391   // identity hash; returns the identity hash key (computes it if necessary)

      392   // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a

      393   // safepoint if called on a biased object. Calling code must be aware of that.

      394   intptr_t identity_hash();

      395   intptr_t slow_identity_hash();

      396 

      397   // marks are forwarded to stack when object is locked

      398   bool     has_displaced_mark() const;

      399   markOop  displaced_mark() const;

      400   void     set_displaced_mark(markOop m);

      401 

      402   // for code generation

      403   static int mark_offset_in_bytes()    { return offset_of(oopDesc, _mark); }

      404   static int klass_offset_in_bytes()   { return offset_of(oopDesc, _metadata._klass); }

      405   static int klass_gap_offset_in_bytes();

      406 };