archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 14:24:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8081202: Hotspot compile warning: "Invalid suffix on literal; C++11 requires a space between literal and identifier"

Browse source 
Need to add a space between macro identifier and string literal

Reviewed-by: stefank, dholmes, kbarrett
This commit is contained in:
Bill Pittore 2015-06-24 12:12:25 -04:00
parent 912d770499
commit 304b59b0c8
85 changed files with 462 additions and 462 deletions
Download patch file Download diff file Expand all files Collapse all files

4
hotspot/src/cpu/aarch64/vm/vtableStubs_aarch64.cpp
View file

@ -105,7 +105,7 @@ VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
__ flush(); __ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("vtable #%d at " PTR_FORMAT "[%d] left over: %d",
vtable_index, p2i(s->entry_point()), vtable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));
@ -184,7 +184,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
__ flush(); __ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("itable #%d at " PTR_FORMAT "[%d] left over: %d",
itable_index, p2i(s->entry_point()), itable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));

2
hotspot/src/cpu/ppc/vm/methodHandles_ppc.cpp
View file

@ -465,7 +465,7 @@ void trace_method_handle_stub(const char* adaptername,
bool has_mh = (strstr(adaptername, "/static") == NULL && bool has_mh = (strstr(adaptername, "/static") == NULL &&
strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH
const char* mh_reg_name = has_mh ? "R23_method_handle" : "G23"; const char* mh_reg_name = has_mh ? "R23_method_handle" : "G23";
tty->print_cr("MH %s %s="INTPTR_FORMAT " sp=" INTPTR_FORMAT, tty->print_cr("MH %s %s=" INTPTR_FORMAT " sp=" INTPTR_FORMAT,
adaptername, mh_reg_name, p2i(mh), p2i(entry_sp)); adaptername, mh_reg_name, p2i(mh), p2i(entry_sp));
if (Verbose) { if (Verbose) {

2
hotspot/src/cpu/sparc/vm/methodHandles_sparc.cpp
View file

@ -483,7 +483,7 @@ void trace_method_handle_stub(const char* adaptername,
bool has_mh = (strstr(adaptername, "/static") == NULL && bool has_mh = (strstr(adaptername, "/static") == NULL &&
strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH
const char* mh_reg_name = has_mh ? "G3_mh" : "G3"; const char* mh_reg_name = has_mh ? "G3_mh" : "G3";
tty->print_cr("MH %s %s="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT, tty->print_cr("MH %s %s=" INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT,
adaptername, mh_reg_name, adaptername, mh_reg_name,
p2i(mh), p2i(saved_sp), p2i(args)); p2i(mh), p2i(saved_sp), p2i(args));

4
hotspot/src/cpu/sparc/vm/vtableStubs_sparc.cpp
View file

@ -110,7 +110,7 @@ VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
masm->flush(); masm->flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("vtable #%d at " PTR_FORMAT "[%d] left over: %d",
vtable_index, p2i(s->entry_point()), vtable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));
@ -205,7 +205,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
masm->flush(); masm->flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("itable #%d at " PTR_FORMAT "[%d] left over: %d",
itable_index, p2i(s->entry_point()), itable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));

2
hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp
View file

@ -5152,7 +5152,7 @@ RegisterOrConstant MacroAssembler::delayed_value_impl(intptr_t* delayed_value_ad
{ {
ResourceMark rm; ResourceMark rm;
stringStream ss; stringStream ss;
ss.print("DelayedValue="INTPTR_FORMAT, delayed_value_addr[1]); ss.print("DelayedValue=" INTPTR_FORMAT, delayed_value_addr[1]);
buf = code_string(ss.as_string()); buf = code_string(ss.as_string());
} }
jcc(Assembler::notZero, L); jcc(Assembler::notZero, L);

2
hotspot/src/cpu/x86/vm/methodHandles_x86.cpp
View file

@ -484,7 +484,7 @@ void trace_method_handle_stub(const char* adaptername,
bool has_mh = (strstr(adaptername, "/static") == NULL && bool has_mh = (strstr(adaptername, "/static") == NULL &&
strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH strstr(adaptername, "linkTo") == NULL); // static linkers don't have MH
const char* mh_reg_name = has_mh ? "rcx_mh" : "rcx"; const char* mh_reg_name = has_mh ? "rcx_mh" : "rcx";
tty->print_cr("MH %s %s="PTR_FORMAT" sp="PTR_FORMAT, tty->print_cr("MH %s %s=" PTR_FORMAT " sp=" PTR_FORMAT,
adaptername, mh_reg_name, adaptername, mh_reg_name,
(void *)mh, entry_sp); (void *)mh, entry_sp);

4
hotspot/src/cpu/x86/vm/vtableStubs_x86_32.cpp
View file

@ -117,7 +117,7 @@ VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
masm->flush(); masm->flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("vtable #%d at " PTR_FORMAT "[%d] left over: %d",
vtable_index, p2i(s->entry_point()), vtable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));
@ -198,7 +198,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
masm->flush(); masm->flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("itable #%d at " PTR_FORMAT "[%d] left over: %d",
itable_index, p2i(s->entry_point()), itable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));

4
hotspot/src/cpu/x86/vm/vtableStubs_x86_64.cpp
View file

@ -112,7 +112,7 @@ VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
__ flush(); __ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("vtable #%d at " PTR_FORMAT "[%d] left over: %d",
vtable_index, s->entry_point(), vtable_index, s->entry_point(),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));
@ -205,7 +205,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
__ flush(); __ flush();
if (PrintMiscellaneous && (WizardMode || Verbose)) { if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d", tty->print_cr("itable #%d at " PTR_FORMAT "[%d] left over: %d",
itable_index, s->entry_point(), itable_index, s->entry_point(),
(int)(s->code_end() - s->entry_point()), (int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc())); (int)(s->code_end() - __ pc()));

6
hotspot/src/os/windows/vm/os_windows.cpp
View file

@ -5890,7 +5890,7 @@ void TestReserveMemorySpecial_test() {
char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false); char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
if (result == NULL) { if (result == NULL) {
if (VerboseInternalVMTests) { if (VerboseInternalVMTests) {
gclog_or_tty->print("Failed to allocate control block with size "SIZE_FORMAT". Skipping remainder of test.", gclog_or_tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
large_allocation_size); large_allocation_size);
} }
} else { } else {
@ -5903,7 +5903,7 @@ void TestReserveMemorySpecial_test() {
char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false); char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
if (actual_location == NULL) { if (actual_location == NULL) {
if (VerboseInternalVMTests) { if (VerboseInternalVMTests) {
gclog_or_tty->print("Failed to allocate any memory at "PTR_FORMAT" size "SIZE_FORMAT". Skipping remainder of test.", gclog_or_tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
expected_location, large_allocation_size); expected_location, large_allocation_size);
} }
} else { } else {
@ -5911,7 +5911,7 @@ void TestReserveMemorySpecial_test() {
os::release_memory_special(actual_location, expected_allocation_size); os::release_memory_special(actual_location, expected_allocation_size);
// only now check, after releasing any memory to avoid any leaks. // only now check, after releasing any memory to avoid any leaks.
assert(actual_location == expected_location, assert(actual_location == expected_location,
err_msg("Failed to allocate memory at requested location "PTR_FORMAT" of size "SIZE_FORMAT", is "PTR_FORMAT" instead", err_msg("Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
expected_location, expected_allocation_size, actual_location)); expected_location, expected_allocation_size, actual_location));
} }
} }

2
hotspot/src/share/vm/c1/c1_CFGPrinter.cpp
View file

@ -161,7 +161,7 @@ void CFGPrinterOutput::print_compilation() {
print("name \"%s\"", method_name(_compilation->method(), true)); print("name \"%s\"", method_name(_compilation->method(), true));
print("method \"%s\"", method_name(_compilation->method())); print("method \"%s\"", method_name(_compilation->method()));
print("date "INT64_FORMAT, (int64_t) os::javaTimeMillis()); print("date " INT64_FORMAT, (int64_t) os::javaTimeMillis());
print_end("compilation"); print_end("compilation");
} }

4
hotspot/src/share/vm/classfile/classLoaderData.cpp
View file

@ -494,7 +494,7 @@ const char* ClassLoaderData::loader_name() {
void ClassLoaderData::dump(outputStream * const out) { void ClassLoaderData::dump(outputStream * const out) {
ResourceMark rm; ResourceMark rm;
out->print("ClassLoaderData CLD: "PTR_FORMAT", loader: "PTR_FORMAT", loader_klass: "PTR_FORMAT" %s {", out->print("ClassLoaderData CLD: " PTR_FORMAT ", loader: " PTR_FORMAT ", loader_klass: " PTR_FORMAT " %s {",
p2i(this), p2i((void *)class_loader()), p2i(this), p2i((void *)class_loader()),
p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name()); p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name());
if (claimed()) out->print(" claimed "); if (claimed()) out->print(" claimed ");
@ -513,7 +513,7 @@ void ClassLoaderData::dump(outputStream * const out) {
ResourceMark rm; ResourceMark rm;
Klass* k = _klasses; Klass* k = _klasses;
while (k != NULL) { while (k != NULL) {
out->print_cr("klass "PTR_FORMAT", %s, CT: %d, MUT: %d", k, k->name()->as_C_string(), out->print_cr("klass " PTR_FORMAT ", %s, CT: %d, MUT: %d", k, k->name()->as_C_string(),
k->has_modified_oops(), k->has_accumulated_modified_oops()); k->has_modified_oops(), k->has_accumulated_modified_oops());
assert(k != k->next_link(), "no loops!"); assert(k != k->next_link(), "no loops!");
k = k->next_link(); k = k->next_link();

2
hotspot/src/share/vm/classfile/dictionary.cpp
View file

@ -557,7 +557,7 @@ void ProtectionDomainCacheTable::print() {
} }
void ProtectionDomainCacheEntry::print() { void ProtectionDomainCacheEntry::print() {
tty->print_cr("entry "PTR_FORMAT" value "PTR_FORMAT" strongly_reachable %d next "PTR_FORMAT, tty->print_cr("entry " PTR_FORMAT " value " PTR_FORMAT " strongly_reachable %d next " PTR_FORMAT,
this, (void*)literal(), _strongly_reachable, next()); this, (void*)literal(), _strongly_reachable, next());
} }
#endif #endif

2
hotspot/src/share/vm/classfile/dictionary.hpp
View file

@ -370,7 +370,7 @@ class SymbolPropertyEntry : public HashtableEntry<Symbol*, mtSymbol> {
void print_on(outputStream* st) const { void print_on(outputStream* st) const {
symbol()->print_value_on(st); symbol()->print_value_on(st);
st->print("/mode="INTX_FORMAT, symbol_mode()); st->print("/mode=" INTX_FORMAT, symbol_mode());
st->print(" -> "); st->print(" -> ");
bool printed = false; bool printed = false;
if (method() != NULL) { if (method() != NULL) {

2
hotspot/src/share/vm/code/codeCache.cpp
View file

@ -1397,7 +1397,7 @@ void CodeCache::print_codelist(outputStream* st) {
nmethod* nm = iter.method(); nmethod* nm = iter.method();
ResourceMark rm; ResourceMark rm;
char *method_name = nm->method()->name_and_sig_as_C_string(); char *method_name = nm->method()->name_and_sig_as_C_string();
st->print_cr("%d %d %s ["INTPTR_FORMAT", "INTPTR_FORMAT" - "INTPTR_FORMAT"]", st->print_cr("%d %d %s [" INTPTR_FORMAT ", " INTPTR_FORMAT " - " INTPTR_FORMAT "]",
nm->compile_id(), nm->comp_level(), method_name, (intptr_t)nm->header_begin(), nm->compile_id(), nm->comp_level(), method_name, (intptr_t)nm->header_begin(),
(intptr_t)nm->code_begin(), (intptr_t)nm->code_end()); (intptr_t)nm->code_begin(), (intptr_t)nm->code_end());
} }

2
hotspot/src/share/vm/code/exceptionHandlerTable.cpp
View file

@ -186,7 +186,7 @@ uint ImplicitExceptionTable::at( uint exec_off ) const {
void ImplicitExceptionTable::print(address base) const { void ImplicitExceptionTable::print(address base) const {
tty->print("{"); tty->print("{");
for( uint i=0; i<len(); i++ ) for( uint i=0; i<len(); i++ )
tty->print("< "INTPTR_FORMAT", "INTPTR_FORMAT" > ",base + *adr(i), base + *(adr(i)+1)); tty->print("< " INTPTR_FORMAT ", " INTPTR_FORMAT " > ",base + *adr(i), base + *(adr(i)+1));
tty->print_cr("}"); tty->print_cr("}");
} }

8
hotspot/src/share/vm/code/nmethod.cpp
View file

@ -2118,7 +2118,7 @@ public:
void maybe_print(oop* p) { void maybe_print(oop* p) {
if (_print_nm == NULL) return; if (_print_nm == NULL) return;
if (!_detected_scavenge_root) _print_nm->print_on(tty, "new scavenge root"); if (!_detected_scavenge_root) _print_nm->print_on(tty, "new scavenge root");
tty->print_cr(""PTR_FORMAT"[offset=%d] detected scavengable oop "PTR_FORMAT" (found at "PTR_FORMAT")", tty->print_cr("" PTR_FORMAT "[offset=%d] detected scavengable oop " PTR_FORMAT " (found at " PTR_FORMAT ")",
_print_nm, (int)((intptr_t)p - (intptr_t)_print_nm), _print_nm, (int)((intptr_t)p - (intptr_t)_print_nm),
(void *)(*p), (intptr_t)p); (void *)(*p), (intptr_t)p);
(*p)->print(); (*p)->print();
@ -2518,7 +2518,7 @@ public:
_nm->print_nmethod(true); _nm->print_nmethod(true);
_ok = false; _ok = false;
} }
tty->print_cr("*** non-oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", tty->print_cr("*** non-oop " PTR_FORMAT " found at " PTR_FORMAT " (offset %d)",
(void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); (void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
} }
virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
@ -2642,7 +2642,7 @@ public:
_nm->print_nmethod(true); _nm->print_nmethod(true);
_ok = false; _ok = false;
} }
tty->print_cr("*** scavengable oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", tty->print_cr("*** scavengable oop " PTR_FORMAT " found at " PTR_FORMAT " (offset %d)",
(void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); (void *)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));
(*p)->print(); (*p)->print();
} }
@ -2687,7 +2687,7 @@ void nmethod::print() const {
print_on(tty, NULL); print_on(tty, NULL);
if (WizardMode) { if (WizardMode) {
tty->print("((nmethod*) "INTPTR_FORMAT ") ", this); tty->print("((nmethod*) " INTPTR_FORMAT ") ", this);
tty->print(" for method " INTPTR_FORMAT , (address)method()); tty->print(" for method " INTPTR_FORMAT , (address)method());
tty->print(" { "); tty->print(" { ");
if (is_in_use()) tty->print("in_use "); if (is_in_use()) tty->print("in_use ");

2
hotspot/src/share/vm/compiler/compileBroker.cpp
View file

@ -172,7 +172,7 @@ class CompilationLog : public StringEventLog {
} }
void log_nmethod(JavaThread* thread, nmethod* nm) { void log_nmethod(JavaThread* thread, nmethod* nm) {
log(thread, "nmethod %d%s " INTPTR_FORMAT " code ["INTPTR_FORMAT ", " INTPTR_FORMAT "]", log(thread, "nmethod %d%s " INTPTR_FORMAT " code [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",
nm->compile_id(), nm->is_osr_method() ? "%" : "", nm->compile_id(), nm->is_osr_method() ? "%" : "",
p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end())); p2i(nm), p2i(nm->code_begin()), p2i(nm->code_end()));
} }

2
hotspot/src/share/vm/compiler/disassembler.cpp
View file

@ -65,7 +65,7 @@ bool Disassembler::_tried_to_load_library = false;
Disassembler::decode_func_virtual Disassembler::_decode_instructions_virtual = NULL; Disassembler::decode_func_virtual Disassembler::_decode_instructions_virtual = NULL;
Disassembler::decode_func Disassembler::_decode_instructions = NULL; Disassembler::decode_func Disassembler::_decode_instructions = NULL;
static const char hsdis_library_name[] = "hsdis-"HOTSPOT_LIB_ARCH; static const char hsdis_library_name[] = "hsdis-" HOTSPOT_LIB_ARCH;
static const char decode_instructions_virtual_name[] = "decode_instructions_virtual"; static const char decode_instructions_virtual_name[] = "decode_instructions_virtual";
static const char decode_instructions_name[] = "decode_instructions"; static const char decode_instructions_name[] = "decode_instructions";
static bool use_new_version = true; static bool use_new_version = true;

78
hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp
View file

@ -688,18 +688,18 @@ void ConcurrentMarkSweepGeneration::printOccupancy(const char *s) {
"The CMS generation should be the old generation"); "The CMS generation should be the old generation");
uint level = 1; uint level = 1;
if (Verbose) { if (Verbose) {
gclog_or_tty->print("[%u %s-%s: "SIZE_FORMAT"("SIZE_FORMAT")]", gclog_or_tty->print("[%u %s-%s: " SIZE_FORMAT "(" SIZE_FORMAT ")]",
level, short_name(), s, used(), capacity()); level, short_name(), s, used(), capacity());
} else { } else {
gclog_or_tty->print("[%u %s-%s: "SIZE_FORMAT"K("SIZE_FORMAT"K)]", gclog_or_tty->print("[%u %s-%s: " SIZE_FORMAT "K(" SIZE_FORMAT "K)]",
level, short_name(), s, used() / K, capacity() / K); level, short_name(), s, used() / K, capacity() / K);
} }
} }
if (Verbose) { if (Verbose) {
gclog_or_tty->print(" "SIZE_FORMAT"("SIZE_FORMAT")", gclog_or_tty->print(" " SIZE_FORMAT "(" SIZE_FORMAT ")",
gch->used(), gch->capacity()); gch->used(), gch->capacity());
} else { } else {
gclog_or_tty->print(" "SIZE_FORMAT"K("SIZE_FORMAT"K)", gclog_or_tty->print(" " SIZE_FORMAT "K(" SIZE_FORMAT "K)",
gch->used() / K, gch->capacity() / K); gch->used() / K, gch->capacity() / K);
} }
} }
@ -729,8 +729,8 @@ bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promoti
bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); bool res = (available >= av_promo) || (available >= max_promotion_in_bytes);
if (Verbose && PrintGCDetails) { if (Verbose && PrintGCDetails) {
gclog_or_tty->print_cr( gclog_or_tty->print_cr(
"CMS: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," "CMS: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "),"
"max_promo("SIZE_FORMAT")", "max_promo(" SIZE_FORMAT ")",
res? "":" not", available, res? ">=":"<", res? "":" not", available, res? ">=":"<",
av_promo, max_promotion_in_bytes); av_promo, max_promotion_in_bytes);
} }
@ -805,18 +805,18 @@ void ConcurrentMarkSweepGeneration::compute_new_size_free_list() {
desired_free_percentage); desired_free_percentage);
gclog_or_tty->print_cr(" Maximum free fraction %f", gclog_or_tty->print_cr(" Maximum free fraction %f",
maximum_free_percentage); maximum_free_percentage);
gclog_or_tty->print_cr(" Capacity "SIZE_FORMAT, capacity()/1000); gclog_or_tty->print_cr(" Capacity " SIZE_FORMAT, capacity()/1000);
gclog_or_tty->print_cr(" Desired capacity "SIZE_FORMAT, gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT,
desired_capacity/1000); desired_capacity/1000);
GenCollectedHeap* gch = GenCollectedHeap::heap(); GenCollectedHeap* gch = GenCollectedHeap::heap();
assert(gch->is_old_gen(this), "The CMS generation should always be the old generation"); assert(gch->is_old_gen(this), "The CMS generation should always be the old generation");
size_t young_size = gch->young_gen()->capacity(); size_t young_size = gch->young_gen()->capacity();
gclog_or_tty->print_cr(" Young gen size " SIZE_FORMAT, young_size / 1000); gclog_or_tty->print_cr(" Young gen size " SIZE_FORMAT, young_size / 1000);
gclog_or_tty->print_cr(" unsafe_max_alloc_nogc "SIZE_FORMAT, gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT,
unsafe_max_alloc_nogc()/1000); unsafe_max_alloc_nogc()/1000);
gclog_or_tty->print_cr(" contiguous available "SIZE_FORMAT, gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT,
contiguous_available()/1000); contiguous_available()/1000);
gclog_or_tty->print_cr(" Expand by "SIZE_FORMAT" (bytes)", gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)",
expand_bytes); expand_bytes);
} }
// safe if expansion fails // safe if expansion fails
@ -1182,8 +1182,8 @@ bool CMSCollector::shouldConcurrentCollect() {
stats().print_on(gclog_or_tty); stats().print_on(gclog_or_tty);
gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f", gclog_or_tty->print_cr("time_until_cms_gen_full %3.7f",
stats().time_until_cms_gen_full()); stats().time_until_cms_gen_full());
gclog_or_tty->print_cr("free="SIZE_FORMAT, _cmsGen->free()); gclog_or_tty->print_cr("free=" SIZE_FORMAT, _cmsGen->free());
gclog_or_tty->print_cr("contiguous_available="SIZE_FORMAT, gclog_or_tty->print_cr("contiguous_available=" SIZE_FORMAT,
_cmsGen->contiguous_available()); _cmsGen->contiguous_available());
gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate()); gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate());
gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate()); gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate());
@ -2160,8 +2160,8 @@ void ConcurrentMarkSweepGeneration::gc_prologue_work(bool full,
assert(_numObjectsPromoted == 0, "check"); assert(_numObjectsPromoted == 0, "check");
assert(_numWordsPromoted == 0, "check"); assert(_numWordsPromoted == 0, "check");
if (Verbose && PrintGC) { if (Verbose && PrintGC) {
gclog_or_tty->print("Allocated "SIZE_FORMAT" objects, " gclog_or_tty->print("Allocated " SIZE_FORMAT " objects, "
SIZE_FORMAT" bytes concurrently", SIZE_FORMAT " bytes concurrently",
_numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord)); _numObjectsAllocated, _numWordsAllocated*sizeof(HeapWord));
} }
_numObjectsAllocated = 0; _numObjectsAllocated = 0;
@ -2241,8 +2241,8 @@ void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) {
assert(_numObjectsAllocated == 0, "check"); assert(_numObjectsAllocated == 0, "check");
assert(_numWordsAllocated == 0, "check"); assert(_numWordsAllocated == 0, "check");
if (Verbose && PrintGC) { if (Verbose && PrintGC) {
gclog_or_tty->print("Promoted "SIZE_FORMAT" objects, " gclog_or_tty->print("Promoted " SIZE_FORMAT " objects, "
SIZE_FORMAT" bytes", SIZE_FORMAT " bytes",
_numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord)); _numObjectsPromoted, _numWordsPromoted*sizeof(HeapWord));
} }
_numObjectsPromoted = 0; _numObjectsPromoted = 0;
@ -2252,7 +2252,7 @@ void ConcurrentMarkSweepGeneration::gc_epilogue_work(bool full) {
if (PrintGC && Verbose) { if (PrintGC && Verbose) {
// Call down the chain in contiguous_available needs the freelistLock // Call down the chain in contiguous_available needs the freelistLock
// so print this out before releasing the freeListLock. // so print this out before releasing the freeListLock.
gclog_or_tty->print(" Contiguous available "SIZE_FORMAT" bytes ", gclog_or_tty->print(" Contiguous available " SIZE_FORMAT " bytes ",
contiguous_available()); contiguous_available());
} }
} }
@ -2340,7 +2340,7 @@ class VerifyMarkedClosure: public BitMapClosure {
HeapWord* addr = _marks->offsetToHeapWord(offset); HeapWord* addr = _marks->offsetToHeapWord(offset);
if (!_marks->isMarked(addr)) { if (!_marks->isMarked(addr)) {
oop(addr)->print_on(gclog_or_tty); oop(addr)->print_on(gclog_or_tty);
gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", p2i(addr)); gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", p2i(addr));
_failed = true; _failed = true;
} }
return true; return true;
@ -4269,7 +4269,7 @@ void CMSCollector::checkpointRootsFinal() {
verify_overflow_empty(); verify_overflow_empty();
if (PrintGCDetails) { if (PrintGCDetails) {
gclog_or_tty->print("[YG occupancy: "SIZE_FORMAT" K ("SIZE_FORMAT" K)]", gclog_or_tty->print("[YG occupancy: " SIZE_FORMAT " K (" SIZE_FORMAT " K)]",
_young_gen->used() / K, _young_gen->used() / K,
_young_gen->capacity() / K); _young_gen->capacity() / K);
} }
@ -4381,8 +4381,8 @@ void CMSCollector::checkpointRootsFinalWork() {
if (ser_ovflw > 0) { if (ser_ovflw > 0) {
if (PrintCMSStatistics != 0) { if (PrintCMSStatistics != 0) {
gclog_or_tty->print_cr("Marking stack overflow (benign) " gclog_or_tty->print_cr("Marking stack overflow (benign) "
"(pmc_pc="SIZE_FORMAT", pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT "(pmc_pc=" SIZE_FORMAT ", pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT
", kac_preclean="SIZE_FORMAT")", ", kac_preclean=" SIZE_FORMAT ")",
_ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw, _ser_pmc_preclean_ovflw, _ser_pmc_remark_ovflw,
_ser_kac_ovflw, _ser_kac_preclean_ovflw); _ser_kac_ovflw, _ser_kac_preclean_ovflw);
} }
@ -4395,7 +4395,7 @@ void CMSCollector::checkpointRootsFinalWork() {
if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) { if (_par_pmc_remark_ovflw > 0 || _par_kac_ovflw > 0) {
if (PrintCMSStatistics != 0) { if (PrintCMSStatistics != 0) {
gclog_or_tty->print_cr("Work queue overflow (benign) " gclog_or_tty->print_cr("Work queue overflow (benign) "
"(pmc_rm="SIZE_FORMAT", kac="SIZE_FORMAT")", "(pmc_rm=" SIZE_FORMAT ", kac=" SIZE_FORMAT ")",
_par_pmc_remark_ovflw, _par_kac_ovflw); _par_pmc_remark_ovflw, _par_kac_ovflw);
} }
_par_pmc_remark_ovflw = 0; _par_pmc_remark_ovflw = 0;
@ -4403,12 +4403,12 @@ void CMSCollector::checkpointRootsFinalWork() {
} }
if (PrintCMSStatistics != 0) { if (PrintCMSStatistics != 0) {
if (_markStack._hit_limit > 0) { if (_markStack._hit_limit > 0) {
gclog_or_tty->print_cr(" (benign) Hit max stack size limit ("SIZE_FORMAT")", gclog_or_tty->print_cr(" (benign) Hit max stack size limit (" SIZE_FORMAT ")",
_markStack._hit_limit); _markStack._hit_limit);
} }
if (_markStack._failed_double > 0) { if (_markStack._failed_double > 0) {
gclog_or_tty->print_cr(" (benign) Failed stack doubling ("SIZE_FORMAT")," gclog_or_tty->print_cr(" (benign) Failed stack doubling (" SIZE_FORMAT "),"
" current capacity "SIZE_FORMAT, " current capacity " SIZE_FORMAT,
_markStack._failed_double, _markStack._failed_double,
_markStack.capacity()); _markStack.capacity());
} }
@ -5161,7 +5161,7 @@ void CMSCollector::do_remark_non_parallel() {
&markFromDirtyCardsClosure); &markFromDirtyCardsClosure);
verify_work_stacks_empty(); verify_work_stacks_empty();
if (PrintCMSStatistics != 0) { if (PrintCMSStatistics != 0) {
gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in cms gen) ", gclog_or_tty->print(" (re-scanned " SIZE_FORMAT " dirty cards in cms gen) ",
markFromDirtyCardsClosure.num_dirty_cards()); markFromDirtyCardsClosure.num_dirty_cards());
} }
} }
@ -6035,8 +6035,8 @@ void CMSMarkStack::expand() {
} else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) { } else if (_failed_double++ == 0 && !CMSConcurrentMTEnabled && PrintGCDetails) {
// Failed to double capacity, continue; // Failed to double capacity, continue;
// we print a detail message only once per CMS cycle. // we print a detail message only once per CMS cycle.
gclog_or_tty->print(" (benign) Failed to expand marking stack from "SIZE_FORMAT"K to " gclog_or_tty->print(" (benign) Failed to expand marking stack from " SIZE_FORMAT "K to "
SIZE_FORMAT"K", SIZE_FORMAT "K",
_capacity / K, new_capacity / K); _capacity / K, new_capacity / K);
} }
} }
@ -7335,25 +7335,25 @@ SweepClosure::~SweepClosure() {
ShouldNotReachHere(); ShouldNotReachHere();
} }
if (Verbose && PrintGC) { if (Verbose && PrintGC) {
gclog_or_tty->print("Collected "SIZE_FORMAT" objects, " SIZE_FORMAT " bytes", gclog_or_tty->print("Collected " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes",
_numObjectsFreed, _numWordsFreed*sizeof(HeapWord)); _numObjectsFreed, _numWordsFreed*sizeof(HeapWord));
gclog_or_tty->print_cr("\nLive "SIZE_FORMAT" objects, " gclog_or_tty->print_cr("\nLive " SIZE_FORMAT " objects, "
SIZE_FORMAT" bytes " SIZE_FORMAT " bytes "
"Already free "SIZE_FORMAT" objects, "SIZE_FORMAT" bytes", "Already free " SIZE_FORMAT " objects, " SIZE_FORMAT " bytes",
_numObjectsLive, _numWordsLive*sizeof(HeapWord), _numObjectsLive, _numWordsLive*sizeof(HeapWord),
_numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord)); _numObjectsAlreadyFree, _numWordsAlreadyFree*sizeof(HeapWord));
size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree) size_t totalBytes = (_numWordsFreed + _numWordsLive + _numWordsAlreadyFree)
* sizeof(HeapWord); * sizeof(HeapWord);
gclog_or_tty->print_cr("Total sweep: "SIZE_FORMAT" bytes", totalBytes); gclog_or_tty->print_cr("Total sweep: " SIZE_FORMAT " bytes", totalBytes);
if (PrintCMSStatistics && CMSVerifyReturnedBytes) { if (PrintCMSStatistics && CMSVerifyReturnedBytes) {
size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes(); size_t indexListReturnedBytes = _sp->sumIndexedFreeListArrayReturnedBytes();
size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes(); size_t dict_returned_bytes = _sp->dictionary()->sum_dict_returned_bytes();
size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes; size_t returned_bytes = indexListReturnedBytes + dict_returned_bytes;
gclog_or_tty->print("Returned "SIZE_FORMAT" bytes", returned_bytes); gclog_or_tty->print("Returned " SIZE_FORMAT " bytes", returned_bytes);
gclog_or_tty->print(" Indexed List Returned "SIZE_FORMAT" bytes", gclog_or_tty->print(" Indexed List Returned " SIZE_FORMAT " bytes",
indexListReturnedBytes); indexListReturnedBytes);
gclog_or_tty->print_cr(" Dictionary Returned "SIZE_FORMAT" bytes", gclog_or_tty->print_cr(" Dictionary Returned " SIZE_FORMAT " bytes",
dict_returned_bytes); dict_returned_bytes);
} }
} }
@ -7432,12 +7432,12 @@ size_t SweepClosure::do_blk_careful(HeapWord* addr) {
// coalesced chunk to the appropriate free list. // coalesced chunk to the appropriate free list.
if (inFreeRange()) { if (inFreeRange()) {
assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit, assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit,
err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", p2i(freeFinger()))); err_msg("freeFinger() " PTR_FORMAT " is out-of-bounds", p2i(freeFinger())));
flush_cur_free_chunk(freeFinger(), flush_cur_free_chunk(freeFinger(),
pointer_delta(addr, freeFinger())); pointer_delta(addr, freeFinger()));
if (CMSTraceSweeper) { if (CMSTraceSweeper) {
gclog_or_tty->print("Sweep: last chunk: "); gclog_or_tty->print("Sweep: last chunk: ");
gclog_or_tty->print("put_free_blk " PTR_FORMAT " ("SIZE_FORMAT") " gclog_or_tty->print("put_free_blk " PTR_FORMAT " (" SIZE_FORMAT ") "
"[coalesced:%d]\n", "[coalesced:%d]\n",
p2i(freeFinger()), pointer_delta(addr, freeFinger()), p2i(freeFinger()), pointer_delta(addr, freeFinger()),
lastFreeRangeCoalesced() ? 1 : 0); lastFreeRangeCoalesced() ? 1 : 0);

2
hotspot/src/share/vm/gc/g1/collectionSetChooser.cpp
View file

@ -119,7 +119,7 @@ void CollectionSetChooser::verify() {
} }
guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes, guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
err_msg("reclaimable bytes inconsistent, " err_msg("reclaimable bytes inconsistent, "
"remaining: "SIZE_FORMAT" sum: "SIZE_FORMAT, "remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
_remaining_reclaimable_bytes, sum_of_reclaimable_bytes)); _remaining_reclaimable_bytes, sum_of_reclaimable_bytes));
} }
#endif // !PRODUCT #endif // !PRODUCT

2
hotspot/src/share/vm/gc/g1/collectionSetChooser.hpp
View file

@ -92,7 +92,7 @@ public:
regions_at_put(_curr_index, NULL); regions_at_put(_curr_index, NULL);
assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes, assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes,
err_msg("remaining reclaimable bytes inconsistent " err_msg("remaining reclaimable bytes inconsistent "
"from region: "SIZE_FORMAT" remaining: "SIZE_FORMAT, "from region: " SIZE_FORMAT " remaining: " SIZE_FORMAT,
hr->reclaimable_bytes(), _remaining_reclaimable_bytes)); hr->reclaimable_bytes(), _remaining_reclaimable_bytes));
_remaining_reclaimable_bytes -= hr->reclaimable_bytes(); _remaining_reclaimable_bytes -= hr->reclaimable_bytes();
_curr_index += 1; _curr_index += 1;

74
hotspot/src/share/vm/gc/g1/concurrentMark.cpp
View file

@ -307,7 +307,7 @@ void CMMarkStack::expand() {
if (PrintGCDetails && Verbose) { if (PrintGCDetails && Verbose) {
// Failed to double capacity, continue; // Failed to double capacity, continue;
gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from " gclog_or_tty->print(" (benign) Failed to expand marking stack capacity from "
SIZE_FORMAT"K to " SIZE_FORMAT"K", SIZE_FORMAT "K to " SIZE_FORMAT "K",
_capacity / K, new_capacity / K); _capacity / K, new_capacity / K);
} }
} }
@ -555,7 +555,7 @@ ConcurrentMark::ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev
_verbose_level = verbose_level; _verbose_level = verbose_level;
if (verbose_low()) { if (verbose_low()) {
gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", " gclog_or_tty->print_cr("[global] init, heap start = " PTR_FORMAT ", "
"heap end = " PTR_FORMAT, p2i(_heap_start), p2i(_heap_end)); "heap end = " PTR_FORMAT, p2i(_heap_start), p2i(_heap_end));
} }
@ -802,7 +802,7 @@ void ConcurrentMark::set_concurrency_and_phase(uint active_tasks, bool concurren
// in a STW phase. // in a STW phase.
assert(!concurrent_marking_in_progress(), "invariant"); assert(!concurrent_marking_in_progress(), "invariant");
assert(out_of_regions(), assert(out_of_regions(),
err_msg("only way to get here: _finger: "PTR_FORMAT", _heap_end: "PTR_FORMAT, err_msg("only way to get here: _finger: " PTR_FORMAT ", _heap_end: " PTR_FORMAT,
p2i(_finger), p2i(_heap_end))); p2i(_finger), p2i(_heap_end)));
} }
} }
@ -1424,7 +1424,7 @@ public:
assert(start <= hr->end() && start <= ntams && ntams <= hr->end(), assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
err_msg("Preconditions not met - " err_msg("Preconditions not met - "
"start: "PTR_FORMAT", ntams: "PTR_FORMAT", end: "PTR_FORMAT, "start: " PTR_FORMAT ", ntams: " PTR_FORMAT ", end: " PTR_FORMAT,
p2i(start), p2i(ntams), p2i(hr->end()))); p2i(start), p2i(ntams), p2i(hr->end())));
// Find the first marked object at or after "start". // Find the first marked object at or after "start".
@ -1725,10 +1725,10 @@ class FinalCountDataUpdateClosure: public CMCountDataClosureBase {
} }
assert(end_idx <= _card_bm->size(), assert(end_idx <= _card_bm->size(),
err_msg("oob: end_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT, err_msg("oob: end_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
end_idx, _card_bm->size())); end_idx, _card_bm->size()));
assert(start_idx < _card_bm->size(), assert(start_idx < _card_bm->size(),
err_msg("oob: start_idx= "SIZE_FORMAT", bitmap size= "SIZE_FORMAT, err_msg("oob: start_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
start_idx, _card_bm->size())); start_idx, _card_bm->size()));
_cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */); _cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
@ -2133,7 +2133,7 @@ class G1CMKeepAliveAndDrainClosure: public OopClosure {
oop obj = oopDesc::load_decode_heap_oop(p); oop obj = oopDesc::load_decode_heap_oop(p);
if (_cm->verbose_high()) { if (_cm->verbose_high()) {
gclog_or_tty->print_cr("\t[%u] we're looking at location " gclog_or_tty->print_cr("\t[%u] we're looking at location "
"*"PTR_FORMAT" = "PTR_FORMAT, "*" PTR_FORMAT " = " PTR_FORMAT,
_task->worker_id(), p2i(p), p2i((void*) obj)); _task->worker_id(), p2i(p), p2i((void*) obj));
} }
@ -2660,9 +2660,9 @@ ConcurrentMark::claim_region(uint worker_id) {
HeapWord* limit = curr_region->next_top_at_mark_start(); HeapWord* limit = curr_region->next_top_at_mark_start();
if (verbose_low()) { if (verbose_low()) {
gclog_or_tty->print_cr("[%u] curr_region = "PTR_FORMAT" " gclog_or_tty->print_cr("[%u] curr_region = " PTR_FORMAT " "
"["PTR_FORMAT", "PTR_FORMAT"), " "[" PTR_FORMAT ", " PTR_FORMAT "), "
"limit = "PTR_FORMAT, "limit = " PTR_FORMAT,
worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit)); worker_id, p2i(curr_region), p2i(bottom), p2i(end), p2i(limit));
} }
@ -2677,7 +2677,7 @@ ConcurrentMark::claim_region(uint worker_id) {
if (limit > bottom) { if (limit > bottom) {
if (verbose_low()) { if (verbose_low()) {
gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is not empty, " gclog_or_tty->print_cr("[%u] region " PTR_FORMAT " is not empty, "
"returning it ", worker_id, p2i(curr_region)); "returning it ", worker_id, p2i(curr_region));
} }
return curr_region; return curr_region;
@ -2685,7 +2685,7 @@ ConcurrentMark::claim_region(uint worker_id) {
assert(limit == bottom, assert(limit == bottom,
"the region limit should be at bottom"); "the region limit should be at bottom");
if (verbose_low()) { if (verbose_low()) {
gclog_or_tty->print_cr("[%u] region "PTR_FORMAT" is empty, " gclog_or_tty->print_cr("[%u] region " PTR_FORMAT " is empty, "
"returning NULL", worker_id, p2i(curr_region)); "returning NULL", worker_id, p2i(curr_region));
} }
// we return NULL and the caller should try calling // we return NULL and the caller should try calling
@ -2697,13 +2697,13 @@ ConcurrentMark::claim_region(uint worker_id) {
if (verbose_low()) { if (verbose_low()) {
if (curr_region == NULL) { if (curr_region == NULL) {
gclog_or_tty->print_cr("[%u] found uncommitted region, moving finger, " gclog_or_tty->print_cr("[%u] found uncommitted region, moving finger, "
"global finger = "PTR_FORMAT", " "global finger = " PTR_FORMAT ", "
"our finger = "PTR_FORMAT, "our finger = " PTR_FORMAT,
worker_id, p2i(_finger), p2i(finger)); worker_id, p2i(_finger), p2i(finger));
} else { } else {
gclog_or_tty->print_cr("[%u] somebody else moved the finger, " gclog_or_tty->print_cr("[%u] somebody else moved the finger, "
"global finger = "PTR_FORMAT", " "global finger = " PTR_FORMAT ", "
"our finger = "PTR_FORMAT, "our finger = " PTR_FORMAT,
worker_id, p2i(_finger), p2i(finger)); worker_id, p2i(_finger), p2i(finger));
} }
} }
@ -2739,7 +2739,7 @@ private:
void do_object_work(oop obj) { void do_object_work(oop obj) {
guarantee(!_g1h->obj_in_cs(obj), guarantee(!_g1h->obj_in_cs(obj),
err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d", err_msg("obj: " PTR_FORMAT " in CSet, phase: %s, info: %d",
p2i((void*) obj), phase_str(), _info)); p2i((void*) obj), phase_str(), _info));
} }
@ -2800,7 +2800,7 @@ void ConcurrentMark::verify_no_cset_oops() {
// here. // here.
HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger); HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
guarantee(global_hr == NULL || global_finger == global_hr->bottom(), guarantee(global_hr == NULL || global_finger == global_hr->bottom(),
err_msg("global finger: "PTR_FORMAT" region: "HR_FORMAT, err_msg("global finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(global_finger), HR_FORMAT_PARAMS(global_hr))); p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
} }
@ -2814,7 +2814,7 @@ void ConcurrentMark::verify_no_cset_oops() {
HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger); HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
guarantee(task_hr == NULL || task_finger == task_hr->bottom() || guarantee(task_hr == NULL || task_finger == task_hr->bottom() ||
!task_hr->in_collection_set(), !task_hr->in_collection_set(),
err_msg("task finger: "PTR_FORMAT" region: "HR_FORMAT, err_msg("task finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(task_finger), HR_FORMAT_PARAMS(task_hr))); p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
} }
} }
@ -2856,8 +2856,8 @@ class AggregateCountDataHRClosure: public HeapRegionClosure {
assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(), assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
err_msg("Preconditions not met - " err_msg("Preconditions not met - "
"start: "PTR_FORMAT", limit: "PTR_FORMAT", " "start: " PTR_FORMAT ", limit: " PTR_FORMAT ", "
"top: "PTR_FORMAT", end: "PTR_FORMAT, "top: " PTR_FORMAT ", end: " PTR_FORMAT,
p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end()))); p2i(start), p2i(limit), p2i(hr->top()), p2i(hr->end())));
assert(hr->next_marked_bytes() == 0, "Precondition"); assert(hr->next_marked_bytes() == 0, "Precondition");
@ -3118,7 +3118,7 @@ bool ConcurrentMark::do_yield_check(uint worker_id) {
#ifndef PRODUCT #ifndef PRODUCT
// for debugging purposes // for debugging purposes
void ConcurrentMark::print_finger() { void ConcurrentMark::print_finger() {
gclog_or_tty->print_cr("heap ["PTR_FORMAT", "PTR_FORMAT"), global finger = "PTR_FORMAT, gclog_or_tty->print_cr("heap [" PTR_FORMAT ", " PTR_FORMAT "), global finger = " PTR_FORMAT,
p2i(_heap_start), p2i(_heap_end), p2i(_finger)); p2i(_heap_start), p2i(_heap_end), p2i(_finger));
for (uint i = 0; i < _max_worker_id; ++i) { for (uint i = 0; i < _max_worker_id; ++i) {
gclog_or_tty->print(" %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger())); gclog_or_tty->print(" %u: " PTR_FORMAT, i, p2i(_tasks[i]->finger()));
@ -3203,7 +3203,7 @@ void CMTask::setup_for_region(HeapRegion* hr) {
"claim_region() should have filtered out continues humongous regions"); "claim_region() should have filtered out continues humongous regions");
if (_cm->verbose_low()) { if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%u] setting up for region "PTR_FORMAT, gclog_or_tty->print_cr("[%u] setting up for region " PTR_FORMAT,
_worker_id, p2i(hr)); _worker_id, p2i(hr));
} }
@ -3220,7 +3220,7 @@ void CMTask::update_region_limit() {
if (limit == bottom) { if (limit == bottom) {
if (_cm->verbose_low()) { if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%u] found an empty region " gclog_or_tty->print_cr("[%u] found an empty region "
"["PTR_FORMAT", "PTR_FORMAT")", "[" PTR_FORMAT ", " PTR_FORMAT ")",
_worker_id, p2i(bottom), p2i(limit)); _worker_id, p2i(bottom), p2i(limit));
} }
// The region was collected underneath our feet. // The region was collected underneath our feet.
@ -3252,7 +3252,7 @@ void CMTask::update_region_limit() {
void CMTask::giveup_current_region() { void CMTask::giveup_current_region() {
assert(_curr_region != NULL, "invariant"); assert(_curr_region != NULL, "invariant");
if (_cm->verbose_low()) { if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%u] giving up region "PTR_FORMAT, gclog_or_tty->print_cr("[%u] giving up region " PTR_FORMAT,
_worker_id, p2i(_curr_region)); _worker_id, p2i(_curr_region));
} }
clear_region_fields(); clear_region_fields();
@ -3374,7 +3374,7 @@ void CMTask::regular_clock_call() {
if (_cm->verbose_medium()) { if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, " gclog_or_tty->print_cr("[%u] regular clock, interval = %1.2lfms, "
"scanned = "SIZE_FORMAT"%s, refs reached = "SIZE_FORMAT"%s", "scanned = " SIZE_FORMAT "%s, refs reached = " SIZE_FORMAT "%s",
_worker_id, last_interval_ms, _worker_id, last_interval_ms,
_words_scanned, _words_scanned,
(_words_scanned >= _words_scanned_limit) ? " (*)" : "", (_words_scanned >= _words_scanned_limit) ? " (*)" : "",
@ -3543,7 +3543,7 @@ void CMTask::drain_local_queue(bool partially) {
statsOnly( ++_local_pops ); statsOnly( ++_local_pops );
if (_cm->verbose_high()) { if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id, gclog_or_tty->print_cr("[%u] popped " PTR_FORMAT, _worker_id,
p2i((void*) obj)); p2i((void*) obj));
} }
@ -3900,8 +3900,8 @@ void CMTask::do_marking_step(double time_target_ms,
if (_cm->verbose_low()) { if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%u] we're scanning part " gclog_or_tty->print_cr("[%u] we're scanning part "
"["PTR_FORMAT", "PTR_FORMAT") " "[" PTR_FORMAT ", " PTR_FORMAT ") "
"of region "HR_FORMAT, "of region " HR_FORMAT,
_worker_id, p2i(_finger), p2i(_region_limit), _worker_id, p2i(_finger), p2i(_region_limit),
HR_FORMAT_PARAMS(_curr_region)); HR_FORMAT_PARAMS(_curr_region));
} }
@ -3988,7 +3988,7 @@ void CMTask::do_marking_step(double time_target_ms,
if (_cm->verbose_low()) { if (_cm->verbose_low()) {
gclog_or_tty->print_cr("[%u] we successfully claimed " gclog_or_tty->print_cr("[%u] we successfully claimed "
"region "PTR_FORMAT, "region " PTR_FORMAT,
_worker_id, p2i(claimed_region)); _worker_id, p2i(claimed_region));
} }
@ -4049,7 +4049,7 @@ void CMTask::do_marking_step(double time_target_ms,
if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) { if (_cm->try_stealing(_worker_id, &_hash_seed, obj)) {
if (_cm->verbose_medium()) { if (_cm->verbose_medium()) {
gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully", gclog_or_tty->print_cr("[%u] stolen " PTR_FORMAT " successfully",
_worker_id, p2i((void*) obj)); _worker_id, p2i((void*) obj));
} }
@ -4257,7 +4257,7 @@ CMTask::CMTask(uint worker_id,
// identify them easily in a large log file. // identify them easily in a large log file.
#define G1PPRL_LINE_PREFIX "###" #define G1PPRL_LINE_PREFIX "###"
#define G1PPRL_ADDR_BASE_FORMAT " "PTR_FORMAT"-"PTR_FORMAT #define G1PPRL_ADDR_BASE_FORMAT " " PTR_FORMAT "-" PTR_FORMAT
#ifdef _LP64 #ifdef _LP64
#define G1PPRL_ADDR_BASE_H_FORMAT " %37s" #define G1PPRL_ADDR_BASE_H_FORMAT " %37s"
#else // _LP64 #else // _LP64
@ -4267,16 +4267,16 @@ CMTask::CMTask(uint worker_id,
// For per-region info // For per-region info
#define G1PPRL_TYPE_FORMAT " %-4s" #define G1PPRL_TYPE_FORMAT " %-4s"
#define G1PPRL_TYPE_H_FORMAT " %4s" #define G1PPRL_TYPE_H_FORMAT " %4s"
#define G1PPRL_BYTE_FORMAT " "SIZE_FORMAT_W(9) #define G1PPRL_BYTE_FORMAT " " SIZE_FORMAT_W(9)
#define G1PPRL_BYTE_H_FORMAT " %9s" #define G1PPRL_BYTE_H_FORMAT " %9s"
#define G1PPRL_DOUBLE_FORMAT " %14.1f" #define G1PPRL_DOUBLE_FORMAT " %14.1f"
#define G1PPRL_DOUBLE_H_FORMAT " %14s" #define G1PPRL_DOUBLE_H_FORMAT " %14s"
// For summary info // For summary info
#define G1PPRL_SUM_ADDR_FORMAT(tag) " "tag":"G1PPRL_ADDR_BASE_FORMAT #define G1PPRL_SUM_ADDR_FORMAT(tag) " " tag ":" G1PPRL_ADDR_BASE_FORMAT
#define G1PPRL_SUM_BYTE_FORMAT(tag) " "tag": "SIZE_FORMAT #define G1PPRL_SUM_BYTE_FORMAT(tag) " " tag ": " SIZE_FORMAT
#define G1PPRL_SUM_MB_FORMAT(tag) " "tag": %1.2f MB" #define G1PPRL_SUM_MB_FORMAT(tag) " " tag ": %1.2f MB"
#define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag)" / %1.2f %%" #define G1PPRL_SUM_MB_PERC_FORMAT(tag) G1PPRL_SUM_MB_FORMAT(tag) " / %1.2f %%"
G1PrintRegionLivenessInfoClosure:: G1PrintRegionLivenessInfoClosure::
G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name) G1PrintRegionLivenessInfoClosure(outputStream* out, const char* phase_name)

8
hotspot/src/share/vm/gc/g1/concurrentMark.inline.hpp
View file

@ -197,8 +197,8 @@ inline bool CMBitMapRO::iterate(BitMapClosure* cl) {
assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \ assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \
"outside underlying space?"); \ "outside underlying space?"); \
assert(G1CollectedHeap::heap()->is_in_exact(addr), \ assert(G1CollectedHeap::heap()->is_in_exact(addr), \
err_msg("Trying to access not available bitmap "PTR_FORMAT \ err_msg("Trying to access not available bitmap " PTR_FORMAT \
" corresponding to "PTR_FORMAT" (%u)", \ " corresponding to " PTR_FORMAT " (%u)", \
p2i(this), p2i(addr), G1CollectedHeap::heap()->addr_to_region(addr))); p2i(this), p2i(addr), G1CollectedHeap::heap()->addr_to_region(addr)));
inline void CMBitMap::mark(HeapWord* addr) { inline void CMBitMap::mark(HeapWord* addr) {
@ -344,7 +344,7 @@ inline void CMTask::make_reference_grey(oop obj, HeapRegion* hr) {
inline void CMTask::deal_with_reference(oop obj) { inline void CMTask::deal_with_reference(oop obj) {
if (_cm->verbose_high()) { if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%u] we're dealing with reference = "PTR_FORMAT, gclog_or_tty->print_cr("[%u] we're dealing with reference = " PTR_FORMAT,
_worker_id, p2i((void*) obj)); _worker_id, p2i((void*) obj));
} }
@ -393,7 +393,7 @@ inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
// assert that word_size is under an upper bound which is its // assert that word_size is under an upper bound which is its
// containing region's capacity. // containing region's capacity.
assert(word_size * HeapWordSize <= hr->capacity(), assert(word_size * HeapWordSize <= hr->capacity(),
err_msg("size: "SIZE_FORMAT" capacity: "SIZE_FORMAT" "HR_FORMAT, err_msg("size: " SIZE_FORMAT " capacity: " SIZE_FORMAT " " HR_FORMAT,
word_size * HeapWordSize, hr->capacity(), word_size * HeapWordSize, hr->capacity(),
HR_FORMAT_PARAMS(hr))); HR_FORMAT_PARAMS(hr)));

4
hotspot/src/share/vm/gc/g1/g1AllocRegion.cpp
View file

@ -140,7 +140,7 @@ HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size,
} }
void G1AllocRegion::fill_in_ext_msg(ar_ext_msg* msg, const char* message) { void G1AllocRegion::fill_in_ext_msg(ar_ext_msg* msg, const char* message) {
msg->append("[%s] %s c: %u b: %s r: "PTR_FORMAT" u: "SIZE_FORMAT, msg->append("[%s] %s c: %u b: %s r: " PTR_FORMAT " u: " SIZE_FORMAT,
_name, message, _count, BOOL_TO_STR(_bot_updates), _name, message, _count, BOOL_TO_STR(_bot_updates),
p2i(_alloc_region), _used_bytes_before); p2i(_alloc_region), _used_bytes_before);
} }
@ -217,7 +217,7 @@ void G1AllocRegion::trace(const char* str, size_t word_size, HeapWord* result) {
if (G1_ALLOC_REGION_TRACING > 1) { if (G1_ALLOC_REGION_TRACING > 1) {
if (result != NULL) { if (result != NULL) {
jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT" "PTR_FORMAT, jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT " " PTR_FORMAT,
word_size, result); word_size, result);
} else if (word_size != 0) { } else if (word_size != 0) {
jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT, word_size); jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT, word_size);

2
hotspot/src/share/vm/gc/g1/g1Allocator.hpp
View file

@ -76,7 +76,7 @@ public:
void decrease_used(size_t bytes) { void decrease_used(size_t bytes) {
assert(_summary_bytes_used >= bytes, assert(_summary_bytes_used >= bytes,
err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" should be >= bytes: "SIZE_FORMAT, err_msg("invariant: _summary_bytes_used: " SIZE_FORMAT " should be >= bytes: " SIZE_FORMAT,
_summary_bytes_used, bytes)); _summary_bytes_used, bytes));
_summary_bytes_used -= bytes; _summary_bytes_used -= bytes;
} }

6
hotspot/src/share/vm/gc/g1/g1BiasedArray.cpp
View file

@ -36,19 +36,19 @@ address G1BiasedMappedArrayBase::create_new_base_array(size_t length, size_t ele
#ifndef PRODUCT #ifndef PRODUCT
void G1BiasedMappedArrayBase::verify_index(idx_t index) const { void G1BiasedMappedArrayBase::verify_index(idx_t index) const {
guarantee(_base != NULL, "Array not initialized"); guarantee(_base != NULL, "Array not initialized");
guarantee(index < length(), err_msg("Index out of bounds index: "SIZE_FORMAT" length: "SIZE_FORMAT, index, length())); guarantee(index < length(), err_msg("Index out of bounds index: " SIZE_FORMAT " length: " SIZE_FORMAT, index, length()));
} }
void G1BiasedMappedArrayBase::verify_biased_index(idx_t biased_index) const { void G1BiasedMappedArrayBase::verify_biased_index(idx_t biased_index) const {
guarantee(_biased_base != NULL, "Array not initialized"); guarantee(_biased_base != NULL, "Array not initialized");
guarantee(biased_index >= bias() && biased_index < (bias() + length()), guarantee(biased_index >= bias() && biased_index < (bias() + length()),
err_msg("Biased index out of bounds, index: "SIZE_FORMAT" bias: "SIZE_FORMAT" length: "SIZE_FORMAT, biased_index, bias(), length())); err_msg("Biased index out of bounds, index: " SIZE_FORMAT " bias: " SIZE_FORMAT " length: " SIZE_FORMAT, biased_index, bias(), length()));
} }
void G1BiasedMappedArrayBase::verify_biased_index_inclusive_end(idx_t biased_index) const { void G1BiasedMappedArrayBase::verify_biased_index_inclusive_end(idx_t biased_index) const {
guarantee(_biased_base != NULL, "Array not initialized"); guarantee(_biased_base != NULL, "Array not initialized");
guarantee(biased_index >= bias() && biased_index <= (bias() + length()), guarantee(biased_index >= bias() && biased_index <= (bias() + length()),
err_msg("Biased index out of inclusive bounds, index: "SIZE_FORMAT" bias: "SIZE_FORMAT" length: "SIZE_FORMAT, biased_index, bias(), length())); err_msg("Biased index out of inclusive bounds, index: " SIZE_FORMAT " bias: " SIZE_FORMAT " length: " SIZE_FORMAT, biased_index, bias(), length()));
} }
class TestMappedArray : public G1BiasedMappedArray<int> { class TestMappedArray : public G1BiasedMappedArray<int> {

4
hotspot/src/share/vm/gc/g1/g1BiasedArray.hpp
View file

@ -71,10 +71,10 @@ protected:
assert(is_power_of_2(mapping_granularity_in_bytes), assert(is_power_of_2(mapping_granularity_in_bytes),
err_msg("mapping granularity must be power of 2, is %zd", mapping_granularity_in_bytes)); err_msg("mapping granularity must be power of 2, is %zd", mapping_granularity_in_bytes));
assert((uintptr_t)bottom % mapping_granularity_in_bytes == 0, assert((uintptr_t)bottom % mapping_granularity_in_bytes == 0,
err_msg("bottom mapping area address must be a multiple of mapping granularity %zd, is "PTR_FORMAT, err_msg("bottom mapping area address must be a multiple of mapping granularity %zd, is " PTR_FORMAT,
mapping_granularity_in_bytes, p2i(bottom))); mapping_granularity_in_bytes, p2i(bottom)));
assert((uintptr_t)end % mapping_granularity_in_bytes == 0, assert((uintptr_t)end % mapping_granularity_in_bytes == 0,
err_msg("end mapping area address must be a multiple of mapping granularity %zd, is "PTR_FORMAT, err_msg("end mapping area address must be a multiple of mapping granularity %zd, is " PTR_FORMAT,
mapping_granularity_in_bytes, p2i(end))); mapping_granularity_in_bytes, p2i(end)));
size_t num_target_elems = pointer_delta(end, bottom, mapping_granularity_in_bytes); size_t num_target_elems = pointer_delta(end, bottom, mapping_granularity_in_bytes);
idx_t bias = (uintptr_t)bottom / mapping_granularity_in_bytes; idx_t bias = (uintptr_t)bottom / mapping_granularity_in_bytes;

14
hotspot/src/share/vm/gc/g1/g1BlockOffsetTable.cpp
View file

@ -69,10 +69,10 @@ bool G1BlockOffsetSharedArray::is_card_boundary(HeapWord* p) const {
#ifdef ASSERT #ifdef ASSERT
void G1BlockOffsetSharedArray::check_index(size_t index, const char* msg) const { void G1BlockOffsetSharedArray::check_index(size_t index, const char* msg) const {
assert((index) < (_reserved.word_size() >> LogN_words), assert((index) < (_reserved.word_size() >> LogN_words),
err_msg("%s - index: "SIZE_FORMAT", _vs.committed_size: "SIZE_FORMAT, err_msg("%s - index: " SIZE_FORMAT ", _vs.committed_size: " SIZE_FORMAT,
msg, (index), (_reserved.word_size() >> LogN_words))); msg, (index), (_reserved.word_size() >> LogN_words)));
assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)), assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)),
err_msg("Index "SIZE_FORMAT" corresponding to "PTR_FORMAT err_msg("Index " SIZE_FORMAT " corresponding to " PTR_FORMAT
" (%u) is not in committed area.", " (%u) is not in committed area.",
(index), (index),
p2i(address_for_index_raw(index)), p2i(address_for_index_raw(index)),
@ -430,11 +430,11 @@ void
G1BlockOffsetArray::print_on(outputStream* out) { G1BlockOffsetArray::print_on(outputStream* out) {
size_t from_index = _array->index_for(_bottom); size_t from_index = _array->index_for(_bottom);
size_t to_index = _array->index_for(_end); size_t to_index = _array->index_for(_end);
out->print_cr(">> BOT for area ["PTR_FORMAT","PTR_FORMAT") " out->print_cr(">> BOT for area [" PTR_FORMAT "," PTR_FORMAT ") "
"cards ["SIZE_FORMAT","SIZE_FORMAT")", "cards [" SIZE_FORMAT "," SIZE_FORMAT ")",
p2i(_bottom), p2i(_end), from_index, to_index); p2i(_bottom), p2i(_end), from_index, to_index);
for (size_t i = from_index; i < to_index; ++i) { for (size_t i = from_index; i < to_index; ++i) {
out->print_cr(" entry "SIZE_FORMAT_W(8)" | "PTR_FORMAT" : %3u", out->print_cr(" entry " SIZE_FORMAT_W(8) " | " PTR_FORMAT " : %3u",
i, p2i(_array->address_for_index(i)), i, p2i(_array->address_for_index(i)),
(uint) _array->offset_array(i)); (uint) _array->offset_array(i));
} }
@ -514,7 +514,7 @@ G1BlockOffsetArrayContigSpace::set_for_starts_humongous(HeapWord* new_top) {
void void
G1BlockOffsetArrayContigSpace::print_on(outputStream* out) { G1BlockOffsetArrayContigSpace::print_on(outputStream* out) {
G1BlockOffsetArray::print_on(out); G1BlockOffsetArray::print_on(out);
out->print_cr(" next offset threshold: "PTR_FORMAT, p2i(_next_offset_threshold)); out->print_cr(" next offset threshold: " PTR_FORMAT, p2i(_next_offset_threshold));
out->print_cr(" next offset index: "SIZE_FORMAT, _next_offset_index); out->print_cr(" next offset index: " SIZE_FORMAT, _next_offset_index);
} }
#endif // !PRODUCT #endif // !PRODUCT

2
hotspot/src/share/vm/gc/g1/g1BlockOffsetTable.hpp
View file

@ -150,7 +150,7 @@ private:
void check_offset(size_t offset, const char* msg) const { void check_offset(size_t offset, const char* msg) const {
assert(offset <= N_words, assert(offset <= N_words,
err_msg("%s - " err_msg("%s - "
"offset: " SIZE_FORMAT", N_words: %u", "offset: " SIZE_FORMAT ", N_words: %u",
msg, offset, (uint)N_words)); msg, offset, (uint)N_words));
} }

4
hotspot/src/share/vm/gc/g1/g1CardCounts.cpp
View file

@ -53,7 +53,7 @@ size_t G1CardCounts::heap_map_factor() {
void G1CardCounts::clear_range(size_t from_card_num, size_t to_card_num) { void G1CardCounts::clear_range(size_t from_card_num, size_t to_card_num) {
if (has_count_table()) { if (has_count_table()) {
assert(from_card_num < to_card_num, assert(from_card_num < to_card_num,
err_msg("Wrong order? from: " SIZE_FORMAT ", to: "SIZE_FORMAT, err_msg("Wrong order? from: " SIZE_FORMAT ", to: " SIZE_FORMAT,
from_card_num, to_card_num)); from_card_num, to_card_num));
Copy::fill_to_bytes(&_card_counts[from_card_num], (to_card_num - from_card_num)); Copy::fill_to_bytes(&_card_counts[from_card_num], (to_card_num - from_card_num));
} }
@ -96,7 +96,7 @@ uint G1CardCounts::add_card_count(jbyte* card_ptr) {
if (has_count_table()) { if (has_count_table()) {
size_t card_num = ptr_2_card_num(card_ptr); size_t card_num = ptr_2_card_num(card_ptr);
assert(card_num < _reserved_max_card_num, assert(card_num < _reserved_max_card_num,
err_msg("Card "SIZE_FORMAT" outside of card counts table (max size "SIZE_FORMAT")", err_msg("Card " SIZE_FORMAT " outside of card counts table (max size " SIZE_FORMAT ")",
card_num, _reserved_max_card_num)); card_num, _reserved_max_card_num));
count = (uint) _card_counts[card_num]; count = (uint) _card_counts[card_num];
if (count < G1ConcRSHotCardLimit) { if (count < G1ConcRSHotCardLimit) {

2
hotspot/src/share/vm/gc/g1/g1CardCounts.hpp
View file

@ -91,7 +91,7 @@ class G1CardCounts: public CHeapObj<mtGC> {
jbyte* card_num_2_ptr(size_t card_num) { jbyte* card_num_2_ptr(size_t card_num) {
assert(card_num < _reserved_max_card_num, assert(card_num < _reserved_max_card_num,
err_msg("card num out of range: "SIZE_FORMAT, card_num)); err_msg("card num out of range: " SIZE_FORMAT, card_num));
return (jbyte*) (_ct_bot + card_num); return (jbyte*) (_ct_bot + card_num);
} }

12
hotspot/src/share/vm/gc/g1/g1CodeCacheRemSet.cpp
View file

@ -350,11 +350,11 @@ class G1CodeRootSetTest {
assert(set1.is_empty(), "Code root set must be initially empty but is not."); assert(set1.is_empty(), "Code root set must be initially empty but is not.");
assert(G1CodeRootSet::static_mem_size() == sizeof(void*), assert(G1CodeRootSet::static_mem_size() == sizeof(void*),
err_msg("The code root set's static memory usage is incorrect, "SIZE_FORMAT" bytes", G1CodeRootSet::static_mem_size())); err_msg("The code root set's static memory usage is incorrect, " SIZE_FORMAT " bytes", G1CodeRootSet::static_mem_size()));
set1.add((nmethod*)1); set1.add((nmethod*)1);
assert(set1.length() == 1, err_msg("Added exactly one element, but set contains " assert(set1.length() == 1, err_msg("Added exactly one element, but set contains "
SIZE_FORMAT" elements", set1.length())); SIZE_FORMAT " elements", set1.length()));
const size_t num_to_add = (size_t)G1CodeRootSet::Threshold + 1; const size_t num_to_add = (size_t)G1CodeRootSet::Threshold + 1;
@ -363,14 +363,14 @@ class G1CodeRootSetTest {
} }
assert(set1.length() == 1, assert(set1.length() == 1,
err_msg("Duplicate detection should not have increased the set size but " err_msg("Duplicate detection should not have increased the set size but "
"is "SIZE_FORMAT, set1.length())); "is " SIZE_FORMAT, set1.length()));
for (size_t i = 2; i <= num_to_add; i++) { for (size_t i = 2; i <= num_to_add; i++) {
set1.add((nmethod*)(uintptr_t)(i)); set1.add((nmethod*)(uintptr_t)(i));
} }
assert(set1.length() == num_to_add, assert(set1.length() == num_to_add,
err_msg("After adding in total "SIZE_FORMAT" distinct code roots, they " err_msg("After adding in total " SIZE_FORMAT " distinct code roots, they "
"need to be in the set, but there are only "SIZE_FORMAT, "need to be in the set, but there are only " SIZE_FORMAT,
num_to_add, set1.length())); num_to_add, set1.length()));
assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable"); assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable");
@ -385,7 +385,7 @@ class G1CodeRootSetTest {
} }
} }
assert(num_popped == num_to_add, assert(num_popped == num_to_add,
err_msg("Managed to pop "SIZE_FORMAT" code roots, but only "SIZE_FORMAT" " err_msg("Managed to pop " SIZE_FORMAT " code roots, but only " SIZE_FORMAT " "
"were added", num_popped, num_to_add)); "were added", num_popped, num_to_add));
assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable"); assert(CodeRootSetTable::_purge_list != NULL, "should have grown to large hashtable");

66
hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp
View file

@ -197,7 +197,7 @@ bool YoungList::check_list_well_formed() {
HeapRegion* last = NULL; HeapRegion* last = NULL;
while (curr != NULL) { while (curr != NULL) {
if (!curr->is_young()) { if (!curr->is_young()) {
gclog_or_tty->print_cr("### YOUNG REGION "PTR_FORMAT"-"PTR_FORMAT" " gclog_or_tty->print_cr("### YOUNG REGION " PTR_FORMAT "-" PTR_FORMAT " "
"incorrectly tagged (y: %d, surv: %d)", "incorrectly tagged (y: %d, surv: %d)",
p2i(curr->bottom()), p2i(curr->end()), p2i(curr->bottom()), p2i(curr->end()),
curr->is_young(), curr->is_survivor()); curr->is_young(), curr->is_survivor());
@ -326,7 +326,7 @@ void YoungList::print() {
if (curr == NULL) if (curr == NULL)
gclog_or_tty->print_cr(" empty"); gclog_or_tty->print_cr(" empty");
while (curr != NULL) { while (curr != NULL) {
gclog_or_tty->print_cr(" "HR_FORMAT", P: "PTR_FORMAT ", N: "PTR_FORMAT", age: %4d", gclog_or_tty->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT ", N: " PTR_FORMAT ", age: %4d",
HR_FORMAT_PARAMS(curr), HR_FORMAT_PARAMS(curr),
p2i(curr->prev_top_at_mark_start()), p2i(curr->prev_top_at_mark_start()),
p2i(curr->next_top_at_mark_start()), p2i(curr->next_top_at_mark_start()),
@ -430,7 +430,7 @@ G1CollectedHeap::new_region_try_secondary_free_list(bool is_old) {
HeapRegion* res = _hrm.allocate_free_region(is_old); HeapRegion* res = _hrm.allocate_free_region(is_old);
if (G1ConcRegionFreeingVerbose) { if (G1ConcRegionFreeingVerbose) {
gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : "
"allocated "HR_FORMAT" from secondary_free_list", "allocated " HR_FORMAT " from secondary_free_list",
HR_FORMAT_PARAMS(res)); HR_FORMAT_PARAMS(res));
} }
return res; return res;
@ -1670,8 +1670,8 @@ resize_if_necessary_after_full_collection(size_t word_size) {
// This assert only makes sense here, before we adjust them // This assert only makes sense here, before we adjust them
// with respect to the min and max heap size. // with respect to the min and max heap size.
assert(minimum_desired_capacity <= maximum_desired_capacity, assert(minimum_desired_capacity <= maximum_desired_capacity,
err_msg("minimum_desired_capacity = "SIZE_FORMAT", " err_msg("minimum_desired_capacity = " SIZE_FORMAT ", "
"maximum_desired_capacity = "SIZE_FORMAT, "maximum_desired_capacity = " SIZE_FORMAT,
minimum_desired_capacity, maximum_desired_capacity)); minimum_desired_capacity, maximum_desired_capacity));
// Should not be greater than the heap max size. No need to adjust // Should not be greater than the heap max size. No need to adjust
@ -2332,7 +2332,7 @@ public:
virtual bool doHeapRegion(HeapRegion* hr) { virtual bool doHeapRegion(HeapRegion* hr) {
unsigned region_gc_time_stamp = hr->get_gc_time_stamp(); unsigned region_gc_time_stamp = hr->get_gc_time_stamp();
if (_gc_time_stamp != region_gc_time_stamp) { if (_gc_time_stamp != region_gc_time_stamp) {
gclog_or_tty->print_cr("Region "HR_FORMAT" has GC time stamp = %d, " gclog_or_tty->print_cr("Region " HR_FORMAT " has GC time stamp = %d, "
"expected %d", HR_FORMAT_PARAMS(hr), "expected %d", HR_FORMAT_PARAMS(hr),
region_gc_time_stamp, _gc_time_stamp); region_gc_time_stamp, _gc_time_stamp);
_failures = true; _failures = true;
@ -2926,10 +2926,10 @@ public:
if (!oopDesc::is_null(heap_oop)) { if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
if (_g1h->is_obj_dead_cond(obj, _vo)) { if (_g1h->is_obj_dead_cond(obj, _vo)) {
gclog_or_tty->print_cr("Root location "PTR_FORMAT" " gclog_or_tty->print_cr("Root location " PTR_FORMAT " "
"points to dead obj "PTR_FORMAT, p2i(p), p2i(obj)); "points to dead obj " PTR_FORMAT, p2i(p), p2i(obj));
if (_vo == VerifyOption_G1UseMarkWord) { if (_vo == VerifyOption_G1UseMarkWord) {
gclog_or_tty->print_cr(" Mark word: "INTPTR_FORMAT, (intptr_t)obj->mark()); gclog_or_tty->print_cr(" Mark word: " INTPTR_FORMAT, (intptr_t)obj->mark());
} }
obj->print_on(gclog_or_tty); obj->print_on(gclog_or_tty);
_failures = true; _failures = true;
@ -2976,9 +2976,9 @@ class G1VerifyCodeRootOopClosure: public OopClosure {
// Verify that the strong code root list for this region // Verify that the strong code root list for this region
// contains the nmethod // contains the nmethod
if (!hrrs->strong_code_roots_list_contains(_nm)) { if (!hrrs->strong_code_roots_list_contains(_nm)) {
gclog_or_tty->print_cr("Code root location "PTR_FORMAT" " gclog_or_tty->print_cr("Code root location " PTR_FORMAT " "
"from nmethod "PTR_FORMAT" not in strong " "from nmethod " PTR_FORMAT " not in strong "
"code roots for region ["PTR_FORMAT","PTR_FORMAT")", "code roots for region [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(p), p2i(_nm), p2i(hr->bottom()), p2i(hr->end())); p2i(p), p2i(_nm), p2i(hr->bottom()), p2i(hr->end()));
_failures = true; _failures = true;
} }
@ -3157,9 +3157,9 @@ public:
r->object_iterate(&not_dead_yet_cl); r->object_iterate(&not_dead_yet_cl);
if (_vo != VerifyOption_G1UseNextMarking) { if (_vo != VerifyOption_G1UseNextMarking) {
if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) {
gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] " gclog_or_tty->print_cr("[" PTR_FORMAT "," PTR_FORMAT "] "
"max_live_bytes "SIZE_FORMAT" " "max_live_bytes " SIZE_FORMAT " "
"< calculated "SIZE_FORMAT, "< calculated " SIZE_FORMAT,
p2i(r->bottom()), p2i(r->end()), p2i(r->bottom()), p2i(r->end()),
r->max_live_bytes(), r->max_live_bytes(),
not_dead_yet_cl.live_bytes()); not_dead_yet_cl.live_bytes());
@ -3444,7 +3444,7 @@ public:
size_t occupied = hrrs->occupied(); size_t occupied = hrrs->occupied();
_occupied_sum += occupied; _occupied_sum += occupied;
gclog_or_tty->print_cr("Printing RSet for region "HR_FORMAT, gclog_or_tty->print_cr("Printing RSet for region " HR_FORMAT,
HR_FORMAT_PARAMS(r)); HR_FORMAT_PARAMS(r));
if (occupied == 0) { if (occupied == 0) {
gclog_or_tty->print_cr(" RSet is empty"); gclog_or_tty->print_cr(" RSet is empty");
@ -3463,7 +3463,7 @@ public:
} }
~PrintRSetsClosure() { ~PrintRSetsClosure() {
gclog_or_tty->print_cr("Occupied Sum: "SIZE_FORMAT, _occupied_sum); gclog_or_tty->print_cr("Occupied Sum: " SIZE_FORMAT, _occupied_sum);
gclog_or_tty->print_cr("========================================"); gclog_or_tty->print_cr("========================================");
gclog_or_tty->cr(); gclog_or_tty->cr();
} }
@ -4308,7 +4308,7 @@ oop
G1CollectedHeap::handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state, G1CollectedHeap::handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state,
oop old) { oop old) {
assert(obj_in_cs(old), assert(obj_in_cs(old),
err_msg("obj: "PTR_FORMAT" should still be in the CSet", err_msg("obj: " PTR_FORMAT " should still be in the CSet",
p2i(old))); p2i(old)));
markOop m = old->mark(); markOop m = old->mark();
oop forward_ptr = old->forward_to_atomic(old); oop forward_ptr = old->forward_to_atomic(old);
@ -4342,7 +4342,7 @@ G1CollectedHeap::handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_s
// space for this object (old != forward_ptr) or they beat us in // space for this object (old != forward_ptr) or they beat us in
// self-forwarding it (old == forward_ptr). // self-forwarding it (old == forward_ptr).
assert(old == forward_ptr || !obj_in_cs(forward_ptr), assert(old == forward_ptr || !obj_in_cs(forward_ptr),
err_msg("obj: "PTR_FORMAT" forwarded to: "PTR_FORMAT" " err_msg("obj: " PTR_FORMAT " forwarded to: " PTR_FORMAT " "
"should not be in the CSet", "should not be in the CSet",
p2i(old), p2i(forward_ptr))); p2i(old), p2i(forward_ptr)));
return forward_ptr; return forward_ptr;
@ -4730,8 +4730,8 @@ public:
if (G1TraceStringSymbolTableScrubbing) { if (G1TraceStringSymbolTableScrubbing) {
gclog_or_tty->print_cr("Cleaned string and symbol table, " gclog_or_tty->print_cr("Cleaned string and symbol table, "
"strings: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed, " "strings: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed, "
"symbols: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed", "symbols: " SIZE_FORMAT " processed, " SIZE_FORMAT " removed",
strings_processed(), strings_removed(), strings_processed(), strings_removed(),
symbols_processed(), symbols_removed()); symbols_processed(), symbols_removed());
} }
@ -5828,13 +5828,13 @@ void G1CollectedHeap::verify_dirty_young_regions() {
bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap, bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap,
HeapWord* tams, HeapWord* end) { HeapWord* tams, HeapWord* end) {
guarantee(tams <= end, guarantee(tams <= end,
err_msg("tams: "PTR_FORMAT" end: "PTR_FORMAT, p2i(tams), p2i(end))); err_msg("tams: " PTR_FORMAT " end: " PTR_FORMAT, p2i(tams), p2i(end)));
HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end); HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end);
if (result < end) { if (result < end) {
gclog_or_tty->cr(); gclog_or_tty->cr();
gclog_or_tty->print_cr("## wrong marked address on %s bitmap: "PTR_FORMAT, gclog_or_tty->print_cr("## wrong marked address on %s bitmap: " PTR_FORMAT,
bitmap_name, p2i(result)); bitmap_name, p2i(result));
gclog_or_tty->print_cr("## %s tams: "PTR_FORMAT" end: "PTR_FORMAT, gclog_or_tty->print_cr("## %s tams: " PTR_FORMAT " end: " PTR_FORMAT,
bitmap_name, p2i(tams), p2i(end)); bitmap_name, p2i(tams), p2i(end));
return false; return false;
} }
@ -5860,7 +5860,7 @@ bool G1CollectedHeap::verify_bitmaps(const char* caller, HeapRegion* hr) {
res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end); res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end);
} }
if (!res_p || !res_n) { if (!res_p || !res_n) {
gclog_or_tty->print_cr("#### Bitmap verification failed for "HR_FORMAT, gclog_or_tty->print_cr("#### Bitmap verification failed for " HR_FORMAT,
HR_FORMAT_PARAMS(hr)); HR_FORMAT_PARAMS(hr));
gclog_or_tty->print_cr("#### Caller: %s", caller); gclog_or_tty->print_cr("#### Caller: %s", caller);
return false; return false;
@ -6157,7 +6157,7 @@ class G1FreeHumongousRegionClosure : public HeapRegionClosure {
!r->rem_set()->is_empty()) { !r->rem_set()->is_empty()) {
if (G1TraceEagerReclaimHumongousObjects) { if (G1TraceEagerReclaimHumongousObjects) {
gclog_or_tty->print_cr("Live humongous region %u size "SIZE_FORMAT" start "PTR_FORMAT" length %u with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d reclaim candidate %d type array %d", gclog_or_tty->print_cr("Live humongous region %u size " SIZE_FORMAT " start " PTR_FORMAT " length %u with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d",
region_idx, region_idx,
(size_t)obj->size() * HeapWordSize, (size_t)obj->size() * HeapWordSize,
p2i(r->bottom()), p2i(r->bottom()),
@ -6179,7 +6179,7 @@ class G1FreeHumongousRegionClosure : public HeapRegionClosure {
p2i(r->bottom()))); p2i(r->bottom())));
if (G1TraceEagerReclaimHumongousObjects) { if (G1TraceEagerReclaimHumongousObjects) {
gclog_or_tty->print_cr("Dead humongous region %u size "SIZE_FORMAT" start "PTR_FORMAT" length %u with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d reclaim candidate %d type array %d", gclog_or_tty->print_cr("Dead humongous region %u size " SIZE_FORMAT " start " PTR_FORMAT " length %u with remset " SIZE_FORMAT " code roots " SIZE_FORMAT " is marked %d reclaim candidate %d type array %d",
region_idx, region_idx,
(size_t)obj->size() * HeapWordSize, (size_t)obj->size() * HeapWordSize,
p2i(r->bottom()), p2i(r->bottom()),
@ -6333,7 +6333,7 @@ public:
NoYoungRegionsClosure() : _success(true) { } NoYoungRegionsClosure() : _success(true) { }
bool doHeapRegion(HeapRegion* r) { bool doHeapRegion(HeapRegion* r) {
if (r->is_young()) { if (r->is_young()) {
gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", gclog_or_tty->print_cr("Region [" PTR_FORMAT ", " PTR_FORMAT ") tagged as young",
p2i(r->bottom()), p2i(r->end())); p2i(r->bottom()), p2i(r->end()));
_success = false; _success = false;
} }
@ -6470,7 +6470,7 @@ void G1CollectedHeap::rebuild_region_sets(bool free_list_only) {
} }
assert(_allocator->used_unlocked() == recalculate_used(), assert(_allocator->used_unlocked() == recalculate_used(),
err_msg("inconsistent _allocator->used_unlocked(), " err_msg("inconsistent _allocator->used_unlocked(), "
"value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, "value: " SIZE_FORMAT " recalculated: " SIZE_FORMAT,
_allocator->used_unlocked(), recalculate_used())); _allocator->used_unlocked(), recalculate_used()));
} }
@ -6697,8 +6697,8 @@ class RegisterNMethodOopClosure: public OopClosure {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
HeapRegion* hr = _g1h->heap_region_containing(obj); HeapRegion* hr = _g1h->heap_region_containing(obj);
assert(!hr->is_continues_humongous(), assert(!hr->is_continues_humongous(),
err_msg("trying to add code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT err_msg("trying to add code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
" starting at "HR_FORMAT, " starting at " HR_FORMAT,
p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
// HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries. // HeapRegion::add_strong_code_root_locked() avoids adding duplicate entries.
@ -6724,8 +6724,8 @@ class UnregisterNMethodOopClosure: public OopClosure {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
HeapRegion* hr = _g1h->heap_region_containing(obj); HeapRegion* hr = _g1h->heap_region_containing(obj);
assert(!hr->is_continues_humongous(), assert(!hr->is_continues_humongous(),
err_msg("trying to remove code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT err_msg("trying to remove code root " PTR_FORMAT " in continuation of humongous region " HR_FORMAT
" starting at "HR_FORMAT, " starting at " HR_FORMAT,
p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); p2i(_nm), HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
hr->remove_strong_code_root(_nm); hr->remove_strong_code_root(_nm);

4
hotspot/src/share/vm/gc/g1/g1CollectedHeap.inline.hpp
View file

@ -82,7 +82,7 @@ inline HeapRegion* G1CollectedHeap::region_at(uint index) const { return _hrm.at
inline uint G1CollectedHeap::addr_to_region(HeapWord* addr) const { inline uint G1CollectedHeap::addr_to_region(HeapWord* addr) const {
assert(is_in_reserved(addr), assert(is_in_reserved(addr),
err_msg("Cannot calculate region index for address "PTR_FORMAT" that is outside of the heap ["PTR_FORMAT", "PTR_FORMAT")", err_msg("Cannot calculate region index for address " PTR_FORMAT " that is outside of the heap [" PTR_FORMAT ", " PTR_FORMAT ")",
p2i(addr), p2i(reserved_region().start()), p2i(reserved_region().end()))); p2i(addr), p2i(reserved_region().start()), p2i(reserved_region().end())));
return (uint)(pointer_delta(addr, reserved_region().start(), sizeof(uint8_t)) >> HeapRegion::LogOfHRGrainBytes); return (uint)(pointer_delta(addr, reserved_region().start(), sizeof(uint8_t)) >> HeapRegion::LogOfHRGrainBytes);
} }
@ -95,7 +95,7 @@ template <class T>
inline HeapRegion* G1CollectedHeap::heap_region_containing_raw(const T addr) const { inline HeapRegion* G1CollectedHeap::heap_region_containing_raw(const T addr) const {
assert(addr != NULL, "invariant"); assert(addr != NULL, "invariant");
assert(is_in_g1_reserved((const void*) addr), assert(is_in_g1_reserved((const void*) addr),
err_msg("Address "PTR_FORMAT" is outside of the heap ranging from ["PTR_FORMAT" to "PTR_FORMAT")", err_msg("Address " PTR_FORMAT " is outside of the heap ranging from [" PTR_FORMAT " to " PTR_FORMAT ")",
p2i((void*)addr), p2i(g1_reserved().start()), p2i(g1_reserved().end()))); p2i((void*)addr), p2i(g1_reserved().start()), p2i(g1_reserved().end())));
return _hrm.addr_to_region((HeapWord*) addr); return _hrm.addr_to_region((HeapWord*) addr);
} }

14
hotspot/src/share/vm/gc/g1/g1CollectorPolicy.cpp
View file

@ -184,7 +184,7 @@ G1CollectorPolicy::G1CollectorPolicy() :
const size_t region_size = HeapRegion::GrainWords; const size_t region_size = HeapRegion::GrainWords;
if (YoungPLABSize > region_size || OldPLABSize > region_size) { if (YoungPLABSize > region_size || OldPLABSize > region_size) {
char buffer[128]; char buffer[128];
jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most "SIZE_FORMAT, jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most " SIZE_FORMAT,
OldPLABSize > region_size ? "Old" : "Young", region_size); OldPLABSize > region_size ? "Old" : "Young", region_size);
vm_exit_during_initialization(buffer); vm_exit_during_initialization(buffer);
} }
@ -821,7 +821,7 @@ void G1CollectorPolicy::record_collection_pause_start(double start_time_sec) {
update_survivors_policy(); update_survivors_policy();
assert(_g1->used() == _g1->recalculate_used(), assert(_g1->used() == _g1->recalculate_used(),
err_msg("sanity, used: "SIZE_FORMAT" recalculate_used: "SIZE_FORMAT, err_msg("sanity, used: " SIZE_FORMAT " recalculate_used: " SIZE_FORMAT,
_g1->used(), _g1->recalculate_used())); _g1->used(), _g1->recalculate_used()));
double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0; double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;
@ -1216,10 +1216,10 @@ void G1CollectorPolicy::print_detailed_heap_transition(bool full) {
(_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc; (_young_list_target_length * HeapRegion::GrainBytes) - survivor_used_bytes_after_gc;
gclog_or_tty->print( gclog_or_tty->print(
" [Eden: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->"EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT") " " [Eden: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->" EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ") "
"Survivors: "EXT_SIZE_FORMAT"->"EXT_SIZE_FORMAT" " "Survivors: " EXT_SIZE_FORMAT "->" EXT_SIZE_FORMAT " "
"Heap: "EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")->" "Heap: " EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")->"
EXT_SIZE_FORMAT"("EXT_SIZE_FORMAT")]", EXT_SIZE_FORMAT "(" EXT_SIZE_FORMAT ")]",
EXT_SIZE_PARAMS(_eden_used_bytes_before_gc), EXT_SIZE_PARAMS(_eden_used_bytes_before_gc),
EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc), EXT_SIZE_PARAMS(_eden_capacity_bytes_before_gc),
EXT_SIZE_PARAMS(eden_used_bytes_after_gc), EXT_SIZE_PARAMS(eden_used_bytes_after_gc),
@ -1787,7 +1787,7 @@ void G1CollectorPolicy::print_collection_set(HeapRegion* list_head, outputStream
while (csr != NULL) { while (csr != NULL) {
HeapRegion* next = csr->next_in_collection_set(); HeapRegion* next = csr->next_in_collection_set();
assert(csr->in_collection_set(), "bad CS"); assert(csr->in_collection_set(), "bad CS");
st->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", st->print_cr(" " HR_FORMAT ", P: " PTR_FORMAT "N: " PTR_FORMAT ", age: %4d",
HR_FORMAT_PARAMS(csr), HR_FORMAT_PARAMS(csr),
p2i(csr->prev_top_at_mark_start()), p2i(csr->next_top_at_mark_start()), p2i(csr->prev_top_at_mark_start()), p2i(csr->next_top_at_mark_start()),
csr->age_in_surv_rate_group_cond()); csr->age_in_surv_rate_group_cond());

6
hotspot/src/share/vm/gc/g1/g1ErgoVerbose.hpp
View file

@ -121,15 +121,15 @@ public:
// Single parameter format strings // Single parameter format strings
#define ergo_format_str(_name_) ", " _name_ ": %s" #define ergo_format_str(_name_) ", " _name_ ": %s"
#define ergo_format_region(_name_) ", " _name_ ": %u regions" #define ergo_format_region(_name_) ", " _name_ ": %u regions"
#define ergo_format_byte(_name_) ", " _name_ ": "SIZE_FORMAT" bytes" #define ergo_format_byte(_name_) ", " _name_ ": " SIZE_FORMAT " bytes"
#define ergo_format_double(_name_) ", " _name_ ": %1.2f" #define ergo_format_double(_name_) ", " _name_ ": %1.2f"
#define ergo_format_perc(_name_) ", " _name_ ": %1.2f %%" #define ergo_format_perc(_name_) ", " _name_ ": %1.2f %%"
#define ergo_format_ms(_name_) ", " _name_ ": %1.2f ms" #define ergo_format_ms(_name_) ", " _name_ ": %1.2f ms"
#define ergo_format_size(_name_) ", " _name_ ": "SIZE_FORMAT #define ergo_format_size(_name_) ", " _name_ ": " SIZE_FORMAT
// Double parameter format strings // Double parameter format strings
#define ergo_format_byte_perc(_name_) \ #define ergo_format_byte_perc(_name_) \
", " _name_ ": "SIZE_FORMAT" bytes (%1.2f %%)" ", " _name_ ": " SIZE_FORMAT " bytes (%1.2f %%)"
// Generates the format string // Generates the format string
#define ergo_format(_extra_format_) \ #define ergo_format(_extra_format_) \

4
hotspot/src/share/vm/gc/g1/g1GCPhaseTimes.cpp
View file

@ -331,7 +331,7 @@ void G1GCPhaseTimes::print_stats(int level, const char* str, double value) {
} }
void G1GCPhaseTimes::print_stats(int level, const char* str, size_t value) { void G1GCPhaseTimes::print_stats(int level, const char* str, size_t value) {
LineBuffer(level).append_and_print_cr("[%s: "SIZE_FORMAT"]", str, value); LineBuffer(level).append_and_print_cr("[%s: " SIZE_FORMAT "]", str, value);
} }
void G1GCPhaseTimes::print_stats(int level, const char* str, double value, uint workers) { void G1GCPhaseTimes::print_stats(int level, const char* str, double value, uint workers) {
@ -451,7 +451,7 @@ class G1GCParPhasePrinter : public StackObj {
if (phase->_thread_work_items != NULL) { if (phase->_thread_work_items != NULL) {
LineBuffer buf2(phase->_thread_work_items->_indent_level); LineBuffer buf2(phase->_thread_work_items->_indent_level);
buf2.append_and_print_cr("[%s: "SIZE_FORMAT"]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id)); buf2.append_and_print_cr("[%s: " SIZE_FORMAT "]", phase->_thread_work_items->_title, _phase_times->sum_thread_work_items(phase_id));
} }
} }

12
hotspot/src/share/vm/gc/g1/g1HRPrinter.cpp
View file

@ -83,18 +83,18 @@ void G1HRPrinter::print(ActionType action, RegionType type,
if (type_str != NULL) { if (type_str != NULL) {
if (top != NULL) { if (top != NULL) {
gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT" "PTR_FORMAT, gclog_or_tty->print_cr(G1HR_PREFIX " %s(%s) " PTR_FORMAT " " PTR_FORMAT,
action_str, type_str, p2i(bottom), p2i(top)); action_str, type_str, p2i(bottom), p2i(top));
} else { } else {
gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT, gclog_or_tty->print_cr(G1HR_PREFIX " %s(%s) " PTR_FORMAT,
action_str, type_str, p2i(bottom)); action_str, type_str, p2i(bottom));
} }
} else { } else {
if (top != NULL) { if (top != NULL) {
gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT" "PTR_FORMAT, gclog_or_tty->print_cr(G1HR_PREFIX " %s " PTR_FORMAT " " PTR_FORMAT,
action_str, p2i(bottom), p2i(top)); action_str, p2i(bottom), p2i(top));
} else { } else {
gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT, gclog_or_tty->print_cr(G1HR_PREFIX " %s " PTR_FORMAT,
action_str, p2i(bottom)); action_str, p2i(bottom));
} }
} }
@ -103,11 +103,11 @@ void G1HRPrinter::print(ActionType action, RegionType type,
void G1HRPrinter::print(ActionType action, HeapWord* bottom, HeapWord* end) { void G1HRPrinter::print(ActionType action, HeapWord* bottom, HeapWord* end) {
const char* action_str = action_name(action); const char* action_str = action_name(action);
gclog_or_tty->print_cr(G1HR_PREFIX" %s ["PTR_FORMAT","PTR_FORMAT"]", gclog_or_tty->print_cr(G1HR_PREFIX " %s [" PTR_FORMAT "," PTR_FORMAT "]",
action_str, p2i(bottom), p2i(end)); action_str, p2i(bottom), p2i(end));
} }
void G1HRPrinter::print(PhaseType phase, size_t phase_num) { void G1HRPrinter::print(PhaseType phase, size_t phase_num) {
const char* phase_str = phase_name(phase); const char* phase_str = phase_name(phase);
gclog_or_tty->print_cr(G1HR_PREFIX" #%s "SIZE_FORMAT, phase_str, phase_num); gclog_or_tty->print_cr(G1HR_PREFIX " #%s " SIZE_FORMAT, phase_str, phase_num);
} }

6
hotspot/src/share/vm/gc/g1/g1InCSetState.hpp
View file

@ -104,7 +104,7 @@ class G1InCSetStateFastTestBiasedMappedArray : public G1BiasedMappedArray<InCSet
public: public:
void set_humongous(uintptr_t index) { void set_humongous(uintptr_t index) {
assert(get_by_index(index).is_default(), assert(get_by_index(index).is_default(),
err_msg("State at index " INTPTR_FORMAT" should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value())); err_msg("State at index " INTPTR_FORMAT " should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value()));
set_by_index(index, InCSetState::Humongous); set_by_index(index, InCSetState::Humongous);
} }
@ -114,13 +114,13 @@ class G1InCSetStateFastTestBiasedMappedArray : public G1BiasedMappedArray<InCSet
void set_in_young(uintptr_t index) { void set_in_young(uintptr_t index) {
assert(get_by_index(index).is_default(), assert(get_by_index(index).is_default(),
err_msg("State at index " INTPTR_FORMAT" should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value())); err_msg("State at index " INTPTR_FORMAT " should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value()));
set_by_index(index, InCSetState::Young); set_by_index(index, InCSetState::Young);
} }
void set_in_old(uintptr_t index) { void set_in_old(uintptr_t index) {
assert(get_by_index(index).is_default(), assert(get_by_index(index).is_default(),
err_msg("State at index " INTPTR_FORMAT" should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value())); err_msg("State at index " INTPTR_FORMAT " should be default but is " CSETSTATE_FORMAT, index, get_by_index(index).value()));
set_by_index(index, InCSetState::Old); set_by_index(index, InCSetState::Old);
} }

2
hotspot/src/share/vm/gc/g1/g1OopClosures.inline.hpp
View file

@ -118,7 +118,7 @@ inline void G1CMOopClosure::do_oop_nv(T* p) {
oop obj = oopDesc::load_decode_heap_oop(p); oop obj = oopDesc::load_decode_heap_oop(p);
if (_cm->verbose_high()) { if (_cm->verbose_high()) {
gclog_or_tty->print_cr("[%u] we're looking at location " gclog_or_tty->print_cr("[%u] we're looking at location "
"*"PTR_FORMAT" = "PTR_FORMAT, "*" PTR_FORMAT " = " PTR_FORMAT,
_task->worker_id(), p2i(p), p2i((void*) obj)); _task->worker_id(), p2i(p), p2i((void*) obj));
} }
_task->deal_with_reference(obj); _task->deal_with_reference(obj);

2
hotspot/src/share/vm/gc/g1/g1RemSet.cpp
View file

@ -424,7 +424,7 @@ G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h,
bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i, bool G1RemSet::refine_card(jbyte* card_ptr, uint worker_i,
bool check_for_refs_into_cset) { bool check_for_refs_into_cset) {
assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)), assert(_g1->is_in_exact(_ct_bs->addr_for(card_ptr)),
err_msg("Card at "PTR_FORMAT" index "SIZE_FORMAT" representing heap at "PTR_FORMAT" (%u) must be in committed heap", err_msg("Card at " PTR_FORMAT " index " SIZE_FORMAT " representing heap at " PTR_FORMAT " (%u) must be in committed heap",
p2i(card_ptr), p2i(card_ptr),
_ct_bs->index_for(_ct_bs->addr_for(card_ptr)), _ct_bs->index_for(_ct_bs->addr_for(card_ptr)),
p2i(_ct_bs->addr_for(card_ptr)), p2i(_ct_bs->addr_for(card_ptr)),

42
hotspot/src/share/vm/gc/g1/g1RemSetSummary.cpp
View file

@ -187,22 +187,22 @@ public:
size_t code_root_elems() const { return _code_root_elems; } size_t code_root_elems() const { return _code_root_elems; }
void print_rs_mem_info_on(outputStream * out, size_t total) { void print_rs_mem_info_on(outputStream * out, size_t total) {
out->print_cr(" "SIZE_FORMAT_W(8)"K (%5.1f%%) by "SIZE_FORMAT" %s regions", out->print_cr(" " SIZE_FORMAT_W(8) "K (%5.1f%%) by " SIZE_FORMAT " %s regions",
round_to_K(rs_mem_size()), rs_mem_size_percent_of(total), amount(), _name); round_to_K(rs_mem_size()), rs_mem_size_percent_of(total), amount(), _name);
} }
void print_cards_occupied_info_on(outputStream * out, size_t total) { void print_cards_occupied_info_on(outputStream * out, size_t total) {
out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) entries by "SIZE_FORMAT" %s regions", out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) entries by " SIZE_FORMAT " %s regions",
cards_occupied(), cards_occupied_percent_of(total), amount(), _name); cards_occupied(), cards_occupied_percent_of(total), amount(), _name);
} }
void print_code_root_mem_info_on(outputStream * out, size_t total) { void print_code_root_mem_info_on(outputStream * out, size_t total) {
out->print_cr(" "SIZE_FORMAT_W(8)"K (%5.1f%%) by "SIZE_FORMAT" %s regions", out->print_cr(" " SIZE_FORMAT_W(8) "K (%5.1f%%) by " SIZE_FORMAT " %s regions",
round_to_K(code_root_mem_size()), code_root_mem_size_percent_of(total), amount(), _name); round_to_K(code_root_mem_size()), code_root_mem_size_percent_of(total), amount(), _name);
} }
void print_code_root_elems_info_on(outputStream * out, size_t total) { void print_code_root_elems_info_on(outputStream * out, size_t total) {
out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) elements by "SIZE_FORMAT" %s regions", out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) elements by " SIZE_FORMAT " %s regions",
code_root_elems(), code_root_elems_percent_of(total), amount(), _name); code_root_elems(), code_root_elems_percent_of(total), amount(), _name);
} }
}; };
@ -280,19 +280,19 @@ public:
RegionTypeCounter* counters[] = { &_young, &_humonguous, &_free, &_old, NULL }; RegionTypeCounter* counters[] = { &_young, &_humonguous, &_free, &_old, NULL };
out->print_cr("\n Current rem set statistics"); out->print_cr("\n Current rem set statistics");
out->print_cr(" Total per region rem sets sizes = "SIZE_FORMAT"K." out->print_cr(" Total per region rem sets sizes = " SIZE_FORMAT "K."
" Max = "SIZE_FORMAT"K.", " Max = " SIZE_FORMAT "K.",
round_to_K(total_rs_mem_sz()), round_to_K(max_rs_mem_sz())); round_to_K(total_rs_mem_sz()), round_to_K(max_rs_mem_sz()));
for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
(*current)->print_rs_mem_info_on(out, total_rs_mem_sz()); (*current)->print_rs_mem_info_on(out, total_rs_mem_sz());
} }
out->print_cr(" Static structures = "SIZE_FORMAT"K," out->print_cr(" Static structures = " SIZE_FORMAT "K,"
" free_lists = "SIZE_FORMAT"K.", " free_lists = " SIZE_FORMAT "K.",
round_to_K(HeapRegionRemSet::static_mem_size()), round_to_K(HeapRegionRemSet::static_mem_size()),
round_to_K(HeapRegionRemSet::fl_mem_size())); round_to_K(HeapRegionRemSet::fl_mem_size()));
out->print_cr(" "SIZE_FORMAT" occupied cards represented.", out->print_cr(" " SIZE_FORMAT " occupied cards represented.",
total_cards_occupied()); total_cards_occupied());
for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
(*current)->print_cards_occupied_info_on(out, total_cards_occupied()); (*current)->print_cards_occupied_info_on(out, total_cards_occupied());
@ -300,30 +300,30 @@ public:
// Largest sized rem set region statistics // Largest sized rem set region statistics
HeapRegionRemSet* rem_set = max_rs_mem_sz_region()->rem_set(); HeapRegionRemSet* rem_set = max_rs_mem_sz_region()->rem_set();
out->print_cr(" Region with largest rem set = "HR_FORMAT", " out->print_cr(" Region with largest rem set = " HR_FORMAT ", "
"size = "SIZE_FORMAT "K, occupied = "SIZE_FORMAT"K.", "size = " SIZE_FORMAT "K, occupied = " SIZE_FORMAT "K.",
HR_FORMAT_PARAMS(max_rs_mem_sz_region()), HR_FORMAT_PARAMS(max_rs_mem_sz_region()),
round_to_K(rem_set->mem_size()), round_to_K(rem_set->mem_size()),
round_to_K(rem_set->occupied())); round_to_K(rem_set->occupied()));
// Strong code root statistics // Strong code root statistics
HeapRegionRemSet* max_code_root_rem_set = max_code_root_mem_sz_region()->rem_set(); HeapRegionRemSet* max_code_root_rem_set = max_code_root_mem_sz_region()->rem_set();
out->print_cr(" Total heap region code root sets sizes = "SIZE_FORMAT"K." out->print_cr(" Total heap region code root sets sizes = " SIZE_FORMAT "K."
" Max = "SIZE_FORMAT"K.", " Max = " SIZE_FORMAT "K.",
round_to_K(total_code_root_mem_sz()), round_to_K(total_code_root_mem_sz()),
round_to_K(max_code_root_rem_set->strong_code_roots_mem_size())); round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()));
for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
(*current)->print_code_root_mem_info_on(out, total_code_root_mem_sz()); (*current)->print_code_root_mem_info_on(out, total_code_root_mem_sz());
} }
out->print_cr(" "SIZE_FORMAT" code roots represented.", out->print_cr(" " SIZE_FORMAT " code roots represented.",
total_code_root_elems()); total_code_root_elems());
for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) { for (RegionTypeCounter** current = &counters[0]; *current != NULL; current++) {
(*current)->print_code_root_elems_info_on(out, total_code_root_elems()); (*current)->print_code_root_elems_info_on(out, total_code_root_elems());
} }
out->print_cr(" Region with largest amount of code roots = "HR_FORMAT", " out->print_cr(" Region with largest amount of code roots = " HR_FORMAT ", "
"size = "SIZE_FORMAT "K, num_elems = "SIZE_FORMAT".", "size = " SIZE_FORMAT "K, num_elems = " SIZE_FORMAT ".",
HR_FORMAT_PARAMS(max_code_root_mem_sz_region()), HR_FORMAT_PARAMS(max_code_root_mem_sz_region()),
round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()), round_to_K(max_code_root_rem_set->strong_code_roots_mem_size()),
round_to_K(max_code_root_rem_set->strong_code_roots_list_length())); round_to_K(max_code_root_rem_set->strong_code_roots_list_length()));
@ -332,16 +332,16 @@ public:
void G1RemSetSummary::print_on(outputStream* out) { void G1RemSetSummary::print_on(outputStream* out) {
out->print_cr("\n Recent concurrent refinement statistics"); out->print_cr("\n Recent concurrent refinement statistics");
out->print_cr(" Processed "SIZE_FORMAT" cards", out->print_cr(" Processed " SIZE_FORMAT " cards",
num_concurrent_refined_cards()); num_concurrent_refined_cards());
out->print_cr(" Of "SIZE_FORMAT" completed buffers:", num_processed_buf_total()); out->print_cr(" Of " SIZE_FORMAT " completed buffers:", num_processed_buf_total());
out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) by concurrent RS threads.", out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) by concurrent RS threads.",
num_processed_buf_total(), num_processed_buf_total(),
percent_of(num_processed_buf_rs_threads(), num_processed_buf_total())); percent_of(num_processed_buf_rs_threads(), num_processed_buf_total()));
out->print_cr(" "SIZE_FORMAT_W(8)" (%5.1f%%) by mutator threads.", out->print_cr(" " SIZE_FORMAT_W(8) " (%5.1f%%) by mutator threads.",
num_processed_buf_mutator(), num_processed_buf_mutator(),
percent_of(num_processed_buf_mutator(), num_processed_buf_total())); percent_of(num_processed_buf_mutator(), num_processed_buf_total()));
out->print_cr(" Did "SIZE_FORMAT" coarsenings.", num_coarsenings()); out->print_cr(" Did " SIZE_FORMAT " coarsenings.", num_coarsenings());
out->print_cr(" Concurrent RS threads times (s)"); out->print_cr(" Concurrent RS threads times (s)");
out->print(" "); out->print(" ");
for (uint i = 0; i < _num_vtimes; i++) { for (uint i = 0; i < _num_vtimes; i++) {

2
hotspot/src/share/vm/gc/g1/g1StringDedupQueue.cpp
View file

@ -155,7 +155,7 @@ void G1StringDedupQueue::unlink_or_oops_do(G1StringDedupUnlinkOrOopsDoClosure* c
void G1StringDedupQueue::print_statistics(outputStream* st) { void G1StringDedupQueue::print_statistics(outputStream* st) {
st->print_cr( st->print_cr(
" [Queue]\n" " [Queue]\n"
" [Dropped: "UINTX_FORMAT"]", _queue->_dropped); " [Dropped: " UINTX_FORMAT "]", _queue->_dropped);
} }
void G1StringDedupQueue::verify() { void G1StringDedupQueue::verify() {

24
hotspot/src/share/vm/gc/g1/g1StringDedupStat.cpp
View file

@ -80,8 +80,8 @@ void G1StringDedupStat::print_summary(outputStream* st, const G1StringDedupStat&
st->stamp(PrintGCTimeStamps); st->stamp(PrintGCTimeStamps);
st->print_cr( st->print_cr(
"[GC concurrent-string-deduplication, " "[GC concurrent-string-deduplication, "
G1_STRDEDUP_BYTES_FORMAT_NS"->"G1_STRDEDUP_BYTES_FORMAT_NS"("G1_STRDEDUP_BYTES_FORMAT_NS"), avg " G1_STRDEDUP_BYTES_FORMAT_NS "->" G1_STRDEDUP_BYTES_FORMAT_NS "(" G1_STRDEDUP_BYTES_FORMAT_NS "), avg "
G1_STRDEDUP_PERCENT_FORMAT_NS", "G1_STRDEDUP_TIME_FORMAT"]", G1_STRDEDUP_PERCENT_FORMAT_NS ", " G1_STRDEDUP_TIME_FORMAT "]",
G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes), G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes),
G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes - last_stat._deduped_bytes), G1_STRDEDUP_BYTES_PARAM(last_stat._new_bytes - last_stat._deduped_bytes),
G1_STRDEDUP_BYTES_PARAM(last_stat._deduped_bytes), G1_STRDEDUP_BYTES_PARAM(last_stat._deduped_bytes),
@ -135,22 +135,22 @@ void G1StringDedupStat::print_statistics(outputStream* st, const G1StringDedupSt
if (total) { if (total) {
st->print_cr( st->print_cr(
" [Total Exec: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT", Idle: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT", Blocked: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT"]", " [Total Exec: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Idle: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]",
stat._exec, stat._exec_elapsed, stat._idle, stat._idle_elapsed, stat._block, stat._block_elapsed); stat._exec, stat._exec_elapsed, stat._idle, stat._idle_elapsed, stat._block, stat._block_elapsed);
} else { } else {
st->print_cr( st->print_cr(
" [Last Exec: "G1_STRDEDUP_TIME_FORMAT", Idle: "G1_STRDEDUP_TIME_FORMAT", Blocked: "UINTX_FORMAT"/"G1_STRDEDUP_TIME_FORMAT"]", " [Last Exec: " G1_STRDEDUP_TIME_FORMAT ", Idle: " G1_STRDEDUP_TIME_FORMAT ", Blocked: " UINTX_FORMAT "/" G1_STRDEDUP_TIME_FORMAT "]",
stat._exec_elapsed, stat._idle_elapsed, stat._block, stat._block_elapsed); stat._exec_elapsed, stat._idle_elapsed, stat._block, stat._block_elapsed);
} }
st->print_cr( st->print_cr(
" [Inspected: "G1_STRDEDUP_OBJECTS_FORMAT"]\n" " [Inspected: " G1_STRDEDUP_OBJECTS_FORMAT "]\n"
" [Skipped: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" " [Skipped: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n"
" [Hashed: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" " [Hashed: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n"
" [Known: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" " [Known: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n"
" [New: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"]\n" " [New: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "]\n"
" [Deduplicated: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" " [Deduplicated: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n"
" [Young: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]\n" " [Young: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]\n"
" [Old: "G1_STRDEDUP_OBJECTS_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT") "G1_STRDEDUP_BYTES_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT")]", " [Old: " G1_STRDEDUP_OBJECTS_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ") " G1_STRDEDUP_BYTES_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT ")]",
stat._inspected, stat._inspected,
stat._skipped, skipped_percent, stat._skipped, skipped_percent,
stat._hashed, hashed_percent, stat._hashed, hashed_percent,

12
hotspot/src/share/vm/gc/g1/g1StringDedupTable.cpp
View file

@ -556,12 +556,12 @@ void G1StringDedupTable::trim_entry_cache() {
void G1StringDedupTable::print_statistics(outputStream* st) { void G1StringDedupTable::print_statistics(outputStream* st) {
st->print_cr( st->print_cr(
" [Table]\n" " [Table]\n"
" [Memory Usage: "G1_STRDEDUP_BYTES_FORMAT_NS"]\n" " [Memory Usage: " G1_STRDEDUP_BYTES_FORMAT_NS "]\n"
" [Size: "SIZE_FORMAT", Min: "SIZE_FORMAT", Max: "SIZE_FORMAT"]\n" " [Size: " SIZE_FORMAT ", Min: " SIZE_FORMAT ", Max: " SIZE_FORMAT "]\n"
" [Entries: "UINTX_FORMAT", Load: "G1_STRDEDUP_PERCENT_FORMAT_NS", Cached: " UINTX_FORMAT ", Added: "UINTX_FORMAT", Removed: "UINTX_FORMAT"]\n" " [Entries: " UINTX_FORMAT ", Load: " G1_STRDEDUP_PERCENT_FORMAT_NS ", Cached: " UINTX_FORMAT ", Added: " UINTX_FORMAT ", Removed: " UINTX_FORMAT "]\n"
" [Resize Count: "UINTX_FORMAT", Shrink Threshold: "UINTX_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT_NS"), Grow Threshold: "UINTX_FORMAT"("G1_STRDEDUP_PERCENT_FORMAT_NS")]\n" " [Resize Count: " UINTX_FORMAT ", Shrink Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS "), Grow Threshold: " UINTX_FORMAT "(" G1_STRDEDUP_PERCENT_FORMAT_NS ")]\n"
" [Rehash Count: "UINTX_FORMAT", Rehash Threshold: "UINTX_FORMAT", Hash Seed: 0x%x]\n" " [Rehash Count: " UINTX_FORMAT ", Rehash Threshold: " UINTX_FORMAT ", Hash Seed: 0x%x]\n"
" [Age Threshold: "UINTX_FORMAT"]", " [Age Threshold: " UINTX_FORMAT "]",
G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry)), G1_STRDEDUP_BYTES_PARAM(_table->_size * sizeof(G1StringDedupEntry*) + (_table->_entries + _entry_cache->size()) * sizeof(G1StringDedupEntry)),
_table->_size, _min_size, _max_size, _table->_size, _min_size, _max_size,
_table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed, _table->_entries, (double)_table->_entries / (double)_table->_size * 100.0, _entry_cache->size(), _entries_added, _entries_removed,

92
hotspot/src/share/vm/gc/g1/heapRegion.cpp
View file

@ -327,7 +327,7 @@ void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark,
bool during_conc_mark, bool during_conc_mark,
size_t marked_bytes) { size_t marked_bytes) {
assert(marked_bytes <= used(), assert(marked_bytes <= used(),
err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT, marked_bytes, used())); err_msg("marked: " SIZE_FORMAT " used: " SIZE_FORMAT, marked_bytes, used()));
_prev_top_at_mark_start = top(); _prev_top_at_mark_start = top();
_prev_marked_bytes = marked_bytes; _prev_marked_bytes = marked_bytes;
} }
@ -504,9 +504,9 @@ class VerifyStrongCodeRootOopClosure: public OopClosure {
// Object is in the region. Check that its less than top // Object is in the region. Check that its less than top
if (_hr->top() <= (HeapWord*)obj) { if (_hr->top() <= (HeapWord*)obj) {
// Object is above top // Object is above top
gclog_or_tty->print_cr("Object "PTR_FORMAT" in region " gclog_or_tty->print_cr("Object " PTR_FORMAT " in region "
"["PTR_FORMAT", "PTR_FORMAT") is above " "[" PTR_FORMAT ", " PTR_FORMAT ") is above "
"top "PTR_FORMAT, "top " PTR_FORMAT,
p2i(obj), p2i(_hr->bottom()), p2i(_hr->end()), p2i(_hr->top())); p2i(obj), p2i(_hr->bottom()), p2i(_hr->end()), p2i(_hr->top()));
_failures = true; _failures = true;
return; return;
@ -540,22 +540,22 @@ public:
if (nm != NULL) { if (nm != NULL) {
// Verify that the nemthod is live // Verify that the nemthod is live
if (!nm->is_alive()) { if (!nm->is_alive()) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has dead nmethod " gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has dead nmethod "
PTR_FORMAT" in its strong code roots", PTR_FORMAT " in its strong code roots",
p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true; _failures = true;
} else { } else {
VerifyStrongCodeRootOopClosure oop_cl(_hr, nm); VerifyStrongCodeRootOopClosure oop_cl(_hr, nm);
nm->oops_do(&oop_cl); nm->oops_do(&oop_cl);
if (!oop_cl.has_oops_in_region()) { if (!oop_cl.has_oops_in_region()) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has nmethod " gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has nmethod "
PTR_FORMAT" in its strong code roots " PTR_FORMAT " in its strong code roots "
"with no pointers into region", "with no pointers into region",
p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true; _failures = true;
} else if (oop_cl.failures()) { } else if (oop_cl.failures()) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has other " gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] has other "
"failures for nmethod "PTR_FORMAT, "failures for nmethod " PTR_FORMAT,
p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm)); p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true; _failures = true;
} }
@ -589,8 +589,8 @@ void HeapRegion::verify_strong_code_roots(VerifyOption vo, bool* failures) const
// on its strong code root list // on its strong code root list
if (is_empty()) { if (is_empty()) {
if (strong_code_roots_length > 0) { if (strong_code_roots_length > 0) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is empty " gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] is empty "
"but has "SIZE_FORMAT" code root entries", "but has " SIZE_FORMAT " code root entries",
p2i(bottom()), p2i(end()), strong_code_roots_length); p2i(bottom()), p2i(end()), strong_code_roots_length);
*failures = true; *failures = true;
} }
@ -599,8 +599,8 @@ void HeapRegion::verify_strong_code_roots(VerifyOption vo, bool* failures) const
if (is_continues_humongous()) { if (is_continues_humongous()) {
if (strong_code_roots_length > 0) { if (strong_code_roots_length > 0) {
gclog_or_tty->print_cr("region "HR_FORMAT" is a continuation of a humongous " gclog_or_tty->print_cr("region " HR_FORMAT " is a continuation of a humongous "
"region but has "SIZE_FORMAT" code root entries", "region but has " SIZE_FORMAT " code root entries",
HR_FORMAT_PARAMS(this), strong_code_roots_length); HR_FORMAT_PARAMS(this), strong_code_roots_length);
*failures = true; *failures = true;
} }
@ -625,7 +625,7 @@ void HeapRegion::print_on(outputStream* st) const {
else else
st->print(" "); st->print(" ");
st->print(" TS %5d", _gc_time_stamp); st->print(" TS %5d", _gc_time_stamp);
st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT, st->print(" PTAMS " PTR_FORMAT " NTAMS " PTR_FORMAT,
p2i(prev_top_at_mark_start()), p2i(next_top_at_mark_start())); p2i(prev_top_at_mark_start()), p2i(next_top_at_mark_start()));
G1OffsetTableContigSpace::print_on(st); G1OffsetTableContigSpace::print_on(st);
} }
@ -686,25 +686,25 @@ public:
} }
if (!_g1h->is_in_closed_subset(obj)) { if (!_g1h->is_in_closed_subset(obj)) {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
gclog_or_tty->print_cr("Field "PTR_FORMAT gclog_or_tty->print_cr("Field " PTR_FORMAT
" of live obj "PTR_FORMAT" in region " " of live obj " PTR_FORMAT " in region "
"["PTR_FORMAT", "PTR_FORMAT")", "[" PTR_FORMAT ", " PTR_FORMAT ")",
p2i(p), p2i(_containing_obj), p2i(p), p2i(_containing_obj),
p2i(from->bottom()), p2i(from->end())); p2i(from->bottom()), p2i(from->end()));
print_object(gclog_or_tty, _containing_obj); print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap", gclog_or_tty->print_cr("points to obj " PTR_FORMAT " not in the heap",
p2i(obj)); p2i(obj));
} else { } else {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p); HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj); HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj);
gclog_or_tty->print_cr("Field "PTR_FORMAT gclog_or_tty->print_cr("Field " PTR_FORMAT
" of live obj "PTR_FORMAT" in region " " of live obj " PTR_FORMAT " in region "
"["PTR_FORMAT", "PTR_FORMAT")", "[" PTR_FORMAT ", " PTR_FORMAT ")",
p2i(p), p2i(_containing_obj), p2i(p), p2i(_containing_obj),
p2i(from->bottom()), p2i(from->end())); p2i(from->bottom()), p2i(from->end()));
print_object(gclog_or_tty, _containing_obj); print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region " gclog_or_tty->print_cr("points to dead obj " PTR_FORMAT " in region "
"["PTR_FORMAT", "PTR_FORMAT")", "[" PTR_FORMAT ", " PTR_FORMAT ")",
p2i(obj), p2i(to->bottom()), p2i(to->end())); p2i(obj), p2i(to->bottom()), p2i(to->end()));
print_object(gclog_or_tty, obj); print_object(gclog_or_tty, obj);
} }
@ -740,14 +740,14 @@ public:
gclog_or_tty->print_cr("----------"); gclog_or_tty->print_cr("----------");
} }
gclog_or_tty->print_cr("Missing rem set entry:"); gclog_or_tty->print_cr("Missing rem set entry:");
gclog_or_tty->print_cr("Field "PTR_FORMAT" " gclog_or_tty->print_cr("Field " PTR_FORMAT " "
"of obj "PTR_FORMAT", " "of obj " PTR_FORMAT ", "
"in region "HR_FORMAT, "in region " HR_FORMAT,
p2i(p), p2i(_containing_obj), p2i(p), p2i(_containing_obj),
HR_FORMAT_PARAMS(from)); HR_FORMAT_PARAMS(from));
_containing_obj->print_on(gclog_or_tty); _containing_obj->print_on(gclog_or_tty);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT" " gclog_or_tty->print_cr("points to obj " PTR_FORMAT " "
"in region "HR_FORMAT, "in region " HR_FORMAT,
p2i(obj), p2i(obj),
HR_FORMAT_PARAMS(to)); HR_FORMAT_PARAMS(to));
obj->print_on(gclog_or_tty); obj->print_on(gclog_or_tty);
@ -783,8 +783,8 @@ void HeapRegion::verify(VerifyOption vo,
if (is_region_humongous != g1->is_humongous(obj_size) && if (is_region_humongous != g1->is_humongous(obj_size) &&
!g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects. !g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects.
gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size (" gclog_or_tty->print_cr("obj " PTR_FORMAT " is of %shumongous size ("
SIZE_FORMAT" words) in a %shumongous region", SIZE_FORMAT " words) in a %shumongous region",
p2i(p), g1->is_humongous(obj_size) ? "" : "non-", p2i(p), g1->is_humongous(obj_size) ? "" : "non-",
obj_size, is_region_humongous ? "" : "non-"); obj_size, is_region_humongous ? "" : "non-");
*failures = true; *failures = true;
@ -798,12 +798,12 @@ void HeapRegion::verify(VerifyOption vo,
(vo == VerifyOption_G1UsePrevMarking && (vo == VerifyOption_G1UsePrevMarking &&
ClassLoaderDataGraph::unload_list_contains(klass)); ClassLoaderDataGraph::unload_list_contains(klass));
if (!is_metaspace_object) { if (!is_metaspace_object) {
gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " "
"not metadata", p2i(klass), p2i(obj)); "not metadata", p2i(klass), p2i(obj));
*failures = true; *failures = true;
return; return;
} else if (!klass->is_klass()) { } else if (!klass->is_klass()) {
gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" " gclog_or_tty->print_cr("klass " PTR_FORMAT " of object " PTR_FORMAT " "
"not a klass", p2i(klass), p2i(obj)); "not a klass", p2i(klass), p2i(obj));
*failures = true; *failures = true;
return; return;
@ -819,7 +819,7 @@ void HeapRegion::verify(VerifyOption vo,
} }
} }
} else { } else {
gclog_or_tty->print_cr(PTR_FORMAT" no an oop", p2i(obj)); gclog_or_tty->print_cr(PTR_FORMAT " no an oop", p2i(obj));
*failures = true; *failures = true;
return; return;
} }
@ -833,8 +833,8 @@ void HeapRegion::verify(VerifyOption vo,
} }
if (p != top()) { if (p != top()) {
gclog_or_tty->print_cr("end of last object "PTR_FORMAT" " gclog_or_tty->print_cr("end of last object " PTR_FORMAT " "
"does not match top "PTR_FORMAT, p2i(p), p2i(top())); "does not match top " PTR_FORMAT, p2i(p), p2i(top()));
*failures = true; *failures = true;
return; return;
} }
@ -849,8 +849,8 @@ void HeapRegion::verify(VerifyOption vo,
HeapWord* addr_1 = p; HeapWord* addr_1 = p;
HeapWord* b_start_1 = _offsets.block_start_const(addr_1); HeapWord* b_start_1 = _offsets.block_start_const(addr_1);
if (b_start_1 != p) { if (b_start_1 != p) {
gclog_or_tty->print_cr("BOT look up for top: "PTR_FORMAT" " gclog_or_tty->print_cr("BOT look up for top: " PTR_FORMAT " "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT, " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
p2i(addr_1), p2i(b_start_1), p2i(p)); p2i(addr_1), p2i(b_start_1), p2i(p));
*failures = true; *failures = true;
return; return;
@ -861,8 +861,8 @@ void HeapRegion::verify(VerifyOption vo,
if (addr_2 < the_end) { if (addr_2 < the_end) {
HeapWord* b_start_2 = _offsets.block_start_const(addr_2); HeapWord* b_start_2 = _offsets.block_start_const(addr_2);
if (b_start_2 != p) { if (b_start_2 != p) {
gclog_or_tty->print_cr("BOT look up for top + 1: "PTR_FORMAT" " gclog_or_tty->print_cr("BOT look up for top + 1: " PTR_FORMAT " "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT, " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
p2i(addr_2), p2i(b_start_2), p2i(p)); p2i(addr_2), p2i(b_start_2), p2i(p));
*failures = true; *failures = true;
return; return;
@ -875,8 +875,8 @@ void HeapRegion::verify(VerifyOption vo,
if (addr_3 < the_end) { if (addr_3 < the_end) {
HeapWord* b_start_3 = _offsets.block_start_const(addr_3); HeapWord* b_start_3 = _offsets.block_start_const(addr_3);
if (b_start_3 != p) { if (b_start_3 != p) {
gclog_or_tty->print_cr("BOT look up for top + diff: "PTR_FORMAT" " gclog_or_tty->print_cr("BOT look up for top + diff: " PTR_FORMAT " "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT, " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
p2i(addr_3), p2i(b_start_3), p2i(p)); p2i(addr_3), p2i(b_start_3), p2i(p));
*failures = true; *failures = true;
return; return;
@ -887,8 +887,8 @@ void HeapRegion::verify(VerifyOption vo,
HeapWord* addr_4 = the_end - 1; HeapWord* addr_4 = the_end - 1;
HeapWord* b_start_4 = _offsets.block_start_const(addr_4); HeapWord* b_start_4 = _offsets.block_start_const(addr_4);
if (b_start_4 != p) { if (b_start_4 != p) {
gclog_or_tty->print_cr("BOT look up for end - 1: "PTR_FORMAT" " gclog_or_tty->print_cr("BOT look up for end - 1: " PTR_FORMAT " "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT, " yielded " PTR_FORMAT ", expecting " PTR_FORMAT,
p2i(addr_4), p2i(b_start_4), p2i(p)); p2i(addr_4), p2i(b_start_4), p2i(p));
*failures = true; *failures = true;
return; return;
@ -896,8 +896,8 @@ void HeapRegion::verify(VerifyOption vo,
} }
if (is_region_humongous && object_num > 1) { if (is_region_humongous && object_num > 1) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous " gclog_or_tty->print_cr("region [" PTR_FORMAT "," PTR_FORMAT "] is humongous "
"but has "SIZE_FORMAT", objects", "but has " SIZE_FORMAT ", objects",
p2i(bottom()), p2i(end()), object_num); p2i(bottom()), p2i(end()), object_num);
*failures = true; *failures = true;
return; return;

6
hotspot/src/share/vm/gc/g1/heapRegion.hpp
View file

@ -51,7 +51,7 @@ class HeapRegion;
class HeapRegionSetBase; class HeapRegionSetBase;
class nmethod; class nmethod;
#define HR_FORMAT "%u:(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]" #define HR_FORMAT "%u:(%s)[" PTR_FORMAT "," PTR_FORMAT "," PTR_FORMAT "]"
#define HR_FORMAT_PARAMS(_hr_) \ #define HR_FORMAT_PARAMS(_hr_) \
(_hr_)->hrm_index(), \ (_hr_)->hrm_index(), \
(_hr_)->get_short_type_str(), \ (_hr_)->get_short_type_str(), \
@ -538,8 +538,8 @@ class HeapRegion: public G1OffsetTableContigSpace {
void set_containing_set(HeapRegionSetBase* containing_set) { void set_containing_set(HeapRegionSetBase* containing_set) {
assert((containing_set == NULL && _containing_set != NULL) || assert((containing_set == NULL && _containing_set != NULL) ||
(containing_set != NULL && _containing_set == NULL), (containing_set != NULL && _containing_set == NULL),
err_msg("containing_set: "PTR_FORMAT" " err_msg("containing_set: " PTR_FORMAT " "
"_containing_set: "PTR_FORMAT, "_containing_set: " PTR_FORMAT,
p2i(containing_set), p2i(_containing_set))); p2i(containing_set), p2i(_containing_set)));
_containing_set = containing_set; _containing_set = containing_set;

2
hotspot/src/share/vm/gc/g1/heapRegion.inline.hpp
View file

@ -113,7 +113,7 @@ HeapRegion::block_size(const HeapWord *addr) const {
assert(ClassUnloadingWithConcurrentMark, assert(ClassUnloadingWithConcurrentMark,
err_msg("All blocks should be objects if G1 Class Unloading isn't used. " err_msg("All blocks should be objects if G1 Class Unloading isn't used. "
"HR: ["PTR_FORMAT", "PTR_FORMAT", "PTR_FORMAT") " "HR: [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ") "
"addr: " PTR_FORMAT, "addr: " PTR_FORMAT,
p2i(bottom()), p2i(top()), p2i(end()), p2i(addr))); p2i(bottom()), p2i(top()), p2i(end()), p2i(addr)));

2
hotspot/src/share/vm/gc/g1/heapRegionManager.cpp
View file

@ -486,7 +486,7 @@ void HeapRegionManager::verify() {
HeapRegion* hr = _regions.get_by_index(i); HeapRegion* hr = _regions.get_by_index(i);
guarantee(hr != NULL, err_msg("invariant: i: %u", i)); guarantee(hr != NULL, err_msg("invariant: i: %u", i));
guarantee(!prev_committed || hr->bottom() == prev_end, guarantee(!prev_committed || hr->bottom() == prev_end,
err_msg("invariant i: %u "HR_FORMAT" prev_end: "PTR_FORMAT, err_msg("invariant i: %u " HR_FORMAT " prev_end: " PTR_FORMAT,
i, HR_FORMAT_PARAMS(hr), p2i(prev_end))); i, HR_FORMAT_PARAMS(hr), p2i(prev_end)));
guarantee(hr->hrm_index() == i, guarantee(hr->hrm_index() == i,
err_msg("invariant: i: %u hrm_index(): %u", i, hr->hrm_index())); err_msg("invariant: i: %u hrm_index(): %u", i, hr->hrm_index()));

4
hotspot/src/share/vm/gc/g1/heapRegionManager.inline.hpp
View file

@ -31,9 +31,9 @@
inline HeapRegion* HeapRegionManager::addr_to_region(HeapWord* addr) const { inline HeapRegion* HeapRegionManager::addr_to_region(HeapWord* addr) const {
assert(addr < heap_end(), assert(addr < heap_end(),
err_msg("addr: "PTR_FORMAT" end: "PTR_FORMAT, p2i(addr), p2i(heap_end()))); err_msg("addr: " PTR_FORMAT " end: " PTR_FORMAT, p2i(addr), p2i(heap_end())));
assert(addr >= heap_bottom(), assert(addr >= heap_bottom(),
err_msg("addr: "PTR_FORMAT" bottom: "PTR_FORMAT, p2i(addr), p2i(heap_bottom()))); err_msg("addr: " PTR_FORMAT " bottom: " PTR_FORMAT, p2i(addr), p2i(heap_bottom())));
HeapRegion* hr = _regions.get_by_address(addr); HeapRegion* hr = _regions.get_by_address(addr);
return hr; return hr;

14
hotspot/src/share/vm/gc/g1/heapRegionRemSet.cpp
View file

@ -90,7 +90,7 @@ protected:
// concurrency. // concurrency.
if (G1TraceHeapRegionRememberedSet) { if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT").", gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").",
p2i(from), p2i(from),
UseCompressedOops UseCompressedOops
? p2i(oopDesc::load_decode_heap_oop((narrowOop*)from)) ? p2i(oopDesc::load_decode_heap_oop((narrowOop*)from))
@ -376,7 +376,7 @@ void FromCardCache::initialize(uint n_par_rs, uint max_num_regions) {
void FromCardCache::invalidate(uint start_idx, size_t new_num_regions) { void FromCardCache::invalidate(uint start_idx, size_t new_num_regions) {
guarantee((size_t)start_idx + new_num_regions <= max_uintx, guarantee((size_t)start_idx + new_num_regions <= max_uintx,
err_msg("Trying to invalidate beyond maximum region, from %u size "SIZE_FORMAT, err_msg("Trying to invalidate beyond maximum region, from %u size " SIZE_FORMAT,
start_idx, new_num_regions)); start_idx, new_num_regions));
for (uint i = 0; i < HeapRegionRemSet::num_par_rem_sets(); i++) { for (uint i = 0; i < HeapRegionRemSet::num_par_rem_sets(); i++) {
uint end_idx = (start_idx + (uint)new_num_regions); uint end_idx = (start_idx + (uint)new_num_regions);
@ -630,13 +630,13 @@ void OtherRegionsTable::scrub(CardTableModRefBS* ctbs,
assert(_coarse_map.size() == region_bm->size(), "Precondition"); assert(_coarse_map.size() == region_bm->size(), "Precondition");
if (G1RSScrubVerbose) { if (G1RSScrubVerbose) {
gclog_or_tty->print(" Coarse map: before = "SIZE_FORMAT"...", gclog_or_tty->print(" Coarse map: before = " SIZE_FORMAT "...",
_n_coarse_entries); _n_coarse_entries);
} }
_coarse_map.set_intersection(*region_bm); _coarse_map.set_intersection(*region_bm);
_n_coarse_entries = _coarse_map.count_one_bits(); _n_coarse_entries = _coarse_map.count_one_bits();
if (G1RSScrubVerbose) { if (G1RSScrubVerbose) {
gclog_or_tty->print_cr(" after = "SIZE_FORMAT".", _n_coarse_entries); gclog_or_tty->print_cr(" after = " SIZE_FORMAT ".", _n_coarse_entries);
} }
// Now do the fine-grained maps. // Now do the fine-grained maps.
@ -1013,7 +1013,7 @@ bool HeapRegionRemSetIterator::fine_has_next(size_t& card_index) {
card_index = _cur_region_card_offset + _cur_card_in_prt; card_index = _cur_region_card_offset + _cur_card_in_prt;
guarantee(_cur_card_in_prt < HeapRegion::CardsPerRegion, guarantee(_cur_card_in_prt < HeapRegion::CardsPerRegion,
err_msg("Card index "SIZE_FORMAT" must be within the region", _cur_card_in_prt)); err_msg("Card index " SIZE_FORMAT " must be within the region", _cur_card_in_prt));
return true; return true;
} }
@ -1182,8 +1182,8 @@ void PerRegionTable::test_fl_mem_size() {
size_t min_prt_size = sizeof(void*) + dummy->bm()->size_in_words() * HeapWordSize; size_t min_prt_size = sizeof(void*) + dummy->bm()->size_in_words() * HeapWordSize;
assert(dummy->mem_size() > min_prt_size, assert(dummy->mem_size() > min_prt_size,
err_msg("PerRegionTable memory usage is suspiciously small, only has "SIZE_FORMAT" bytes. " err_msg("PerRegionTable memory usage is suspiciously small, only has " SIZE_FORMAT " bytes. "
"Should be at least "SIZE_FORMAT" bytes.", dummy->mem_size(), min_prt_size)); "Should be at least " SIZE_FORMAT " bytes.", dummy->mem_size(), min_prt_size));
free(dummy); free(dummy);
guarantee(dummy->mem_size() == fl_mem_size(), "fl_mem_size() does not return the correct element size"); guarantee(dummy->mem_size() == fl_mem_size(), "fl_mem_size() does not return the correct element size");
// try to reset the state // try to reset the state

14
hotspot/src/share/vm/gc/g1/heapRegionSet.cpp
View file

@ -30,7 +30,7 @@
uint FreeRegionList::_unrealistically_long_length = 0; uint FreeRegionList::_unrealistically_long_length = 0;
void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) { void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) {
msg->append("[%s] %s ln: %u cy: "SIZE_FORMAT, msg->append("[%s] %s ln: %u cy: " SIZE_FORMAT,
name(), message, length(), total_capacity_bytes()); name(), message, length(), total_capacity_bytes());
fill_in_ext_msg_extra(msg); fill_in_ext_msg_extra(msg);
} }
@ -83,13 +83,13 @@ void HeapRegionSetBase::verify_end() {
void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) { void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) {
out->cr(); out->cr();
out->print_cr("Set: %s ("PTR_FORMAT")", name(), p2i(this)); out->print_cr("Set: %s (" PTR_FORMAT ")", name(), p2i(this));
out->print_cr(" Region Assumptions"); out->print_cr(" Region Assumptions");
out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous())); out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous()));
out->print_cr(" free : %s", BOOL_TO_STR(regions_free())); out->print_cr(" free : %s", BOOL_TO_STR(regions_free()));
out->print_cr(" Attributes"); out->print_cr(" Attributes");
out->print_cr(" length : %14u", length()); out->print_cr(" length : %14u", length());
out->print_cr(" total capacity : "SIZE_FORMAT_W(14)" bytes", out->print_cr(" total capacity : " SIZE_FORMAT_W(14) " bytes",
total_capacity_bytes()); total_capacity_bytes());
} }
@ -105,7 +105,7 @@ void FreeRegionList::set_unrealistically_long_length(uint len) {
} }
void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) { void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) {
msg->append(" hd: "PTR_FORMAT" tl: "PTR_FORMAT, p2i(_head), p2i(_tail)); msg->append(" hd: " PTR_FORMAT " tl: " PTR_FORMAT, p2i(_head), p2i(_tail));
} }
void FreeRegionList::remove_all() { void FreeRegionList::remove_all() {
@ -276,8 +276,8 @@ void FreeRegionList::clear() {
void FreeRegionList::print_on(outputStream* out, bool print_contents) { void FreeRegionList::print_on(outputStream* out, bool print_contents) {
HeapRegionSetBase::print_on(out, print_contents); HeapRegionSetBase::print_on(out, print_contents);
out->print_cr(" Linking"); out->print_cr(" Linking");
out->print_cr(" head : "PTR_FORMAT, p2i(_head)); out->print_cr(" head : " PTR_FORMAT, p2i(_head));
out->print_cr(" tail : "PTR_FORMAT, p2i(_tail)); out->print_cr(" tail : " PTR_FORMAT, p2i(_tail));
if (print_contents) { if (print_contents) {
out->print_cr(" Contents"); out->print_cr(" Contents");
@ -305,7 +305,7 @@ void FreeRegionList::verify_list() {
count++; count++;
guarantee(count < _unrealistically_long_length, guarantee(count < _unrealistically_long_length,
hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " "prev1: "PTR_FORMAT" length: %u", hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: " PTR_FORMAT " prev0: " PTR_FORMAT " " "prev1: " PTR_FORMAT " length: %u",
name(), count, p2i(curr), p2i(prev0), p2i(prev1), length())); name(), count, p2i(curr), p2i(prev0), p2i(prev1), length()));
if (curr->next() != NULL) { if (curr->next() != NULL) {

4
hotspot/src/share/vm/gc/g1/satbQueue.cpp
View file

@ -200,8 +200,8 @@ void ObjPtrQueue::print(const char* name) {
void ObjPtrQueue::print(const char* name, void ObjPtrQueue::print(const char* name,
void** buf, size_t index, size_t sz) { void** buf, size_t index, size_t sz) {
gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: "PTR_FORMAT" " gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: " PTR_FORMAT " "
"index: "SIZE_FORMAT" sz: "SIZE_FORMAT, "index: " SIZE_FORMAT " sz: " SIZE_FORMAT,
name, p2i(buf), index, sz); name, p2i(buf), index, sz);
} }
#endif // PRODUCT #endif // PRODUCT

2
hotspot/src/share/vm/gc/parallel/mutableNUMASpace.cpp
View file

@ -85,7 +85,7 @@ void MutableNUMASpace::ensure_parsability() {
while (words_left_to_fill > 0) { while (words_left_to_fill > 0) {
size_t words_to_fill = MIN2(words_left_to_fill, CollectedHeap::filler_array_max_size()); size_t words_to_fill = MIN2(words_left_to_fill, CollectedHeap::filler_array_max_size());
assert(words_to_fill >= CollectedHeap::min_fill_size(), assert(words_to_fill >= CollectedHeap::min_fill_size(),
err_msg("Remaining size ("SIZE_FORMAT ") is too small to fill (based on " SIZE_FORMAT " and " SIZE_FORMAT ")", err_msg("Remaining size (" SIZE_FORMAT ") is too small to fill (based on " SIZE_FORMAT " and " SIZE_FORMAT ")",
words_to_fill, words_left_to_fill, CollectedHeap::filler_array_max_size())); words_to_fill, words_left_to_fill, CollectedHeap::filler_array_max_size()));
CollectedHeap::fill_with_object((HeapWord*)cur_top, words_to_fill); CollectedHeap::fill_with_object((HeapWord*)cur_top, words_to_fill);
if (!os::numa_has_static_binding()) { if (!os::numa_has_static_binding()) {

6
hotspot/src/share/vm/gc/parallel/psOldGen.hpp
View file

@ -65,9 +65,9 @@ class PSOldGen : public CHeapObj<mtGC> {
// Explictly capture current covered_region in a local // Explictly capture current covered_region in a local
MemRegion covered_region = this->start_array()->covered_region(); MemRegion covered_region = this->start_array()->covered_region();
assert(covered_region.contains(new_memregion), assert(covered_region.contains(new_memregion),
err_msg("new region is not in covered_region [ "PTR_FORMAT", "PTR_FORMAT" ], " err_msg("new region is not in covered_region [ " PTR_FORMAT ", " PTR_FORMAT " ], "
"new region [ "PTR_FORMAT", "PTR_FORMAT" ], " "new region [ " PTR_FORMAT ", " PTR_FORMAT " ], "
"object space [ "PTR_FORMAT", "PTR_FORMAT" ]", "object space [ " PTR_FORMAT ", " PTR_FORMAT " ]",
p2i(covered_region.start()), p2i(covered_region.start()),
p2i(covered_region.end()), p2i(covered_region.end()),
p2i(new_memregion.start()), p2i(new_memregion.start()),

4
hotspot/src/share/vm/gc/serial/tenuredGeneration.cpp
View file

@ -168,8 +168,8 @@ bool TenuredGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes)
bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); bool res = (available >= av_promo) || (available >= max_promotion_in_bytes);
if (PrintGC && Verbose) { if (PrintGC && Verbose) {
gclog_or_tty->print_cr( gclog_or_tty->print_cr(
"Tenured: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," "Tenured: promo attempt is%s safe: available(" SIZE_FORMAT ") %s av_promo(" SIZE_FORMAT "),"
"max_promo("SIZE_FORMAT")", "max_promo(" SIZE_FORMAT ")",
res? "":" not", available, res? ">=":"<", res? "":" not", available, res? ">=":"<",
av_promo, max_promotion_in_bytes); av_promo, max_promotion_in_bytes);
} }

2
hotspot/src/share/vm/gc/shared/barrierSet.inline.hpp
View file

@ -69,7 +69,7 @@ void BarrierSet::write_ref_array(HeapWord* start, size_t count) {
assert(UseCompressedOops || (aligned_start == start && aligned_end == end), assert(UseCompressedOops || (aligned_start == start && aligned_end == end),
"Expected heap word alignment of start and end"); "Expected heap word alignment of start and end");
#if 0 #if 0
warning("Post:\t" INTPTR_FORMAT "[" SIZE_FORMAT "] : [" INTPTR_FORMAT","INTPTR_FORMAT")\t", warning("Post:\t" INTPTR_FORMAT "[" SIZE_FORMAT "] : [" INTPTR_FORMAT "," INTPTR_FORMAT ")\t",
start, count, aligned_start, aligned_end); start, count, aligned_start, aligned_end);
#endif #endif
write_ref_array_work(MemRegion(aligned_start, aligned_end)); write_ref_array_work(MemRegion(aligned_start, aligned_end));

2
hotspot/src/share/vm/gc/shared/blockOffsetTable.cpp
View file

@ -560,7 +560,7 @@ HeapWord* BlockOffsetArrayNonContigSpace::block_start_unsafe(
q = n; q = n;
n += _sp->block_size(n); n += _sp->block_size(n);
assert(n > q, assert(n > q,
err_msg("Looping at n = " PTR_FORMAT " with last = " PTR_FORMAT"," err_msg("Looping at n = " PTR_FORMAT " with last = " PTR_FORMAT ","
" while querying blk_start(" PTR_FORMAT ")" " while querying blk_start(" PTR_FORMAT ")"
" on _sp = [" PTR_FORMAT "," PTR_FORMAT ")", " on _sp = [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(n), p2i(last), p2i(addr), p2i(_sp->bottom()), p2i(_sp->end()))); p2i(n), p2i(last), p2i(addr), p2i(_sp->bottom()), p2i(_sp->end())));

2
hotspot/src/share/vm/gc/shared/cardTableModRefBS.cpp
View file

@ -600,7 +600,7 @@ void CardTableModRefBS::verify_region(MemRegion mr,
(val_equals) ? "" : "not ", val); (val_equals) ? "" : "not ", val);
failures = true; failures = true;
} }
tty->print_cr("== card "PTR_FORMAT" ["PTR_FORMAT","PTR_FORMAT"], " tty->print_cr("== card " PTR_FORMAT " [" PTR_FORMAT "," PTR_FORMAT "], "
"val: %d", p2i(curr), p2i(addr_for(curr)), "val: %d", p2i(curr), p2i(addr_for(curr)),
p2i((HeapWord*) (((size_t) addr_for(curr)) + card_size)), p2i((HeapWord*) (((size_t) addr_for(curr)) + card_size)),
(int) curr_val); (int) curr_val);

12
hotspot/src/share/vm/gc/shared/cardTableModRefBS.hpp
View file

@ -158,8 +158,8 @@ class CardTableModRefBS: public ModRefBarrierSet {
// Mapping from address to card marking array entry // Mapping from address to card marking array entry
jbyte* byte_for(const void* p) const { jbyte* byte_for(const void* p) const {
assert(_whole_heap.contains(p), assert(_whole_heap.contains(p),
err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " err_msg("Attempt to access p = " PTR_FORMAT " out of bounds of "
" card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift]; jbyte* result = &byte_map_base[uintptr_t(p) >> card_shift];
assert(result >= _byte_map && result < _byte_map + _byte_map_size, assert(result >= _byte_map && result < _byte_map + _byte_map_size,
@ -399,8 +399,8 @@ public:
size_t delta = pointer_delta(p, byte_map_base, sizeof(jbyte)); size_t delta = pointer_delta(p, byte_map_base, sizeof(jbyte));
HeapWord* result = (HeapWord*) (delta << card_shift); HeapWord* result = (HeapWord*) (delta << card_shift);
assert(_whole_heap.contains(result), assert(_whole_heap.contains(result),
err_msg("Returning result = "PTR_FORMAT" out of bounds of " err_msg("Returning result = " PTR_FORMAT " out of bounds of "
" card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); p2i(result), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
return result; return result;
} }
@ -408,8 +408,8 @@ public:
// Mapping from address to card marking array index. // Mapping from address to card marking array index.
size_t index_for(void* p) { size_t index_for(void* p) {
assert(_whole_heap.contains(p), assert(_whole_heap.contains(p),
err_msg("Attempt to access p = "PTR_FORMAT" out of bounds of " err_msg("Attempt to access p = " PTR_FORMAT " out of bounds of "
" card marking array's _whole_heap = ["PTR_FORMAT","PTR_FORMAT")", " card marking array's _whole_heap = [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end()))); p2i(p), p2i(_whole_heap.start()), p2i(_whole_heap.end())));
return byte_for(p) - _byte_map; return byte_for(p) - _byte_map;
} }

2
hotspot/src/share/vm/gc/shared/generation.cpp
View file

@ -173,7 +173,7 @@ bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const
bool res = (available >= max_promotion_in_bytes); bool res = (available >= max_promotion_in_bytes);
if (PrintGC && Verbose) { if (PrintGC && Verbose) {
gclog_or_tty->print_cr( gclog_or_tty->print_cr(
"Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")", "Generation: promo attempt is%s safe: available(" SIZE_FORMAT ") %s max_promo(" SIZE_FORMAT ")",
res? "":" not", available, res? ">=":"<", res? "":" not", available, res? ">=":"<",
max_promotion_in_bytes); max_promotion_in_bytes);
} }

12
hotspot/src/share/vm/gc/shared/plab.cpp
View file

@ -45,7 +45,7 @@ PLAB::PLAB(size_t desired_plab_sz_) :
// ArrayOopDesc::header_size depends on command line initialization. // ArrayOopDesc::header_size depends on command line initialization.
AlignmentReserve = oopDesc::header_size() > MinObjAlignment ? align_object_size(arrayOopDesc::header_size(T_INT)) : 0; AlignmentReserve = oopDesc::header_size() > MinObjAlignment ? align_object_size(arrayOopDesc::header_size(T_INT)) : 0;
assert(min_size() > AlignmentReserve, assert(min_size() > AlignmentReserve,
err_msg("Minimum PLAB size " SIZE_FORMAT" must be larger than alignment reserve " SIZE_FORMAT" " err_msg("Minimum PLAB size " SIZE_FORMAT " must be larger than alignment reserve " SIZE_FORMAT " "
"to be able to contain objects", min_size(), AlignmentReserve)); "to be able to contain objects", min_size(), AlignmentReserve));
} }
@ -121,10 +121,10 @@ void PLABStats::adjust_desired_plab_sz(uint no_of_gc_workers) {
if (_allocated == 0) { if (_allocated == 0) {
assert(_unused == 0, assert(_unused == 0,
err_msg("Inconsistency in PLAB stats: " err_msg("Inconsistency in PLAB stats: "
"_allocated: "SIZE_FORMAT", " "_allocated: " SIZE_FORMAT ", "
"_wasted: "SIZE_FORMAT", " "_wasted: " SIZE_FORMAT ", "
"_unused: "SIZE_FORMAT", " "_unused: " SIZE_FORMAT ", "
"_undo_wasted: "SIZE_FORMAT, "_undo_wasted: " SIZE_FORMAT,
_allocated, _wasted, _unused, _undo_wasted)); _allocated, _wasted, _unused, _undo_wasted));
_allocated = 1; _allocated = 1;
@ -144,7 +144,7 @@ void PLABStats::adjust_desired_plab_sz(uint no_of_gc_workers) {
new_plab_sz = align_object_size(new_plab_sz); new_plab_sz = align_object_size(new_plab_sz);
// Latch the result // Latch the result
if (PrintPLAB) { if (PrintPLAB) {
gclog_or_tty->print(" (plab_sz = " SIZE_FORMAT" desired_plab_sz = " SIZE_FORMAT") ", recent_plab_sz, new_plab_sz); gclog_or_tty->print(" (plab_sz = " SIZE_FORMAT " desired_plab_sz = " SIZE_FORMAT ") ", recent_plab_sz, new_plab_sz);
} }
_desired_plab_sz = new_plab_sz; _desired_plab_sz = new_plab_sz;

8
hotspot/src/share/vm/gc/shared/threadLocalAllocBuffer.inline.hpp
View file

@ -93,10 +93,10 @@ void ThreadLocalAllocBuffer::record_slow_allocation(size_t obj_size) {
if (PrintTLAB && Verbose) { if (PrintTLAB && Verbose) {
Thread* thrd = myThread(); Thread* thrd = myThread();
gclog_or_tty->print("TLAB: %s thread: "INTPTR_FORMAT" [id: %2d]" gclog_or_tty->print("TLAB: %s thread: " INTPTR_FORMAT " [id: %2d]"
" obj: "SIZE_FORMAT " obj: " SIZE_FORMAT
" free: "SIZE_FORMAT " free: " SIZE_FORMAT
" waste: "SIZE_FORMAT"\n", " waste: " SIZE_FORMAT "\n",
"slow", p2i(thrd), thrd->osthread()->thread_id(), "slow", p2i(thrd), thrd->osthread()->thread_id(),
obj_size, free(), refill_waste_limit()); obj_size, free(), refill_waste_limit());
} }

2
hotspot/src/share/vm/memory/allocation.cpp
View file

@ -752,7 +752,7 @@ julong AllocStats::free_bytes() { return os::free_bytes - start_mfree_bytes; }
julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; } julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; }
void AllocStats::print() { void AllocStats::print() {
tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), " tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), "
UINT64_FORMAT" frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc", UINT64_FORMAT " frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc",
num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M); num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M);
} }

2
hotspot/src/share/vm/memory/universe.cpp
View file

@ -805,7 +805,7 @@ void Universe::print_compressed_oops_mode(outputStream* st) {
ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) { ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) {
assert(alignment <= Arguments::conservative_max_heap_alignment(), assert(alignment <= Arguments::conservative_max_heap_alignment(),
err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT, err_msg("actual alignment " SIZE_FORMAT " must be within maximum heap alignment " SIZE_FORMAT,
alignment, Arguments::conservative_max_heap_alignment())); alignment, Arguments::conservative_max_heap_alignment()));
size_t total_reserved = align_size_up(heap_size, alignment); size_t total_reserved = align_size_up(heap_size, alignment);

2
hotspot/src/share/vm/oops/constantPool.cpp
View file

@ -1467,7 +1467,7 @@ static void print_cpool_bytes(jint cnt, u1 *bytes) {
} }
case JVM_CONSTANT_Long: { case JVM_CONSTANT_Long: {
u8 val = Bytes::get_Java_u8(bytes); u8 val = Bytes::get_Java_u8(bytes);
printf("long "INT64_FORMAT, (int64_t) *(jlong *) &val); printf("long " INT64_FORMAT, (int64_t) *(jlong *) &val);
ent_size = 8; ent_size = 8;
idx++; // Long takes two cpool slots idx++; // Long takes two cpool slots
break; break;

10
hotspot/src/share/vm/oops/cpCache.cpp
View file

@ -308,7 +308,7 @@ void ConstantPoolCacheEntry::set_method_handle_common(constantPoolHandle cpool,
adapter->size_of_parameters()); adapter->size_of_parameters());
if (TraceInvokeDynamic) { if (TraceInvokeDynamic) {
tty->print_cr("set_method_handle bc=%d appendix="PTR_FORMAT"%s method_type="PTR_FORMAT"%s method="PTR_FORMAT" ", tty->print_cr("set_method_handle bc=%d appendix=" PTR_FORMAT "%s method_type=" PTR_FORMAT "%s method=" PTR_FORMAT " ",
invoke_code, invoke_code,
(void *)appendix(), (has_appendix ? "" : " (unused)"), (void *)appendix(), (has_appendix ? "" : " (unused)"),
(void *)method_type(), (has_method_type ? "" : " (unused)"), (void *)method_type(), (has_method_type ? "" : " (unused)"),
@ -538,12 +538,12 @@ void ConstantPoolCacheEntry::print(outputStream* st, int index) const {
// print separator // print separator
if (index == 0) st->print_cr(" -------------"); if (index == 0) st->print_cr(" -------------");
// print entry // print entry
st->print("%3d ("PTR_FORMAT") ", index, (intptr_t)this); st->print("%3d (" PTR_FORMAT ") ", index, (intptr_t)this);
st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(), st->print_cr("[%02x|%02x|%5d]", bytecode_2(), bytecode_1(),
constant_pool_index()); constant_pool_index());
st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f1); st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f1);
st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_f2); st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_f2);
st->print_cr(" [ "PTR_FORMAT"]", (intptr_t)_flags); st->print_cr(" [ " PTR_FORMAT "]", (intptr_t)_flags);
st->print_cr(" -------------"); st->print_cr(" -------------");
} }

2
hotspot/src/share/vm/oops/markOop.cpp
View file

@ -49,7 +49,7 @@ void markOopDesc::print_on(outputStream* st) const {
st->print("monitor=NULL"); st->print("monitor=NULL");
else { else {
BasicLock * bl = (BasicLock *) mon->owner(); BasicLock * bl = (BasicLock *) mon->owner();
st->print("monitor={count="INTPTR_FORMAT",waiters="INTPTR_FORMAT",recursions="INTPTR_FORMAT",owner="INTPTR_FORMAT"}", st->print("monitor={count=" INTPTR_FORMAT ",waiters=" INTPTR_FORMAT ",recursions=" INTPTR_FORMAT ",owner=" INTPTR_FORMAT "}",
mon->count(), mon->waiters(), mon->recursions(), p2i(bl)); mon->count(), mon->waiters(), mon->recursions(), p2i(bl));
} }
} else { } else {

4
hotspot/src/share/vm/oops/method.cpp
View file

@ -2018,9 +2018,9 @@ void Method::print_on(outputStream* st) const {
assert(is_method(), "must be method"); assert(is_method(), "must be method");
st->print_cr("%s", internal_name()); st->print_cr("%s", internal_name());
// get the effect of PrintOopAddress, always, for methods: // get the effect of PrintOopAddress, always, for methods:
st->print_cr(" - this oop: "INTPTR_FORMAT, (intptr_t)this); st->print_cr(" - this oop: " INTPTR_FORMAT, (intptr_t)this);
st->print (" - method holder: "); method_holder()->print_value_on(st); st->cr(); st->print (" - method holder: "); method_holder()->print_value_on(st); st->cr();
st->print (" - constants: "INTPTR_FORMAT" ", (address)constants()); st->print (" - constants: " INTPTR_FORMAT " ", (address)constants());
constants()->print_value_on(st); st->cr(); constants()->print_value_on(st); st->cr();
st->print (" - access: 0x%x ", access_flags().as_int()); access_flags().print_on(st); st->cr(); st->print (" - access: 0x%x ", access_flags().as_int()); access_flags().print_on(st); st->cr();
st->print (" - name: "); name()->print_value_on(st); st->cr(); st->print (" - name: "); name()->print_value_on(st); st->cr();

2
hotspot/src/share/vm/oops/objArrayKlass.cpp
View file

@ -466,7 +466,7 @@ void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
if (i > max_objArray_print_length) { if (i > max_objArray_print_length) {
st->print("..."); break; st->print("..."); break;
} }
st->print(" "INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i)); st->print(" " INTPTR_FORMAT, (intptr_t)(void*)objArrayOop(obj)->obj_at(i));
} }
st->print(" }"); st->print(" }");
} }

2
hotspot/src/share/vm/oops/oop.cpp
View file

@ -47,7 +47,7 @@ void oopDesc::print_on(outputStream* st) const {
void oopDesc::print_address_on(outputStream* st) const { void oopDesc::print_address_on(outputStream* st) const {
if (PrintOopAddress) { if (PrintOopAddress) {
st->print("{"INTPTR_FORMAT"}", this); st->print("{" INTPTR_FORMAT "}", this);
} }
} }

4
hotspot/src/share/vm/opto/callnode.cpp
View file

@ -342,7 +342,7 @@ static void format_helper( PhaseRegAlloc *regalloc, outputStream* st, Node *n, c
const Type *t = n->bottom_type(); const Type *t = n->bottom_type();
switch (t->base()) { switch (t->base()) {
case Type::Int: case Type::Int:
st->print(" %s%d]=#"INT32_FORMAT,msg,i,t->is_int()->get_con()); st->print(" %s%d]=#" INT32_FORMAT,msg,i,t->is_int()->get_con());
break; break;
case Type::AnyPtr: case Type::AnyPtr:
assert( t == TypePtr::NULL_PTR || n->in_dump(), "" ); assert( t == TypePtr::NULL_PTR || n->in_dump(), "" );
@ -371,7 +371,7 @@ static void format_helper( PhaseRegAlloc *regalloc, outputStream* st, Node *n, c
st->print(" %s%d]=#%fF",msg,i,t->is_float_constant()->_f); st->print(" %s%d]=#%fF",msg,i,t->is_float_constant()->_f);
break; break;
case Type::Long: case Type::Long:
st->print(" %s%d]=#"INT64_FORMAT,msg,i,(int64_t)(t->is_long()->get_con())); st->print(" %s%d]=#" INT64_FORMAT,msg,i,(int64_t)(t->is_long()->get_con()));
break; break;
case Type::Half: case Type::Half:
case Type::Top: case Type::Top:

44
hotspot/src/share/vm/prims/methodHandles.cpp
View file

@ -1389,41 +1389,41 @@ JVM_END
#define LANG "Ljava/lang/" #define LANG "Ljava/lang/"
#define JLINV "Ljava/lang/invoke/" #define JLINV "Ljava/lang/invoke/"
#define OBJ LANG"Object;" #define OBJ LANG "Object;"
#define CLS LANG"Class;" #define CLS LANG "Class;"
#define STRG LANG"String;" #define STRG LANG "String;"
#define CS JLINV"CallSite;" #define CS JLINV "CallSite;"
#define MT JLINV"MethodType;" #define MT JLINV "MethodType;"
#define MH JLINV"MethodHandle;" #define MH JLINV "MethodHandle;"
#define MEM JLINV"MemberName;" #define MEM JLINV "MemberName;"
#define CTX JLINV"MethodHandleNatives$CallSiteContext;" #define CTX JLINV "MethodHandleNatives$CallSiteContext;"
#define CC (char*) /*cast a literal from (const char*)*/ #define CC (char*) /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
// These are the native methods on java.lang.invoke.MethodHandleNatives. // These are the native methods on java.lang.invoke.MethodHandleNatives.
static JNINativeMethod MHN_methods[] = { static JNINativeMethod MHN_methods[] = {
{CC"init", CC"("MEM""OBJ")V", FN_PTR(MHN_init_Mem)}, {CC "init", CC "(" MEM "" OBJ ")V", FN_PTR(MHN_init_Mem)},
{CC"expand", CC"("MEM")V", FN_PTR(MHN_expand_Mem)}, {CC "expand", CC "(" MEM ")V", FN_PTR(MHN_expand_Mem)},
{CC"resolve", CC"("MEM""CLS")"MEM, FN_PTR(MHN_resolve_Mem)}, {CC "resolve", CC "(" MEM "" CLS ")" MEM, FN_PTR(MHN_resolve_Mem)},
// static native int getNamedCon(int which, Object[] name) // static native int getNamedCon(int which, Object[] name)
{CC"getNamedCon", CC"(I["OBJ")I", FN_PTR(MHN_getNamedCon)}, {CC "getNamedCon", CC "(I[" OBJ ")I", FN_PTR(MHN_getNamedCon)},
// static native int getMembers(Class<?> defc, String matchName, String matchSig, // static native int getMembers(Class<?> defc, String matchName, String matchSig,
// int matchFlags, Class<?> caller, int skip, MemberName[] results); // int matchFlags, Class<?> caller, int skip, MemberName[] results);
{CC"getMembers", CC"("CLS""STRG""STRG"I"CLS"I["MEM")I", FN_PTR(MHN_getMembers)}, {CC "getMembers", CC "(" CLS "" STRG "" STRG "I" CLS "I[" MEM ")I", FN_PTR(MHN_getMembers)},
{CC"objectFieldOffset", CC"("MEM")J", FN_PTR(MHN_objectFieldOffset)}, {CC "objectFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_objectFieldOffset)},
{CC"setCallSiteTargetNormal", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetNormal)}, {CC "setCallSiteTargetNormal", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetNormal)},
{CC"setCallSiteTargetVolatile", CC"("CS""MH")V", FN_PTR(MHN_setCallSiteTargetVolatile)}, {CC "setCallSiteTargetVolatile", CC "(" CS "" MH ")V", FN_PTR(MHN_setCallSiteTargetVolatile)},
{CC"clearCallSiteContext", CC"("CTX")V", FN_PTR(MHN_clearCallSiteContext)}, {CC "clearCallSiteContext", CC "(" CTX ")V", FN_PTR(MHN_clearCallSiteContext)},
{CC"staticFieldOffset", CC"("MEM")J", FN_PTR(MHN_staticFieldOffset)}, {CC "staticFieldOffset", CC "(" MEM ")J", FN_PTR(MHN_staticFieldOffset)},
{CC"staticFieldBase", CC"("MEM")"OBJ, FN_PTR(MHN_staticFieldBase)}, {CC "staticFieldBase", CC "(" MEM ")" OBJ, FN_PTR(MHN_staticFieldBase)},
{CC"getMemberVMInfo", CC"("MEM")"OBJ, FN_PTR(MHN_getMemberVMInfo)} {CC "getMemberVMInfo", CC "(" MEM ")" OBJ, FN_PTR(MHN_getMemberVMInfo)}
}; };
static JNINativeMethod MH_methods[] = { static JNINativeMethod MH_methods[] = {
// UnsupportedOperationException throwers // UnsupportedOperationException throwers
{CC"invoke", CC"(["OBJ")"OBJ, FN_PTR(MH_invoke_UOE)}, {CC "invoke", CC "([" OBJ ")" OBJ, FN_PTR(MH_invoke_UOE)},
{CC"invokeExact", CC"(["OBJ")"OBJ, FN_PTR(MH_invokeExact_UOE)} {CC "invokeExact", CC "([" OBJ ")" OBJ, FN_PTR(MH_invokeExact_UOE)}
}; };
/** /**

16
hotspot/src/share/vm/prims/perf.cpp
View file

@ -295,17 +295,17 @@ PERF_END
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
#define BB "Ljava/nio/ByteBuffer;" #define BB "Ljava/nio/ByteBuffer;"
#define JLS "Ljava/lang/String;" #define JLS "Ljava/lang/String;"
#define CL_ARGS CC"("JLS"IIJ)"BB #define CL_ARGS CC "(" JLS "IIJ)" BB
#define CBA_ARGS CC"("JLS"II[BI)"BB #define CBA_ARGS CC "(" JLS "II[BI)" BB
static JNINativeMethod perfmethods[] = { static JNINativeMethod perfmethods[] = {
{CC"attach", CC"("JLS"II)"BB, FN_PTR(Perf_Attach)}, {CC "attach", CC "(" JLS "II)" BB, FN_PTR(Perf_Attach)},
{CC"detach", CC"("BB")V", FN_PTR(Perf_Detach)}, {CC "detach", CC "(" BB ")V", FN_PTR(Perf_Detach)},
{CC"createLong", CL_ARGS, FN_PTR(Perf_CreateLong)}, {CC "createLong", CL_ARGS, FN_PTR(Perf_CreateLong)},
{CC"createByteArray", CBA_ARGS, FN_PTR(Perf_CreateByteArray)}, {CC "createByteArray", CBA_ARGS, FN_PTR(Perf_CreateByteArray)},
{CC"highResCounter", CC"()J", FN_PTR(Perf_HighResCounter)}, {CC "highResCounter", CC "()J", FN_PTR(Perf_HighResCounter)},
{CC"highResFrequency", CC"()J", FN_PTR(Perf_HighResFrequency)} {CC "highResFrequency", CC "()J", FN_PTR(Perf_HighResFrequency)}
}; };
#undef CBA_ARGS #undef CBA_ARGS

106
hotspot/src/share/vm/prims/unsafe.cpp
View file

@ -1206,39 +1206,39 @@ UNSAFE_END
#define LANG "Ljava/lang/" #define LANG "Ljava/lang/"
#define OBJ LANG"Object;" #define OBJ LANG "Object;"
#define CLS LANG"Class;" #define CLS LANG "Class;"
#define FLD LANG"reflect/Field;" #define FLD LANG "reflect/Field;"
#define THR LANG"Throwable;" #define THR LANG "Throwable;"
#define DC_Args LANG"String;[BII" LANG"ClassLoader;" "Ljava/security/ProtectionDomain;" #define DC_Args LANG "String;[BII" LANG "ClassLoader;" "Ljava/security/ProtectionDomain;"
#define DAC_Args CLS"[B["OBJ #define DAC_Args CLS "[B[" OBJ
#define CC (char*) /*cast a literal from (const char*)*/ #define CC (char*) /*cast a literal from (const char*)*/
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f) #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
#define DECLARE_GETPUTOOP(Boolean, Z) \ #define DECLARE_GETPUTOOP(Boolean, Z) \
{CC"get"#Boolean, CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean)}, \ {CC "get" #Boolean, CC "(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean)}, \
{CC"put"#Boolean, CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean)}, \ {CC "put" #Boolean, CC "(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean)}, \
{CC"get"#Boolean"Volatile", CC"("OBJ"J)"#Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \ {CC "get" #Boolean "Volatile", CC "(" OBJ "J)" #Z, FN_PTR(Unsafe_Get##Boolean##Volatile)}, \
{CC"put"#Boolean"Volatile", CC"("OBJ"J"#Z")V", FN_PTR(Unsafe_Set##Boolean##Volatile)} {CC "put" #Boolean "Volatile", CC "(" OBJ "J" #Z ")V", FN_PTR(Unsafe_Set##Boolean##Volatile)}
#define DECLARE_GETPUTNATIVE(Byte, B) \ #define DECLARE_GETPUTNATIVE(Byte, B) \
{CC"get"#Byte, CC"("ADR")"#B, FN_PTR(Unsafe_GetNative##Byte)}, \ {CC "get" #Byte, CC "(" ADR ")" #B, FN_PTR(Unsafe_GetNative##Byte)}, \
{CC"put"#Byte, CC"("ADR#B")V", FN_PTR(Unsafe_SetNative##Byte)} {CC "put" #Byte, CC "(" ADR#B ")V", FN_PTR(Unsafe_SetNative##Byte)}
static JNINativeMethod methods[] = { static JNINativeMethod methods[] = {
{CC"getObject", CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObject)}, {CC "getObject", CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObject)},
{CC"putObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObject)}, {CC "putObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObject)},
{CC"getObjectVolatile",CC"("OBJ"J)"OBJ"", FN_PTR(Unsafe_GetObjectVolatile)}, {CC "getObjectVolatile",CC "(" OBJ "J)" OBJ "", FN_PTR(Unsafe_GetObjectVolatile)},
{CC"putObjectVolatile",CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetObjectVolatile)}, {CC "putObjectVolatile",CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetObjectVolatile)},
{CC"getUncompressedObject", CC"("ADR")"OBJ, FN_PTR(Unsafe_GetUncompressedObject)}, {CC "getUncompressedObject", CC "(" ADR ")" OBJ, FN_PTR(Unsafe_GetUncompressedObject)},
{CC"getJavaMirror", CC"("ADR")"CLS, FN_PTR(Unsafe_GetJavaMirror)}, {CC "getJavaMirror", CC "(" ADR ")" CLS, FN_PTR(Unsafe_GetJavaMirror)},
{CC"getKlassPointer", CC"("OBJ")"ADR, FN_PTR(Unsafe_GetKlassPointer)}, {CC "getKlassPointer", CC "(" OBJ ")" ADR, FN_PTR(Unsafe_GetKlassPointer)},
DECLARE_GETPUTOOP(Boolean, Z), DECLARE_GETPUTOOP(Boolean, Z),
DECLARE_GETPUTOOP(Byte, B), DECLARE_GETPUTOOP(Byte, B),
@ -1257,49 +1257,49 @@ static JNINativeMethod methods[] = {
DECLARE_GETPUTNATIVE(Float, F), DECLARE_GETPUTNATIVE(Float, F),
DECLARE_GETPUTNATIVE(Double, D), DECLARE_GETPUTNATIVE(Double, D),
{CC"getAddress", CC"("ADR")"ADR, FN_PTR(Unsafe_GetNativeAddress)}, {CC "getAddress", CC "(" ADR ")" ADR, FN_PTR(Unsafe_GetNativeAddress)},
{CC"putAddress", CC"("ADR""ADR")V", FN_PTR(Unsafe_SetNativeAddress)}, {CC "putAddress", CC "(" ADR "" ADR ")V", FN_PTR(Unsafe_SetNativeAddress)},
{CC"allocateMemory", CC"(J)"ADR, FN_PTR(Unsafe_AllocateMemory)}, {CC "allocateMemory", CC "(J)" ADR, FN_PTR(Unsafe_AllocateMemory)},
{CC"reallocateMemory", CC"("ADR"J)"ADR, FN_PTR(Unsafe_ReallocateMemory)}, {CC "reallocateMemory", CC "(" ADR "J)" ADR, FN_PTR(Unsafe_ReallocateMemory)},
{CC"freeMemory", CC"("ADR")V", FN_PTR(Unsafe_FreeMemory)}, {CC "freeMemory", CC "(" ADR ")V", FN_PTR(Unsafe_FreeMemory)},
{CC"objectFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_ObjectFieldOffset)}, {CC "objectFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_ObjectFieldOffset)},
{CC"staticFieldOffset", CC"("FLD")J", FN_PTR(Unsafe_StaticFieldOffset)}, {CC "staticFieldOffset", CC "(" FLD ")J", FN_PTR(Unsafe_StaticFieldOffset)},
{CC"staticFieldBase", CC"("FLD")"OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)}, {CC "staticFieldBase", CC "(" FLD ")" OBJ, FN_PTR(Unsafe_StaticFieldBaseFromField)},
{CC"ensureClassInitialized",CC"("CLS")V", FN_PTR(Unsafe_EnsureClassInitialized)}, {CC "ensureClassInitialized",CC "(" CLS ")V", FN_PTR(Unsafe_EnsureClassInitialized)},
{CC"arrayBaseOffset", CC"("CLS")I", FN_PTR(Unsafe_ArrayBaseOffset)}, {CC "arrayBaseOffset", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayBaseOffset)},
{CC"arrayIndexScale", CC"("CLS")I", FN_PTR(Unsafe_ArrayIndexScale)}, {CC "arrayIndexScale", CC "(" CLS ")I", FN_PTR(Unsafe_ArrayIndexScale)},
{CC"addressSize", CC"()I", FN_PTR(Unsafe_AddressSize)}, {CC "addressSize", CC "()I", FN_PTR(Unsafe_AddressSize)},
{CC"pageSize", CC"()I", FN_PTR(Unsafe_PageSize)}, {CC "pageSize", CC "()I", FN_PTR(Unsafe_PageSize)},
{CC"defineClass", CC"("DC_Args")"CLS, FN_PTR(Unsafe_DefineClass)}, {CC "defineClass", CC "(" DC_Args ")" CLS, FN_PTR(Unsafe_DefineClass)},
{CC"allocateInstance", CC"("CLS")"OBJ, FN_PTR(Unsafe_AllocateInstance)}, {CC "allocateInstance", CC "(" CLS ")" OBJ, FN_PTR(Unsafe_AllocateInstance)},
{CC"throwException", CC"("THR")V", FN_PTR(Unsafe_ThrowException)}, {CC "throwException", CC "(" THR ")V", FN_PTR(Unsafe_ThrowException)},
{CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z", FN_PTR(Unsafe_CompareAndSwapObject)}, {CC "compareAndSwapObject", CC "(" OBJ "J" OBJ "" OBJ ")Z", FN_PTR(Unsafe_CompareAndSwapObject)},
{CC"compareAndSwapInt", CC"("OBJ"J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)}, {CC "compareAndSwapInt", CC "(" OBJ "J""I""I"")Z", FN_PTR(Unsafe_CompareAndSwapInt)},
{CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)}, {CC "compareAndSwapLong", CC "(" OBJ "J""J""J"")Z", FN_PTR(Unsafe_CompareAndSwapLong)},
{CC"putOrderedObject", CC"("OBJ"J"OBJ")V", FN_PTR(Unsafe_SetOrderedObject)}, {CC "putOrderedObject", CC "(" OBJ "J" OBJ ")V", FN_PTR(Unsafe_SetOrderedObject)},
{CC"putOrderedInt", CC"("OBJ"JI)V", FN_PTR(Unsafe_SetOrderedInt)}, {CC "putOrderedInt", CC "(" OBJ "JI)V", FN_PTR(Unsafe_SetOrderedInt)},
{CC"putOrderedLong", CC"("OBJ"JJ)V", FN_PTR(Unsafe_SetOrderedLong)}, {CC "putOrderedLong", CC "(" OBJ "JJ)V", FN_PTR(Unsafe_SetOrderedLong)},
{CC"park", CC"(ZJ)V", FN_PTR(Unsafe_Park)}, {CC "park", CC "(ZJ)V", FN_PTR(Unsafe_Park)},
{CC"unpark", CC"("OBJ")V", FN_PTR(Unsafe_Unpark)}, {CC "unpark", CC "(" OBJ ")V", FN_PTR(Unsafe_Unpark)},
{CC"getLoadAverage", CC"([DI)I", FN_PTR(Unsafe_Loadavg)}, {CC "getLoadAverage", CC "([DI)I", FN_PTR(Unsafe_Loadavg)},
{CC"copyMemory", CC"("OBJ"J"OBJ"JJ)V", FN_PTR(Unsafe_CopyMemory)}, {CC "copyMemory", CC "(" OBJ "J" OBJ "JJ)V", FN_PTR(Unsafe_CopyMemory)},
{CC"setMemory", CC"("OBJ"JJB)V", FN_PTR(Unsafe_SetMemory)}, {CC "setMemory", CC "(" OBJ "JJB)V", FN_PTR(Unsafe_SetMemory)},
{CC"defineAnonymousClass", CC"("DAC_Args")"CLS, FN_PTR(Unsafe_DefineAnonymousClass)}, {CC "defineAnonymousClass", CC "(" DAC_Args ")" CLS, FN_PTR(Unsafe_DefineAnonymousClass)},
{CC"shouldBeInitialized",CC"("CLS")Z", FN_PTR(Unsafe_ShouldBeInitialized)}, {CC "shouldBeInitialized",CC "(" CLS ")Z", FN_PTR(Unsafe_ShouldBeInitialized)},
{CC"loadFence", CC"()V", FN_PTR(Unsafe_LoadFence)}, {CC "loadFence", CC "()V", FN_PTR(Unsafe_LoadFence)},
{CC"storeFence", CC"()V", FN_PTR(Unsafe_StoreFence)}, {CC "storeFence", CC "()V", FN_PTR(Unsafe_StoreFence)},
{CC"fullFence", CC"()V", FN_PTR(Unsafe_FullFence)}, {CC "fullFence", CC "()V", FN_PTR(Unsafe_FullFence)},
{CC"isBigEndian0", CC"()Z", FN_PTR(Unsafe_isBigEndian0)}, {CC "isBigEndian0", CC "()Z", FN_PTR(Unsafe_isBigEndian0)},
{CC"unalignedAccess0", CC"()Z", FN_PTR(Unsafe_unalignedAccess0)} {CC "unalignedAccess0", CC "()Z", FN_PTR(Unsafe_unalignedAccess0)}
}; };
#undef CC #undef CC

12
hotspot/src/share/vm/prims/whitebox.cpp
View file

@ -159,8 +159,8 @@ WB_END
WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) { WB_ENTRY(void, WB_PrintHeapSizes(JNIEnv* env, jobject o)) {
CollectorPolicy * p = Universe::heap()->collector_policy(); CollectorPolicy * p = Universe::heap()->collector_policy();
gclog_or_tty->print_cr("Minimum heap "SIZE_FORMAT" Initial heap " gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
SIZE_FORMAT" Maximum heap "SIZE_FORMAT" Space alignment "SIZE_FORMAT" Heap alignment "SIZE_FORMAT, SIZE_FORMAT " Maximum heap " SIZE_FORMAT " Space alignment " SIZE_FORMAT " Heap alignment " SIZE_FORMAT,
p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(), p->min_heap_byte_size(), p->initial_heap_byte_size(), p->max_heap_byte_size(),
p->space_alignment(), p->heap_alignment()); p->space_alignment(), p->heap_alignment());
} }
@ -195,8 +195,8 @@ WB_ENTRY(void, WB_ReadFromNoaccessArea(JNIEnv* env, jobject o))
Universe::narrow_oop_use_implicit_null_checks() )) { Universe::narrow_oop_use_implicit_null_checks() )) {
tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n " tty->print_cr("WB_ReadFromNoaccessArea method is useless:\n "
"\tUseCompressedOops is %d\n" "\tUseCompressedOops is %d\n"
"\trhs.base() is "PTR_FORMAT"\n" "\trhs.base() is " PTR_FORMAT "\n"
"\tUniverse::narrow_oop_base() is "PTR_FORMAT"\n" "\tUniverse::narrow_oop_base() is " PTR_FORMAT "\n"
"\tUniverse::narrow_oop_use_implicit_null_checks() is %d", "\tUniverse::narrow_oop_use_implicit_null_checks() is %d",
UseCompressedOops, UseCompressedOops,
rhs.base(), rhs.base(),
@ -249,8 +249,8 @@ static jint wb_stress_virtual_space_resize(size_t reserved_space_size,
WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o, WB_ENTRY(jint, WB_StressVirtualSpaceResize(JNIEnv* env, jobject o,
jlong reserved_space_size, jlong magnitude, jlong iterations)) jlong reserved_space_size, jlong magnitude, jlong iterations))
tty->print_cr("reservedSpaceSize="JLONG_FORMAT", magnitude="JLONG_FORMAT", " tty->print_cr("reservedSpaceSize=" JLONG_FORMAT ", magnitude=" JLONG_FORMAT ", "
"iterations="JLONG_FORMAT"\n", reserved_space_size, magnitude, "iterations=" JLONG_FORMAT "\n", reserved_space_size, magnitude,
iterations); iterations);
if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) { if (reserved_space_size < 0 || magnitude < 0 || iterations < 0) {
tty->print_cr("One of variables printed above is negative. Can't proceed.\n"); tty->print_cr("One of variables printed above is negative. Can't proceed.\n");

8
hotspot/src/share/vm/runtime/commandLineFlagRangeList.cpp
View file

@ -84,7 +84,7 @@ public:
} }
void print(outputStream* st) { void print(outputStream* st) {
st->print("[ "INTX_FORMAT_W(-25)" ... "INTX_FORMAT_W(25)" ]", _min, _max); st->print("[ " INTX_FORMAT_W(-25) " ... " INTX_FORMAT_W(25) " ]", _min, _max);
} }
}; };
@ -140,7 +140,7 @@ public:
} }
void print(outputStream* st) { void print(outputStream* st) {
st->print("[ "UINTX_FORMAT_W(-25)" ... "UINTX_FORMAT_W(25)" ]", _min, _max); st->print("[ " UINTX_FORMAT_W(-25) " ... " UINTX_FORMAT_W(25) " ]", _min, _max);
} }
}; };
@ -168,7 +168,7 @@ public:
} }
void print(outputStream* st) { void print(outputStream* st) {
st->print("[ "UINT64_FORMAT_W(-25)" ... "UINT64_FORMAT_W(25)" ]", _min, _max); st->print("[ " UINT64_FORMAT_W(-25) " ... " UINT64_FORMAT_W(25) " ]", _min, _max);
} }
}; };
@ -196,7 +196,7 @@ public:
} }
void print(outputStream* st) { void print(outputStream* st) {
st->print("[ "SIZE_FORMAT_W(-25)" ... "SIZE_FORMAT_W(25)" ]", _min, _max); st->print("[ " SIZE_FORMAT_W(-25) " ... " SIZE_FORMAT_W(25) " ]", _min, _max);
} }
}; };

2
hotspot/src/share/vm/runtime/deoptimization.cpp
View file

@ -1340,7 +1340,7 @@ JRT_ENTRY(void, Deoptimization::uncommon_trap_inner(JavaThread* thread, jint tra
ttyLocker ttyl; ttyLocker ttyl;
char buf[100]; char buf[100];
if (xtty != NULL) { if (xtty != NULL) {
xtty->begin_head("uncommon_trap thread='" UINTX_FORMAT"' %s", xtty->begin_head("uncommon_trap thread='" UINTX_FORMAT "' %s",
os::current_thread_id(), os::current_thread_id(),
format_trap_request(buf, sizeof(buf), trap_request)); format_trap_request(buf, sizeof(buf), trap_request));
nm->log_identity(xtty); nm->log_identity(xtty);

4
hotspot/src/share/vm/runtime/globals.cpp
View file

@ -1240,7 +1240,7 @@ bool CommandLineFlags::check_all_ranges_and_constraints() {
size_ranges += sizeof(CommandLineFlagRange*); size_ranges += sizeof(CommandLineFlagRange*);
} }
} }
fprintf(stderr, "Size of %d ranges: "SIZE_FORMAT" bytes\n", fprintf(stderr, "Size of %d ranges: " SIZE_FORMAT " bytes\n",
CommandLineFlagRangeList::length(), size_ranges); CommandLineFlagRangeList::length(), size_ranges);
} }
{ {
@ -1270,7 +1270,7 @@ bool CommandLineFlags::check_all_ranges_and_constraints() {
size_constraints += sizeof(CommandLineFlagConstraint*); size_constraints += sizeof(CommandLineFlagConstraint*);
} }
} }
fprintf(stderr, "Size of %d constraints: "SIZE_FORMAT" bytes\n", fprintf(stderr, "Size of %d constraints: " SIZE_FORMAT " bytes\n",
CommandLineFlagConstraintList::length(), size_constraints); CommandLineFlagConstraintList::length(), size_constraints);
} }
#endif // PRINT_RANGES_AND_CONSTRAINTS_SIZES #endif // PRINT_RANGES_AND_CONSTRAINTS_SIZES

22
hotspot/src/share/vm/runtime/safepoint.cpp
View file

@ -894,7 +894,7 @@ void ThreadSafepointState::restart() {
case _running: case _running:
default: default:
tty->print_cr("restart thread "INTPTR_FORMAT" with state %d", tty->print_cr("restart thread " INTPTR_FORMAT " with state %d",
_thread, _type); _thread, _type);
_thread->print(); _thread->print();
ShouldNotReachHere(); ShouldNotReachHere();
@ -1193,7 +1193,7 @@ void SafepointSynchronize::print_statistics() {
sstats = &_safepoint_stats[index]; sstats = &_safepoint_stats[index];
tty->print("%.3f: ", sstats->_time_stamp); tty->print("%.3f: ", sstats->_time_stamp);
tty->print("%-26s [" tty->print("%-26s ["
INT32_FORMAT_W(8)INT32_FORMAT_W(11)INT32_FORMAT_W(15) INT32_FORMAT_W(8) INT32_FORMAT_W(11) INT32_FORMAT_W(15)
" ] ", " ] ",
sstats->_vmop_type == -1 ? "no vm operation" : sstats->_vmop_type == -1 ? "no vm operation" :
VM_Operation::name(sstats->_vmop_type), VM_Operation::name(sstats->_vmop_type),
@ -1202,9 +1202,9 @@ void SafepointSynchronize::print_statistics() {
sstats->_nof_threads_wait_to_block); sstats->_nof_threads_wait_to_block);
// "/ MICROUNITS " is to convert the unit from nanos to millis. // "/ MICROUNITS " is to convert the unit from nanos to millis.
tty->print(" [" tty->print(" ["
INT64_FORMAT_W(6)INT64_FORMAT_W(6) INT64_FORMAT_W(6) INT64_FORMAT_W(6)
INT64_FORMAT_W(6)INT64_FORMAT_W(6) INT64_FORMAT_W(6) INT64_FORMAT_W(6)
INT64_FORMAT_W(6)" ] ", INT64_FORMAT_W(6) " ] ",
sstats->_time_to_spin / MICROUNITS, sstats->_time_to_spin / MICROUNITS,
sstats->_time_to_wait_to_block / MICROUNITS, sstats->_time_to_wait_to_block / MICROUNITS,
sstats->_time_to_sync / MICROUNITS, sstats->_time_to_sync / MICROUNITS,
@ -1212,9 +1212,9 @@ void SafepointSynchronize::print_statistics() {
sstats->_time_to_exec_vmop / MICROUNITS); sstats->_time_to_exec_vmop / MICROUNITS);
if (need_to_track_page_armed_status) { if (need_to_track_page_armed_status) {
tty->print(INT32_FORMAT" ", sstats->_page_armed); tty->print(INT32_FORMAT " ", sstats->_page_armed);
} }
tty->print_cr(INT32_FORMAT" ", sstats->_nof_threads_hit_page_trap); tty->print_cr(INT32_FORMAT " ", sstats->_nof_threads_hit_page_trap);
} }
} }
@ -1249,17 +1249,17 @@ void SafepointSynchronize::print_stat_on_exit() {
for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) { for (int index = 0; index < VM_Operation::VMOp_Terminating; index++) {
if (_safepoint_reasons[index] != 0) { if (_safepoint_reasons[index] != 0) {
tty->print_cr("%-26s"UINT64_FORMAT_W(10), VM_Operation::name(index), tty->print_cr("%-26s" UINT64_FORMAT_W(10), VM_Operation::name(index),
_safepoint_reasons[index]); _safepoint_reasons[index]);
} }
} }
tty->print_cr(UINT64_FORMAT_W(5)" VM operations coalesced during safepoint", tty->print_cr(UINT64_FORMAT_W(5) " VM operations coalesced during safepoint",
_coalesced_vmop_count); _coalesced_vmop_count);
tty->print_cr("Maximum sync time "INT64_FORMAT_W(5)" ms", tty->print_cr("Maximum sync time " INT64_FORMAT_W(5) " ms",
_max_sync_time / MICROUNITS); _max_sync_time / MICROUNITS);
tty->print_cr("Maximum vm operation time (except for Exit VM operation) " tty->print_cr("Maximum vm operation time (except for Exit VM operation) "
INT64_FORMAT_W(5)" ms", INT64_FORMAT_W(5) " ms",
_max_vmop_time / MICROUNITS); _max_vmop_time / MICROUNITS);
} }

2
hotspot/src/share/vm/runtime/unhandledOops.cpp
View file

@ -105,7 +105,7 @@ void UnhandledOops::unregister_unhandled_oop(oop* op) {
_level --; _level --;
if (unhandled_oop_print) { if (unhandled_oop_print) {
for (int i=0; i<_level; i++) tty->print(" "); for (int i=0; i<_level; i++) tty->print(" ");
tty->print_cr("u "INTPTR_FORMAT, op); tty->print_cr("u " INTPTR_FORMAT, op);
} }
int i = _oop_list->find_from_end(op, match_oop_entry); int i = _oop_list->find_from_end(op, match_oop_entry);

2
hotspot/src/share/vm/services/diagnosticArgument.cpp
View file

@ -89,7 +89,7 @@ template <> void DCmdArgument<jlong>::parse_value(const char* str,
size_t len, TRAPS) { size_t len, TRAPS) {
int scanned = -1; int scanned = -1;
if (str == NULL if (str == NULL
|| sscanf(str, JLONG_FORMAT"%n", &_value, &scanned) != 1 || sscanf(str, JLONG_FORMAT "%n", &_value, &scanned) != 1
|| (size_t)scanned != len) || (size_t)scanned != len)
{ {
ResourceMark rm; ResourceMark rm;

2
hotspot/src/share/vm/services/threadService.cpp
View file

@ -888,7 +888,7 @@ void DeadlockCycle::print_on(outputStream* st) const {
st->print(" waiting to lock monitor " INTPTR_FORMAT, waitingToLockMonitor); st->print(" waiting to lock monitor " INTPTR_FORMAT, waitingToLockMonitor);
oop obj = (oop)waitingToLockMonitor->object(); oop obj = (oop)waitingToLockMonitor->object();
if (obj != NULL) { if (obj != NULL) {
st->print(" (object "INTPTR_FORMAT ", a %s)", (address)obj, st->print(" (object " INTPTR_FORMAT ", a %s)", (address)obj,
(InstanceKlass::cast(obj->klass()))->external_name()); (InstanceKlass::cast(obj->klass()))->external_name());
if (!currentThread->current_pending_monitor_is_from_java()) { if (!currentThread->current_pending_monitor_is_from_java()) {

14
hotspot/src/share/vm/trace/traceStream.hpp
View file

@ -40,31 +40,31 @@ class TraceStream : public StackObj {
TraceStream(outputStream& stream): _st(stream) {} TraceStream(outputStream& stream): _st(stream) {}
void print_val(const char* label, u1 val) { void print_val(const char* label, u1 val) {
_st.print("%s = "UINT32_FORMAT, label, val); _st.print("%s = " UINT32_FORMAT, label, val);
} }
void print_val(const char* label, u2 val) { void print_val(const char* label, u2 val) {
_st.print("%s = "UINT32_FORMAT, label, val); _st.print("%s = " UINT32_FORMAT, label, val);
} }
void print_val(const char* label, s2 val) { void print_val(const char* label, s2 val) {
_st.print("%s = "INT32_FORMAT, label, val); _st.print("%s = " INT32_FORMAT, label, val);
} }
void print_val(const char* label, u4 val) { void print_val(const char* label, u4 val) {
_st.print("%s = "UINT32_FORMAT, label, val); _st.print("%s = " UINT32_FORMAT, label, val);
} }
void print_val(const char* label, s4 val) { void print_val(const char* label, s4 val) {
_st.print("%s = "INT32_FORMAT, label, val); _st.print("%s = " INT32_FORMAT, label, val);
} }
void print_val(const char* label, u8 val) { void print_val(const char* label, u8 val) {
_st.print("%s = "UINT64_FORMAT, label, val); _st.print("%s = " UINT64_FORMAT, label, val);
} }
void print_val(const char* label, s8 val) { void print_val(const char* label, s8 val) {
_st.print("%s = "INT64_FORMAT, label, (int64_t) val); _st.print("%s = " INT64_FORMAT, label, (int64_t) val);
} }
void print_val(const char* label, bool val) { void print_val(const char* label, bool val) {

4
hotspot/src/share/vm/utilities/ostream.cpp
View file

@ -274,7 +274,7 @@ void outputStream::print_data(void* data, size_t len, bool with_ascii) {
size_t limit = (len + 16) / 16 * 16; size_t limit = (len + 16) / 16 * 16;
for (size_t i = 0; i < limit; ++i) { for (size_t i = 0; i < limit; ++i) {
if (i % 16 == 0) { if (i % 16 == 0) {
indent().print(INTPTR_FORMAT_W(07)":", i); indent().print(INTPTR_FORMAT_W(07) ":", i);
} }
if (i % 2 == 0) { if (i % 2 == 0) {
print(" "); print(" ");
@ -946,7 +946,7 @@ void defaultStream::start_log() {
// %%% Should be: jlong time_ms = os::start_time_milliseconds(), if // %%% Should be: jlong time_ms = os::start_time_milliseconds(), if
// we ever get round to introduce that method on the os class // we ever get round to introduce that method on the os class
xs->head("hotspot_log version='%d %d'" xs->head("hotspot_log version='%d %d'"
" process='%d' time_ms='"INT64_FORMAT"'", " process='%d' time_ms='" INT64_FORMAT "'",
LOG_MAJOR_VERSION, LOG_MINOR_VERSION, LOG_MAJOR_VERSION, LOG_MINOR_VERSION,
os::current_process_id(), (int64_t)time_ms); os::current_process_id(), (int64_t)time_ms);
// Write VM version header immediately. // Write VM version header immediately.