// Get custom message for this locked flag, or NULL if
// none is available. Returns message type produced.
Flag::MsgType Flag::get_locked_message(char* buf, int buflen) const {
buf[0] = '\0';
if (is_diagnostic() && !is_unlocked()) {
jio_snprintf(buf, buflen,
"Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n"
"Error: The unlock option must precede '%s'.\n",
_name, _name);
return Flag::DIAGNOSTIC_FLAG_BUT_LOCKED;
}
if (is_experimental() && !is_unlocked()) {
jio_snprintf(buf, buflen,
"Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n"
"Error: The unlock option must precede '%s'.\n",
_name, _name);
return Flag::EXPERIMENTAL_FLAG_BUT_LOCKED;
}
if (is_develop() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is develop and is available only in debug version of VM.\n",
_name);
return Flag::DEVELOPER_FLAG_BUT_PRODUCT_BUILD;
}
if (is_notproduct() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is notproduct and is available only in debug version of VM.\n",
_name);
return Flag::NOTPRODUCT_FLAG_BUT_PRODUCT_BUILD;
}
get_locked_message_ext(buf, buflen);
return Flag::NONE;
}
// Same as must_be_preserved_with_bias_for_promotion_failure() except that
// it takes a Klass* argument, instead of the object of which this is the mark word.
inline bool markOopDesc::must_be_preserved_with_bias_for_cms_scavenge(Klass* klass_of_obj_containing_mark) const {
assert(UseBiasedLocking, "unexpected");
// CMS scavenges preserve mark words in similar fashion to promotion failures; see above
if (has_bias_pattern() ||
klass_of_obj_containing_mark->prototype_header()->has_bias_pattern()) {
return true;
}
return (!is_unlocked() || !has_no_hash());
}
void markOopDesc::print_on(outputStream* st) const {
if (is_locked()) {
st->print("locked(0x%lx)->", value());
markOop(*(markOop*)value())->print_on(st);
} else {
assert(is_unlocked(), "just checking");
st->print("mark(");
st->print("hash %#lx,", hash());
st->print("age %d)", age());
}
}
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
void markOopDesc::print_on(outputStream* st) const {
if (is_locked()) {
st->print("locked(" INTPTR_FORMAT ")->", value());
markOop(*(markOop*)value())->print_on(st);
} else {
assert(is_unlocked() || has_bias_pattern(), "just checking");
st->print("mark(");
if (has_bias_pattern()) st->print("biased,");
st->print("hash %#lx,", hash());
st->print("age %d)", age());
}
}
// Should this header be preserved during GC (when biased locking is enabled)?
inline bool markOopDesc::must_be_preserved_with_bias(oop obj_containing_mark) const {
assert(UseBiasedLocking, "unexpected");
if (has_bias_pattern()) {
// Will reset bias at end of collection
// Mark words of biased and currently locked objects are preserved separately
return false;
}
markOop prototype_header = prototype_for_object(obj_containing_mark);
if (prototype_header->has_bias_pattern()) {
// Individual instance which has its bias revoked; must return
// true for correctness
return true;
}
return (!is_unlocked() || !has_no_hash());
}
// Get custom message for this locked flag, or return NULL if
// none is available.
void Flag::get_locked_message(char* buf, int buflen) const {
buf[0] = '\0';
if (is_diagnostic() && !is_unlocked()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n",
_name);
return;
}
if (is_experimental() && !is_unlocked()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n",
_name);
return;
}
if (is_develop() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is develop and is available only in debug version of VM.\n",
_name);
return;
}
if (is_notproduct() && is_product_build()) {
jio_snprintf(buf, buflen, "Error: VM option '%s' is notproduct and is available only in debug version of VM.\n",
_name);
return;
}
get_locked_message_ext(buf, buflen);
}
// Should this header be preserved in the case of a promotion failure
// during scavenge (when biased locking is enabled)?
inline bool markOopDesc::must_be_preserved_with_bias_for_promotion_failure(oop obj_containing_mark) const {
assert(UseBiasedLocking, "unexpected");
// We don't explicitly save off the mark words of biased and
// currently-locked objects during scavenges, so if during a
// promotion failure we encounter either a biased mark word or a
// klass which still has a biasable prototype header, we have to
// preserve the mark word. This results in oversaving, but promotion
// failures are rare, and this avoids adding more complex logic to
// the scavengers to call new variants of
// BiasedLocking::preserve_marks() / restore_marks() in the middle
// of a scavenge when a promotion failure has first been detected.
if (has_bias_pattern() ||
prototype_for_object(obj_containing_mark)->has_bias_pattern()) {
return true;
}
return (!is_unlocked() || !has_no_hash());
}
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
void markOopDesc::print_on(outputStream* st) const {
if (is_marked()) {
st->print(" marked(" INTPTR_FORMAT ")", value());
} else if (has_monitor()) {
// have to check has_monitor() before is_locked()
st->print(" monitor(" INTPTR_FORMAT ")=", value());
ObjectMonitor* mon = monitor();
if (mon == NULL) {
st->print("NULL (this should never be seen!)");
} else {
st->print("{count=" INTPTR_FORMAT ",waiters=" INTPTR_FORMAT
",recursions=" INTPTR_FORMAT ",owner=" INTPTR_FORMAT "}",
mon->count(), mon->waiters(), mon->recursions(),
p2i(mon->owner()));
}
} else if (is_locked()) {
st->print(" locked(" INTPTR_FORMAT ")->", value());
if (is_neutral()) {
st->print("is_neutral");
if (has_no_hash()) {
st->print(" no_hash");
} else {
st->print(" hash=" INTPTR_FORMAT, hash());
}
st->print(" age=%d", age());
} else if (has_bias_pattern()) {
st->print("is_biased");
JavaThread* jt = biased_locker();
st->print(" biased_locker=" INTPTR_FORMAT, p2i(jt));
} else {
st->print("??");
}
} else {
assert(is_unlocked() || has_bias_pattern(), "just checking");
st->print("mark(");
if (has_bias_pattern()) st->print("biased,");
st->print("hash %#lx,", hash());
st->print("age %d)", age());
}
}
inline bool oopDesc::has_displaced_mark() const {
return !is_unlocked();
}
// Same as must_be_preserved_for_promotion_failure() except that
// it takes a Klass* argument, instead of the object of which this is the mark word.
inline bool markOopDesc::must_be_preserved_for_cms_scavenge(Klass* klass_of_obj_containing_mark) const {
if (!UseBiasedLocking)
return (!is_unlocked() || !has_no_hash());
return must_be_preserved_with_bias_for_cms_scavenge(klass_of_obj_containing_mark);
}
// Should this header be preserved in the case of a promotion failure
// during scavenge?
inline bool markOopDesc::must_be_preserved_for_promotion_failure(oop obj_containing_mark) const {
if (!UseBiasedLocking)
return (!is_unlocked() || !has_no_hash());
return must_be_preserved_with_bias_for_promotion_failure(obj_containing_mark);
}
