33 // Should this header be preserved during GC (when biased locking is enabled)?

    32 // Should this header be preserved during GC?

    34 inline bool markWord::must_be_preserved_with_bias(oop obj_containing_mark) const {

    33 template <typename KlassProxy>

    35   assert(UseBiasedLocking, "unexpected");

    34 inline bool markWord::must_be_preserved(KlassProxy klass) const {

    36   if (has_bias_pattern()) {

    35   if (UseBiasedLocking) {

    37     // Will reset bias at end of collection

    36     if (has_bias_pattern()) {

    38     // Mark words of biased and currently locked objects are preserved separately

    37       // Will reset bias at end of collection

    39     return false;

    38       // Mark words of biased and currently locked objects are preserved separately

    40   }

    39       return false;

    41   markWord prototype_header = prototype_for_object(obj_containing_mark);

    40     }

    42   if (prototype_header.has_bias_pattern()) {

    41     markWord prototype_header = prototype_for_klass(klass);

    43     // Individual instance which has its bias revoked; must return

    42     if (prototype_header.has_bias_pattern()) {

    44     // true for correctness

    43       // Individual instance which has its bias revoked; must return

    45     return true;

    44       // true for correctness

    45       return true;

    46     }

    50 // Should this header be preserved during GC?

    51 // Should this header be preserved in the case of a promotion failure during scavenge?

    51 inline bool markWord::must_be_preserved(oop obj_containing_mark) const {

    52 template <typename KlassProxy>

    52   if (!UseBiasedLocking)

    53 inline bool markWord::must_be_preserved_for_promotion_failure(KlassProxy klass) const {

    53     return (!is_unlocked() || !has_no_hash());

    54   if (UseBiasedLocking) {

    54   return must_be_preserved_with_bias(obj_containing_mark);

    55     // We don't explicitly save off the mark words of biased and

    55 }

    56     // currently-locked objects during scavenges, so if during a

    56 

    57     // promotion failure we encounter either a biased mark word or a

    57 // Should this header be preserved in the case of a promotion failure

    58     // klass which still has a biasable prototype header, we have to

    58 // during scavenge (when biased locking is enabled)?

    59     // preserve the mark word. This results in oversaving, but promotion

    59 inline bool markWord::must_be_preserved_with_bias_for_promotion_failure(oop obj_containing_mark) const {

    60     // failures are rare, and this avoids adding more complex logic to

    60   assert(UseBiasedLocking, "unexpected");

    61     // the scavengers to call new variants of

    61   // We don't explicitly save off the mark words of biased and

    62     // BiasedLocking::preserve_marks() / restore_marks() in the middle

    62   // currently-locked objects during scavenges, so if during a

    63     // of a scavenge when a promotion failure has first been detected.

    63   // promotion failure we encounter either a biased mark word or a

    64     if (has_bias_pattern() || prototype_for_klass(klass).has_bias_pattern()) {

    64   // klass which still has a biasable prototype header, we have to

    65       return true;

    65   // preserve the mark word. This results in oversaving, but promotion

    66     }

    66   // failures are rare, and this avoids adding more complex logic to

    67   // the scavengers to call new variants of

    68   // BiasedLocking::preserve_marks() / restore_marks() in the middle

    69   // of a scavenge when a promotion failure has first been detected.

    70   if (has_bias_pattern() ||

    71       prototype_for_object(obj_containing_mark).has_bias_pattern()) {

    72     return true;

    77 // Should this header be preserved in the case of a promotion failure

    71 // Same as must_be_preserved_for_promotion_failure().

    78 // during scavenge?

    72 inline bool markWord::must_be_preserved_for_cms_scavenge(Klass* klass_of_obj_containing_mark) const {

    79 inline bool markWord::must_be_preserved_for_promotion_failure(oop obj_containing_mark) const {

    73   return must_be_preserved_for_promotion_failure(klass_of_obj_containing_mark);

    80   if (!UseBiasedLocking)

    81     return (!is_unlocked() || !has_no_hash());

    82   return must_be_preserved_with_bias_for_promotion_failure(obj_containing_mark);

    86 // Same as must_be_preserved_with_bias_for_promotion_failure() except that

    80   return prototype_header;

    87 // it takes a Klass* argument, instead of the object of which this is the mark word.

    88 inline bool markWord::must_be_preserved_with_bias_for_cms_scavenge(Klass* klass_of_obj_containing_mark) const {

    89   assert(UseBiasedLocking, "unexpected");

    90   // CMS scavenges preserve mark words in similar fashion to promotion failures; see above

    91   if (has_bias_pattern() ||

    92       klass_of_obj_containing_mark->prototype_header().has_bias_pattern()) {

    93     return true;

    94   }

    95   return (!is_unlocked() || !has_no_hash());

    96 }

    97 

    98 // Same as must_be_preserved_for_promotion_failure() except that

    99 // it takes a Klass* argument, instead of the object of which this is the mark word.

   100 inline bool markWord::must_be_preserved_for_cms_scavenge(Klass* klass_of_obj_containing_mark) const {

   101   if (!UseBiasedLocking)

   102     return (!is_unlocked() || !has_no_hash());

   103   return must_be_preserved_with_bias_for_cms_scavenge(klass_of_obj_containing_mark);

   104 }

   105 

   106 inline markWord markWord::prototype_for_object(oop obj) {

   107 #ifdef ASSERT

   108   markWord prototype_header = obj->klass()->prototype_header();

   109   assert(prototype_header == prototype() || prototype_header.has_bias_pattern(), "corrupt prototype header");

   110 #endif

   111   return obj->klass()->prototype_header();