1 /*

        2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

       20  * CA 95054 USA or visit www.sun.com if you need additional information or

       21  * have any 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 void oop_store(oop* p, oop v);

       34 void oop_store(volatile oop* p, oop v);

       35 

       36 // store into oop without store check

       37 void oop_store_without_check(oop* p, oop v);

       38 void oop_store_without_check(volatile oop* p, oop v);

       39 

       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  private:

       57   volatile markOop  _mark;

       58   klassOop _klass;

       59 

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

       61   static BarrierSet* _bs;

       62 

       63  public:

       64   markOop  mark() const         { return _mark; }

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

       66 

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

       68 

       69   void    release_set_mark(markOop m);

       70   markOop cas_set_mark(markOop new_mark, markOop old_mark);

       71 

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

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

       74   void init_mark();

       75 

       76   klassOop klass() const        { return _klass; }

       77   oop* klass_addr() const       { return (oop*) &_klass; }

       78 

       79   void set_klass(klassOop k);

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

       81   void set_klass_to_list_ptr(oop k);

       82 

       83   // size of object header

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

       85   static int header_size_in_bytes() { return sizeof(oopDesc); }

       86 

       87   Klass* blueprint() const;

       88 

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

       90   bool is_a(klassOop k)  const;

       91 

       92   // Returns the actual oop size of the object

       93   int size();

       94 

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

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

       97   int size_given_klass(Klass* klass);

       98 

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

      100   // installation of their klass pointer.

      101   bool is_parsable();

      102 

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

      104   bool is_instance()           const;

      105   bool is_instanceRef()        const;

      106   bool is_array()              const;

      107   bool is_objArray()           const;

      108   bool is_symbol()             const;

      109   bool is_klass()              const;

      110   bool is_thread()             const;

      111   bool is_method()             const;

      112   bool is_constMethod()        const;

      113   bool is_methodData()         const;

      114   bool is_constantPool()       const;

      115   bool is_constantPoolCache()  const;

      116   bool is_typeArray()          const;

      117   bool is_javaArray()          const;

      118   bool is_compiledICHolder()   const;

      119 

      120  private:

      121   // field addresses in oop

      122   // byte/char/bool/short fields are always stored as full words

      123   void*     field_base(int offset)        const;

      124 

      125   jbyte*    byte_field_addr(int offset)   const;

      126   jchar*    char_field_addr(int offset)   const;

      127   jboolean* bool_field_addr(int offset)   const;

      128   jint*     int_field_addr(int offset)    const;

      129   jshort*   short_field_addr(int offset)  const;

      130   jlong*    long_field_addr(int offset)   const;

      131   jfloat*   float_field_addr(int offset)  const;

      132   jdouble*  double_field_addr(int offset) const;

      133 

      134  public:

      135   // need this as public for garbage collection

      136   oop* obj_field_addr(int offset) const;

      137 

      138   oop obj_field(int offset) const;

      139   void obj_field_put(int offset, oop value);

      140 

      141   jbyte byte_field(int offset) const;

      142   void byte_field_put(int offset, jbyte contents);

      143 

      144   jchar char_field(int offset) const;

      145   void char_field_put(int offset, jchar contents);

      146 

      147   jboolean bool_field(int offset) const;

      148   void bool_field_put(int offset, jboolean contents);

      149 

      150   jint int_field(int offset) const;

      151   void int_field_put(int offset, jint contents);

      152 

      153   jshort short_field(int offset) const;

      154   void short_field_put(int offset, jshort contents);

      155 

      156   jlong long_field(int offset) const;

      157   void long_field_put(int offset, jlong contents);

      158 

      159   jfloat float_field(int offset) const;

      160   void float_field_put(int offset, jfloat contents);

      161 

      162   jdouble double_field(int offset) const;

      163   void double_field_put(int offset, jdouble contents);

      164 

      165   oop obj_field_acquire(int offset) const;

      166   void release_obj_field_put(int offset, oop value);

      167 

      168   jbyte byte_field_acquire(int offset) const;

      169   void release_byte_field_put(int offset, jbyte contents);

      170 

      171   jchar char_field_acquire(int offset) const;

      172   void release_char_field_put(int offset, jchar contents);

      173 

      174   jboolean bool_field_acquire(int offset) const;

      175   void release_bool_field_put(int offset, jboolean contents);

      176 

      177   jint int_field_acquire(int offset) const;

      178   void release_int_field_put(int offset, jint contents);

      179 

      180   jshort short_field_acquire(int offset) const;

      181   void release_short_field_put(int offset, jshort contents);

      182 

      183   jlong long_field_acquire(int offset) const;

      184   void release_long_field_put(int offset, jlong contents);

      185 

      186   jfloat float_field_acquire(int offset) const;

      187   void release_float_field_put(int offset, jfloat contents);

      188 

      189   jdouble double_field_acquire(int offset) const;

      190   void release_double_field_put(int offset, jdouble contents);

      191 

      192   // printing functions for VM debugging

      193   void print_on(outputStream* st) const;         // First level print

      194   void print_value_on(outputStream* st) const;   // Second level print.

      195   void print_address_on(outputStream* st) const; // Address printing

      196 

      197   // printing on default output stream

      198   void print();

      199   void print_value();

      200   void print_address();

      201 

      202   // return the print strings

      203   char* print_string();

      204   char* print_value_string();

      205 

      206   // verification operations

      207   void verify_on(outputStream* st);

      208   void verify();

      209   void verify_old_oop(oop* p, bool allow_dirty);

      210 

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

      212   bool partially_loaded();

      213   void set_partially_loaded();

      214 

      215   // locking operations

      216   bool is_locked()   const;

      217   bool is_unlocked() const;

      218   bool has_bias_pattern() const;

      219 

      220   // asserts

      221   bool is_oop(bool ignore_mark_word = false) const;

      222   bool is_oop_or_null(bool ignore_mark_word = false) const;

      223 #ifndef PRODUCT

      224   bool is_unlocked_oop() const;

      225 #endif

      226 

      227   // garbage collection

      228   bool is_gc_marked() const;

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

      230   // reference field in "this".

      231   void follow_contents();

      232   void follow_header();

      233 

      234 #ifndef SERIALGC

      235   // Parallel Scavenge

      236   void copy_contents(PSPromotionManager* pm);

      237   void push_contents(PSPromotionManager* pm);

      238 

      239   // Parallel Old

      240   void update_contents(ParCompactionManager* cm);

      241   void update_contents(ParCompactionManager* cm,

      242                        HeapWord* begin_limit,

      243                        HeapWord* end_limit);

      244   void update_contents(ParCompactionManager* cm,

      245                        klassOop old_klass,

      246                        HeapWord* begin_limit,

      247                        HeapWord* end_limit);

      248 

      249   void follow_contents(ParCompactionManager* cm);

      250   void follow_header(ParCompactionManager* cm);

      251 #endif // SERIALGC

      252 

      253   bool is_perm() const;

      254   bool is_perm_or_null() const;

      255   bool is_shared() const;

      256   bool is_shared_readonly() const;

      257   bool is_shared_readwrite() const;

      258 

      259   // Forward pointer operations for scavenge

      260   bool is_forwarded() const;

      261 

      262   void forward_to(oop p);

      263   bool cas_forward_to(oop p, markOop compare);

      264 

      265 #ifndef SERIALGC

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

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

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

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

      270   oop forward_to_atomic(oop p);

      271 #endif // SERIALGC

      272 

      273   oop forwardee() const;

      274 

      275   // Age of object during scavenge

      276   int age() const;

      277   void incr_age();

      278 

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

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

      281   int adjust_pointers();

      282   void adjust_header();

      283 

      284 #ifndef SERIALGC

      285   // Parallel old

      286   void update_header();

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

      288 #endif // SERIALGC

      289 

      290   // mark-sweep support

      291   void follow_body(int begin, int end);

      292 

      293   // Fast access to barrier set

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

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

      296 

      297   // iterators, returns size of object

      298 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix)                             \

      299   int oop_iterate(OopClosureType* blk);                                  \

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

      301 

      302   ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)

      303   ALL_OOP_OOP_ITERATE_CLOSURES_3(OOP_ITERATE_DECL)

      304 

      305   void oop_iterate_header(OopClosure* blk);

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

      307 

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

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

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

      311   intptr_t identity_hash();

      312   intptr_t slow_identity_hash();

      313 

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

      315   bool     has_displaced_mark() const;

      316   markOop  displaced_mark() const;

      317   void     set_displaced_mark(markOop m);

      318 

      319   // for code generation

      320   static int klass_offset_in_bytes()   { return offset_of(oopDesc, _klass); }

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

      322 };