(gdb) p obj

$15 = (oopDesc *) 0xf3885d08

(gdb) p * obj

$16 = {

  _mark = 0x70dea4e01,

  _metadata = {

    _klass = 0x2000070e,

    _compressed_klass = 536872718

  },

  static _bs = 0x7f658801eea8

}

(gdb) p k

$87 = (InstanceKlass *) 0x100060030

        (gdb) p * k

$88 = (InstanceKlass) {

        <Klass> = {

            <Metadata> = {

                <MetaspaceObj> = {<No data fields>},

                members of Metadata:

                _vptr.Metadata = 0x7f5aa945e590 <vtable for InstanceKlass+16>,

                        _valid = 0

            },

            members of Klass:

            _layout_helper = 24,

            _super_check_offset = 56,

            _name = 0x7f5aa014b5d8,

            _secondary_super_cache = 0x0,

            _secondary_supers = 0x7f5aa5399090,

            _primary_supers = {0x100000f30, 0x100060030, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},

            _java_mirror = 0xd758fc70,

            _super = 0x100000f30,

            _subklass = 0x0,

            _next_sibling = 0x1000471a8,

            _next_link = 0x0,

            _class_loader_data = 0x7f5aa0153768,

            _modifier_flags = 1,

            _access_flags = {

                    _flags = 2097185

            },

            _last_biased_lock_bulk_revocation_time = 0,

            _prototype_header = 0x5,

            _biased_lock_revocation_count = 0,

            _modified_oops = 1 '\001',

                    _accumulated_modified_oops = 0 '\000'

        },

        members of InstanceKlass:

        static _total_instanceKlass_count = 415,

        _annotations = 0x0,

        _array_klasses = 0x0,

        _constants = 0x7f5aa5799080,

        _inner_classes = 0x7f5aa5399060,

        _source_debug_extension = 0x0,

        _array_name = 0x0,

        _nonstatic_field_size = 2,

        _static_field_size = 1,

        _generic_signature_index = 0,

        _source_file_name_index = 69,

        _static_oop_field_count = 0,

        _java_fields_count = 3,

        _nonstatic_oop_map_size = 1,

        _is_marked_dependent = false,

        _misc_flags = 6,

        _minor_version = 0,

        _major_version = 51,

        _init_thread = 0x0,

        _vtable_len = 5,

        _itable_len = 2,

        _oop_map_cache = 0x0,

        _member_names = 0x0,

        _jni_ids = 0x0,

        _methods_jmethod_ids = 0x0,

        _dependencies = 0x0,

        _osr_nmethods_head = 0x0,

        _breakpoints = 0x0,

        _previous_versions = 0x0,

        _cached_class_file = 0x0,

        _idnum_allocated_count = 3,

        _init_state = 1 '\001',

        _reference_type = 0 '\000',

        _jvmti_cached_class_field_map = 0x0,

        _verify_count = 0,

        _methods = 0x7f5aa5799338,

        _default_methods = 0x0,

        _local_interfaces = 0x7f5aa5399090,

        _transitive_interfaces = 0x7f5aa5399090,

        _method_ordering = 0x7f5aa5399048,

        _default_vtable_indices = 0x0,

        _fields = 0x7f5aa5799308

}

(gdb) p name->as_utf8()

$80 = 0x7f5aa0009c88 "com/test/Test"

// The markOop describes the header of an object.

//

// Note that the mark is not a real oop but just a word.

// It is placed in the oop hierarchy for historical reasons.

//

// Bit-format of an object header (most significant first, big endian layout below):

//

//  32 bits:

//  --------

//             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)

//             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)

//             size:32 ------------------------------------------>| (CMS free block)

//             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object)

//

//  64 bits:

//  --------

//  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)

//  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)

//  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)

//  size:64 ----------------------------------------------------->| (CMS free block)

//

//  unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)

//  JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)

//  narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)

//  unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)

//

//  - hash contains the identity hash value: largest value is

//    31 bits, see os::random().  Also, 64-bit vm's require

//    a hash value no bigger than 32 bits because they will not

//    properly generate a mask larger than that: see library_call.cpp

//    and c1_CodePatterns_sparc.cpp.

//

//  - the biased lock pattern is used to bias a lock toward a given

//    thread. When this pattern is set in the low three bits, the lock

//    is either biased toward a given thread or "anonymously" biased,

//    indicating that it is possible for it to be biased. When the

//    lock is biased toward a given thread, locking and unlocking can

//    be performed by that thread without using atomic operations.

//    When a lock's bias is revoked, it reverts back to the normal

//    locking scheme described below.

//

//    Note that we are overloading the meaning of the "unlocked" state

//    of the header. Because we steal a bit from the age we can

//    guarantee that the bias pattern will never be seen for a truly

//    unlocked object.

//

//    Note also that the biased state contains the age bits normally

//    contained in the object header. Large increases in scavenge

//    times were seen when these bits were absent and an arbitrary age

//    assigned to all biased objects, because they tended to consume a

//    significant fraction of the eden semispaces and were not

//    promoted promptly, causing an increase in the amount of copying

//    performed. The runtime system aligns all JavaThread* pointers to

//    a very large value (currently 128 bytes (32bVM) or 256 bytes (64bVM))

//    to make room for the age bits & the epoch bits (used in support of

//    biased locking), and for the CMS "freeness" bit in the 64bVM (+COOPs).

//

//    [JavaThread* | epoch | age | 1 | 01]       lock is biased toward given thread

//    [0           | epoch | age | 1 | 01]       lock is anonymously biased

//

//  - the two lock bits are used to describe three states: locked/unlocked and monitor.

//

//    [ptr             | 00]  locked             ptr points to real header on stack

//    [header      | 0 | 01]  unlocked           regular object header

//    [ptr             | 10]  monitor            inflated lock (header is wapped out)

//    [ptr             | 11]  marked             used by markSweep to mark an object

//                                               not valid at any other time

//

//    We assume that stack/thread pointers have the lowest two bits cleared.

//    [JavaThread* | epoch | age | 1 | 01]       lock is biased toward given thread

//    [0           | epoch | age | 1 | 01]       lock is anonymously biased

//

//  - the two lock bits are used to describe three states: locked/unlocked and monitor.

//

//    [ptr             | 00]  locked             ptr points to real header on stack

//    [header      | 0 | 01]  unlocked           regular object header

//    [ptr             | 10]  monitor            inflated lock (header is wapped out)

//    [ptr             | 11]  marked             used by markSweep to mark an object

//                                               not valid at any other time

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_IHashCode");

  // as implemented in the classic virtual machine; return 0 if object is NULL

  return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;

JVM_END

intptr_t ObjectSynchronizer::FastHashCode (Thread * Self, oop obj) {

  if (UseBiasedLocking) {

// thread-local storage.

    if (obj->mark()->has_bias_pattern()) {

      // Box and unbox the raw reference just in case we cause a STW safepoint.

      Handle hobj (Self, obj) ;

      // Relaxing assertion for bug 6320749.

      assert (Universe::verify_in_progress() ||

              !SafepointSynchronize::is_at_safepoint(),

             "biases should not be seen by VM thread here");

      BiasedLocking::revoke_and_rebias(hobj, false, JavaThread::current());

      obj = hobj() ;

      assert(!obj->mark()->has_bias_pattern(), "biases should be revoked by now");

    }

  }

  ObjectMonitor* monitor = NULL;

  markOop temp, test;

  intptr_t hash;

  markOop mark = ReadStableMark (obj);

  // object should remain ineligible for biased locking

  assert (!mark->has_bias_pattern(), "invariant") ;

  if (mark->is_neutral()) {

    hash = mark->hash();              // this is a normal header

    if (hash) {                       // if it has hash, just return it

      return hash;

    }

    hash = get_next_hash(Self, obj);  // allocate a new hash code

    temp = mark->copy_set_hash(hash); // merge the hash code into header

    // use (machine word version) atomic operation to install the hash

    test = (markOop) Atomic::cmpxchg_ptr(temp, obj->mark_addr(), mark);

    if (test == mark) {

      return hash;

    }

  // hash operations

  intptr_t hash() const {

    return mask_bits(value() >> hash_shift, hash_mask);

  }

(gdb) p/x hash_mask

$20 = 7FFF FFFF

(gdb) p/x hash

$22 = 0x70dea4e