archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-25 22:04:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge

Browse source
This commit is contained in:
Jesper Wilhelmsson 2015-10-07 01:03:24 +02:00
commit e75e2e04f7
308 changed files with 5792 additions and 2256 deletions
Download patch file Download diff file Expand all files Collapse all files

2
hotspot/make/bsd/makefiles/jsig.make
View file

@ -62,7 +62,7 @@ endif
$(LIBJSIG): $(JSIGSRCDIR)/jsig.c $(LIBJSIG_MAPFILE)
@echo $(LOG_INFO) Making signal interposition lib...
$(QUIETLY) $(CC) $(SYMFLAG) $(ARCHFLAG) $(SHARED_FLAG) $(PICFLAG) \
$(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) -o $@ $<
$(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) $(EXTRA_CFLAGS) -o $@ $<
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
ifeq ($(OS_VENDOR), Darwin)
$(DSYMUTIL) $@

2
hotspot/make/linux/makefiles/gcc.make
View file

@ -207,7 +207,7 @@ ifeq ($(USE_CLANG), true)
WARNINGS_ARE_ERRORS += -Wno-return-type -Wno-empty-body
endif
WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef -Wunused-function -Wunused-value -Wformat=2 -Wreturn-type -Woverloaded-virtual
WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef -Wunused-function -Wunused-value -Wformat=2 -Wreturn-type -Woverloaded-virtual -Wno-format-zero-length
ifeq ($(USE_CLANG),)
# Since GCC 4.3, -Wconversion has changed its meanings to warn these implicit

5
hotspot/make/windows/makefiles/compile.make
View file

@ -1,5 +1,5 @@
#
# Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
@ -31,6 +31,7 @@ CXX=cl.exe
# /nologo Supress copyright message at every cl.exe startup
# /W3 Warning level 3
# /Zi Include debugging information
# /d2Zi+ Extended debugging symbols for optimized code (/Zo in VS2013 Update 3 and later)
# /WX Treat any warning error as a fatal error
# /MD Use dynamic multi-threaded runtime (msvcrt.dll or msvc*NN.dll)
# /MTd Use static multi-threaded runtime debug versions
@ -57,7 +58,7 @@ CXX_FLAGS=$(EXTRA_CFLAGS) /nologo /W3 /WX
# Let's add debug information when Full Debug Symbols is enabled
!if "$(ENABLE_FULL_DEBUG_SYMBOLS)" == "1"
CXX_FLAGS=$(CXX_FLAGS) /Zi
CXX_FLAGS=$(CXX_FLAGS) /Zi /d2Zi+
!endif
# Based on BUILDARCH we add some flags and select the default compiler name

7
hotspot/make/windows/makefiles/vm.make
View file

@ -163,6 +163,7 @@ VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/gc/serial
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/gc/cms
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/gc/g1
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/asm
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/logging
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/memory
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/oops
VM_PATH=$(VM_PATH);$(WorkSpace)/src/share/vm/prims
@ -250,6 +251,9 @@ bytecodeInterpreterWithChecks.obj: ..\generated\jvmtifiles\bytecodeInterpreterWi
{$(COMMONSRC)\share\vm\asm}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
{$(COMMONSRC)\share\vm\logging}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
{$(COMMONSRC)\share\vm\memory}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
@ -330,6 +334,9 @@ bytecodeInterpreterWithChecks.obj: ..\generated\jvmtifiles\bytecodeInterpreterWi
{$(ALTSRC)\share\vm\asm}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
{$(ALTSRC)\share\vm\logging}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<
{$(ALTSRC)\share\vm\memory}.cpp.obj::
$(CXX) $(CXX_FLAGS) $(CXX_USE_PCH) /c $<

6
hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp
View file

@ -2238,7 +2238,7 @@ void MacroAssembler::debug64(char* msg, int64_t pc, int64_t regs[])
ttyLocker ttyl;
::tty->print_cr("=============== DEBUG MESSAGE: %s ================\n",
msg);
assert(false, err_msg("DEBUG MESSAGE: %s", msg));
assert(false, "DEBUG MESSAGE: %s", msg);
}
}
@ -3075,11 +3075,15 @@ void MacroAssembler::store_check(Register obj) {
if (UseCondCardMark) {
Label L_already_dirty;
membar(StoreLoad);
ldrb(rscratch2, Address(obj, rscratch1));
cbz(rscratch2, L_already_dirty);
strb(zr, Address(obj, rscratch1));
bind(L_already_dirty);
} else {
if (UseConcMarkSweepGC && CMSPrecleaningEnabled) {
membar(StoreStore);
}
strb(zr, Address(obj, rscratch1));
}
}

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

@ -50,7 +50,7 @@ void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_
#ifdef ASSERT
static int check_nonzero(const char* xname, int x) {
assert(x != 0, err_msg("%s should be nonzero", xname));
assert(x != 0, "%s should be nonzero", xname);
return x;
}
#define NONZERO(x) check_nonzero(#x, x)
@ -407,7 +407,7 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
}
default:
fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
break;
}

2
hotspot/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp
View file

@ -1207,7 +1207,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
} else if (iid == vmIntrinsics::_invokeBasic) {
has_receiver = true;
} else {
fatal(err_msg_res("unexpected intrinsic id %d", iid));
fatal("unexpected intrinsic id %d", iid);
}
if (member_reg != noreg) {

3
hotspot/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp
View file

@ -746,6 +746,9 @@ class StubGenerator: public StubCodeGenerator {
const Register count = end; // 'end' register contains bytes count now
__ mov(scratch, (address)ct->byte_map_base);
__ add(start, start, scratch);
if (UseConcMarkSweepGC) {
__ membar(__ StoreStore);
}
__ BIND(L_loop);
__ strb(zr, Address(start, count));
__ subs(count, count, 1);

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

@ -4292,7 +4292,7 @@ const char* stop_types[] = {
static void stop_on_request(int tp, const char* msg) {
tty->print("PPC assembly code requires stop: (%s) %s\n", stop_types[tp%/*stop_end*/4], msg);
guarantee(false, err_msg("PPC assembly code requires stop: %s", msg));
guarantee(false, "PPC assembly code requires stop: %s", msg);
}
// Call a C-function that prints output.

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

@ -60,7 +60,7 @@ void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_
#ifdef ASSERT
static int check_nonzero(const char* xname, int x) {
assert(x != 0, err_msg("%s should be nonzero", xname));
assert(x != 0, "%s should be nonzero", xname);
return x;
}
#define NONZERO(x) check_nonzero(#x, x)
@ -434,7 +434,7 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
}
default:
fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
break;
}

8
hotspot/src/cpu/ppc/vm/nativeInst_ppc.cpp
View file

@ -149,7 +149,7 @@ void NativeCall::verify() {
if (!NativeCall::is_call_at(addr)) {
tty->print_cr("not a NativeCall at " PTR_FORMAT, p2i(addr));
// TODO: PPC port: Disassembler::decode(addr - 20, addr + 20, tty);
fatal(err_msg("not a NativeCall at " PTR_FORMAT, p2i(addr)));
fatal("not a NativeCall at " PTR_FORMAT, p2i(addr));
}
}
#endif // ASSERT
@ -162,7 +162,7 @@ void NativeFarCall::verify() {
if (!NativeFarCall::is_far_call_at(addr)) {
tty->print_cr("not a NativeFarCall at " PTR_FORMAT, p2i(addr));
// TODO: PPC port: Disassembler::decode(addr, 20, 20, tty);
fatal(err_msg("not a NativeFarCall at " PTR_FORMAT, p2i(addr)));
fatal("not a NativeFarCall at " PTR_FORMAT, p2i(addr));
}
}
#endif // ASSERT
@ -308,7 +308,7 @@ void NativeMovConstReg::verify() {
! MacroAssembler::is_bl(*((int*) addr))) {
tty->print_cr("not a NativeMovConstReg at " PTR_FORMAT, p2i(addr));
// TODO: PPC port: Disassembler::decode(addr, 20, 20, tty);
fatal(err_msg("not a NativeMovConstReg at " PTR_FORMAT, p2i(addr)));
fatal("not a NativeMovConstReg at " PTR_FORMAT, p2i(addr));
}
}
}
@ -346,7 +346,7 @@ void NativeJump::verify() {
if (!NativeJump::is_jump_at(addr)) {
tty->print_cr("not a NativeJump at " PTR_FORMAT, p2i(addr));
// TODO: PPC port: Disassembler::decode(addr, 20, 20, tty);
fatal(err_msg("not a NativeJump at " PTR_FORMAT, p2i(addr)));
fatal("not a NativeJump at " PTR_FORMAT, p2i(addr));
}
}
#endif // ASSERT

5
hotspot/src/cpu/ppc/vm/sharedRuntime_ppc.cpp
View file

@ -475,9 +475,8 @@ void RegisterSaver::restore_result_registers(MacroAssembler* masm, int frame_siz
// Is vector's size (in bytes) bigger than a size saved by default?
bool SharedRuntime::is_wide_vector(int size) {
ResourceMark rm;
// Note, MaxVectorSize == 8 on PPC64.
assert(size <= 8, err_msg_res("%d bytes vectors are not supported", size));
assert(size <= 8, "%d bytes vectors are not supported", size);
return size > 8;
}
#ifdef COMPILER2
@ -1631,7 +1630,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
} else if (iid == vmIntrinsics::_invokeBasic) {
has_receiver = true;
} else {
fatal(err_msg_res("unexpected intrinsic id %d", iid));
fatal("unexpected intrinsic id %d", iid);
}
if (member_reg != noreg) {

2
hotspot/src/cpu/sparc/vm/assembler_sparc.hpp
View file

@ -389,7 +389,7 @@ class Assembler : public AbstractAssembler {
static void assert_signed_range(intptr_t x, int nbits) {
assert(nbits == 32 || (-(1 << nbits-1) <= x && x < ( 1 << nbits-1)),
err_msg("value out of range: x=" INTPTR_FORMAT ", nbits=%d", x, nbits));
"value out of range: x=" INTPTR_FORMAT ", nbits=%d", x, nbits);
}
static void assert_signed_word_disp_range(intptr_t x, int nbits) {

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

@ -1596,7 +1596,7 @@ void MacroAssembler::debug(char* msg, RegistersForDebugging* regs) {
else {
::tty->print_cr("=============== DEBUG MESSAGE: %s ================\n", msg);
}
assert(false, err_msg("DEBUG MESSAGE: %s", msg));
assert(false, "DEBUG MESSAGE: %s", msg);
}

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

@ -56,7 +56,7 @@ void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_
#ifdef ASSERT
static int check_nonzero(const char* xname, int x) {
assert(x != 0, err_msg("%s should be nonzero", xname));
assert(x != 0, "%s should be nonzero", xname);
return x;
}
#define NONZERO(x) check_nonzero(#x, x)
@ -453,7 +453,7 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
}
default:
fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
break;
}

6
hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
View file

@ -316,7 +316,7 @@ void RegisterSaver::restore_result_registers(MacroAssembler* masm) {
// 8 bytes FP registers are saved by default on SPARC.
bool SharedRuntime::is_wide_vector(int size) {
// Note, MaxVectorSize == 8 on SPARC.
assert(size <= 8, err_msg_res("%d bytes vectors are not supported", size));
assert(size <= 8, "%d bytes vectors are not supported", size);
return size > 8;
}
@ -464,7 +464,7 @@ int SharedRuntime::java_calling_convention(const BasicType *sig_bt,
break;
default:
fatal(err_msg_res("unknown basic type %d", sig_bt[i]));
fatal("unknown basic type %d", sig_bt[i]);
break;
}
}
@ -1859,7 +1859,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
} else if (iid == vmIntrinsics::_invokeBasic) {
has_receiver = true;
} else {
fatal(err_msg_res("unexpected intrinsic id %d", iid));
fatal("unexpected intrinsic id %d", iid);
}
if (member_reg != noreg) {

2
hotspot/src/cpu/sparc/vm/sparc.ad
View file

@ -1098,7 +1098,7 @@ void MachConstantBaseNode::emit(CodeBuffer& cbuf, PhaseRegAlloc* ra_) const {
Register r = as_Register(ra_->get_encode(this));
CodeSection* consts_section = __ code()->consts();
int consts_size = consts_section->align_at_start(consts_section->size());
assert(constant_table.size() == consts_size, err_msg("must be: %d == %d", constant_table.size(), consts_size));
assert(constant_table.size() == consts_size, "must be: %d == %d", constant_table.size(), consts_size);
if (UseRDPCForConstantTableBase) {
// For the following RDPC logic to work correctly the consts

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

@ -733,11 +733,11 @@ address Assembler::locate_operand(address inst, WhichOperand which) {
// these asserts are somewhat nonsensical
#ifndef _LP64
assert(which == imm_operand || which == disp32_operand,
err_msg("which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, p2i(ip)));
"which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, p2i(ip));
#else
assert((which == call32_operand || which == imm_operand) && is_64bit ||
which == narrow_oop_operand && !is_64bit,
err_msg("which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, p2i(ip)));
"which %d is_64_bit %d ip " INTPTR_FORMAT, which, is_64bit, p2i(ip));
#endif // _LP64
return ip;

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

@ -2684,7 +2684,7 @@ void LIR_Assembler::comp_op(LIR_Condition condition, LIR_Opr opr1, LIR_Opr opr2,
#endif // _LP64
}
} else {
fatal(err_msg("unexpected type: %s", basictype_to_str(c->type())));
fatal("unexpected type: %s", basictype_to_str(c->type()));
}
// cpu register - address
} else if (opr2->is_address()) {

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

@ -418,7 +418,7 @@ void MacroAssembler::debug32(int rdi, int rsi, int rbp, int rsp, int rbx, int rd
::tty->print_cr("=============== DEBUG MESSAGE: %s ================\n", msg);
}
// Don't assert holding the ttyLock
assert(false, err_msg("DEBUG MESSAGE: %s", msg));
assert(false, "DEBUG MESSAGE: %s", msg);
ThreadStateTransition::transition(thread, _thread_in_vm, saved_state);
}
@ -884,7 +884,7 @@ void MacroAssembler::debug64(char* msg, int64_t pc, int64_t regs[]) {
ttyLocker ttyl;
::tty->print_cr("=============== DEBUG MESSAGE: %s ================\n",
msg);
assert(false, err_msg("DEBUG MESSAGE: %s", msg));
assert(false, "DEBUG MESSAGE: %s", msg);
}
}

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

@ -53,7 +53,7 @@ void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_
#ifdef ASSERT
static int check_nonzero(const char* xname, int x) {
assert(x != 0, err_msg("%s should be nonzero", xname));
assert(x != 0, "%s should be nonzero", xname);
return x;
}
#define NONZERO(x) check_nonzero(#x, x)
@ -456,7 +456,7 @@ void MethodHandles::generate_method_handle_dispatch(MacroAssembler* _masm,
}
default:
fatal(err_msg_res("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
break;
}

4
hotspot/src/cpu/x86/vm/register_x86.hpp
View file

@ -162,7 +162,7 @@ class XMMRegisterImpl: public AbstractRegisterImpl {
XMMRegister successor() const { return as_XMMRegister(encoding() + 1); }
// accessors
int encoding() const { assert(is_valid(), err_msg("invalid register (%d)", (int)(intptr_t)this )); return (intptr_t)this; }
int encoding() const { assert(is_valid(), "invalid register (%d)", (int)(intptr_t)this ); return (intptr_t)this; }
bool is_valid() const { return 0 <= (intptr_t)this && (intptr_t)this < number_of_registers; }
const char* name() const;
};
@ -245,7 +245,7 @@ public:
KRegister successor() const { return as_KRegister(encoding() + 1); }
// accessors
int encoding() const { assert(is_valid(), err_msg("invalid register (%d)", (int)(intptr_t)this)); return (intptr_t)this; }
int encoding() const { assert(is_valid(), "invalid register (%d)", (int)(intptr_t)this); return (intptr_t)this; }
bool is_valid() const { return 0 <= (intptr_t)this && (intptr_t)this < number_of_registers; }
const char* name() const;
};

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

@ -1434,7 +1434,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
} else if (iid == vmIntrinsics::_invokeBasic) {
has_receiver = true;
} else {
fatal(err_msg_res("unexpected intrinsic id %d", iid));
fatal("unexpected intrinsic id %d", iid);
}
if (member_reg != noreg) {

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

@ -1695,7 +1695,7 @@ static void gen_special_dispatch(MacroAssembler* masm,
} else if (iid == vmIntrinsics::_invokeBasic) {
has_receiver = true;
} else {
fatal(err_msg_res("unexpected intrinsic id %d", iid));
fatal("unexpected intrinsic id %d", iid);
}
if (member_reg != noreg) {

8
hotspot/src/os/aix/vm/os_aix.cpp
View file

@ -2286,7 +2286,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
if (!pd_commit_memory(addr, size, exec)) {
// Add extra info in product mode for vm_exit_out_of_memory():
PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -3120,8 +3120,8 @@ void os::Aix::set_signal_handler(int sig, bool set_installed) {
// libjsig also interposes the sigaction() call below and saves the
// old sigaction on it own.
} else {
fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig));
fatal("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig);
}
}
@ -3699,7 +3699,7 @@ void os::make_polling_page_unreadable(void) {
void os::make_polling_page_readable(void) {
// Changed according to os_linux.cpp.
if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) {
fatal(err_msg("Could not enable polling page at " PTR_FORMAT, _polling_page));
fatal("Could not enable polling page at " PTR_FORMAT, _polling_page);
}
};

3
hotspot/src/os/aix/vm/vmError_aix.cpp
View file

@ -117,8 +117,7 @@ static void crash_handler(int sig, siginfo_t* info, void* ucVoid) {
return;
}
VMError err(NULL, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(NULL, sig, pc, info, ucVoid);
}
void VMError::reset_signal_handlers() {

11
hotspot/src/os/bsd/vm/os_bsd.cpp
View file

@ -1977,7 +1977,7 @@ static const char* sem_init_strerror(kern_return_t value) {
OSXSemaphore::OSXSemaphore(uint value) {
kern_return_t ret = SEM_INIT(_semaphore, value);
guarantee(ret == KERN_SUCCESS, err_msg("Failed to create semaphore: %s", sem_init_strerror(ret)));
guarantee(ret == KERN_SUCCESS, "Failed to create semaphore: %s", sem_init_strerror(ret));
}
OSXSemaphore::~OSXSemaphore() {
@ -2213,7 +2213,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
if (!pd_commit_memory(addr, size, exec)) {
// add extra info in product mode for vm_exit_out_of_memory():
PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -3100,8 +3100,8 @@ void os::Bsd::set_signal_handler(int sig, bool set_installed) {
// libjsig also interposes the sigaction() call below and saves the
// old sigaction on it own.
} else {
fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig));
fatal("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig);
}
}
@ -3459,8 +3459,7 @@ void os::init(void) {
Bsd::set_page_size(getpagesize());
if (Bsd::page_size() == -1) {
fatal(err_msg("os_bsd.cpp: os::init: sysconf failed (%s)",
strerror(errno)));
fatal("os_bsd.cpp: os::init: sysconf failed (%s)", strerror(errno));
}
init_page_sizes((size_t) Bsd::page_size());

3
hotspot/src/os/bsd/vm/vmError_bsd.cpp
View file

@ -121,8 +121,7 @@ static void crash_handler(int sig, siginfo_t* info, void* ucVoid) {
return;
}
VMError err(NULL, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(NULL, sig, pc, info, ucVoid);
}
void VMError::reset_signal_handlers() {

16
hotspot/src/os/linux/vm/os_linux.cpp
View file

@ -2680,7 +2680,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
if (err != 0) {
// the caller wants all commit errors to exit with the specified mesg:
warn_fail_commit_memory(addr, size, exec, err);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -2716,7 +2716,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t size,
if (err != 0) {
// the caller wants all commit errors to exit with the specified mesg:
warn_fail_commit_memory(addr, size, alignment_hint, exec, err);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -4278,8 +4278,8 @@ void os::Linux::set_signal_handler(int sig, bool set_installed) {
// libjsig also interposes the sigaction() call below and saves the
// old sigaction on it own.
} else {
fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig));
fatal("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig);
}
}
@ -4611,8 +4611,8 @@ void os::init(void) {
Linux::set_page_size(sysconf(_SC_PAGESIZE));
if (Linux::page_size() == -1) {
fatal(err_msg("os_linux.cpp: os::init: sysconf failed (%s)",
strerror(errno)));
fatal("os_linux.cpp: os::init: sysconf failed (%s)",
strerror(errno));
}
init_page_sizes((size_t) Linux::page_size());
@ -4628,7 +4628,7 @@ void os::init(void) {
int status;
pthread_condattr_t* _condattr = os::Linux::condAttr();
if ((status = pthread_condattr_init(_condattr)) != 0) {
fatal(err_msg("pthread_condattr_init: %s", strerror(status)));
fatal("pthread_condattr_init: %s", strerror(status));
}
// Only set the clock if CLOCK_MONOTONIC is available
if (os::supports_monotonic_clock()) {
@ -4637,7 +4637,7 @@ void os::init(void) {
warning("Unable to use monotonic clock with relative timed-waits" \
" - changes to the time-of-day clock may have adverse affects");
} else {
fatal(err_msg("pthread_condattr_setclock: %s", strerror(status)));
fatal("pthread_condattr_setclock: %s", strerror(status));
}
}
}

3
hotspot/src/os/linux/vm/vmError_linux.cpp
View file

@ -121,8 +121,7 @@ static void crash_handler(int sig, siginfo_t* info, void* ucVoid) {
return;
}
VMError err(NULL, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(NULL, sig, pc, info, ucVoid);
}
void VMError::reset_signal_handlers() {

2
hotspot/src/os/posix/vm/os_posix.cpp
View file

@ -1030,7 +1030,7 @@ void os::WatcherThreadCrashProtection::check_crash_protection(int sig,
#define check_with_errno(check_type, cond, msg) \
do { \
int err = errno; \
check_type(cond, err_msg("%s; error='%s' (errno=%d)", msg, strerror(err), err)); \
check_type(cond, "%s; error='%s' (errno=%d)", msg, strerror(err), err); \
} while (false)
#define assert_with_errno(cond, msg) check_with_errno(assert, cond, msg)

32
hotspot/src/os/solaris/vm/os_solaris.cpp
View file

@ -1118,8 +1118,7 @@ sigset_t* os::Solaris::allowdebug_blocked_signals() {
void _handle_uncaught_cxx_exception() {
VMError err("An uncaught C++ exception");
err.report_and_die();
VMError::report_and_die("An uncaught C++ exception");
}
@ -1330,7 +1329,7 @@ jlong getTimeMillis() {
jlong os::javaTimeMillis() {
timeval t;
if (gettimeofday(&t, NULL) == -1) {
fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));
fatal("os::javaTimeMillis: gettimeofday (%s)", strerror(errno));
}
return jlong(t.tv_sec) * 1000 + jlong(t.tv_usec) / 1000;
}
@ -1338,7 +1337,7 @@ jlong os::javaTimeMillis() {
void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
timeval t;
if (gettimeofday(&t, NULL) == -1) {
fatal(err_msg("os::javaTimeSystemUTC: gettimeofday (%s)", strerror(errno)));
fatal("os::javaTimeSystemUTC: gettimeofday (%s)", strerror(errno));
}
seconds = jlong(t.tv_sec);
nanos = jlong(t.tv_usec) * 1000;
@ -2392,14 +2391,14 @@ void os::pd_commit_memory_or_exit(char* addr, size_t bytes, bool exec,
if (err != 0) {
// the caller wants all commit errors to exit with the specified mesg:
warn_fail_commit_memory(addr, bytes, exec, err);
vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, "%s", mesg);
}
}
size_t os::Solaris::page_size_for_alignment(size_t alignment) {
assert(is_size_aligned(alignment, (size_t) vm_page_size()),
err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT,
alignment, (size_t) vm_page_size()));
SIZE_FORMAT " is not aligned to " SIZE_FORMAT,
alignment, (size_t) vm_page_size());
for (int i = 0; _page_sizes[i] != 0; i++) {
if (is_size_aligned(alignment, _page_sizes[i])) {
@ -2415,7 +2414,7 @@ int os::Solaris::commit_memory_impl(char* addr, size_t bytes,
int err = Solaris::commit_memory_impl(addr, bytes, exec);
if (err == 0 && UseLargePages && alignment_hint > 0) {
assert(is_size_aligned(bytes, alignment_hint),
err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, alignment_hint));
SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, alignment_hint);
// The syscall memcntl requires an exact page size (see man memcntl for details).
size_t page_size = page_size_for_alignment(alignment_hint);
@ -2439,7 +2438,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t bytes,
if (err != 0) {
// the caller wants all commit errors to exit with the specified mesg:
warn_fail_commit_memory(addr, bytes, alignment_hint, exec, err);
vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(bytes, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -2969,11 +2968,11 @@ bool os::Solaris::is_valid_page_size(size_t bytes) {
}
bool os::Solaris::setup_large_pages(caddr_t start, size_t bytes, size_t align) {
assert(is_valid_page_size(align), err_msg(SIZE_FORMAT " is not a valid page size", align));
assert(is_valid_page_size(align), SIZE_FORMAT " is not a valid page size", align);
assert(is_ptr_aligned((void*) start, align),
err_msg(PTR_FORMAT " is not aligned to " SIZE_FORMAT, p2i((void*) start), align));
PTR_FORMAT " is not aligned to " SIZE_FORMAT, p2i((void*) start), align);
assert(is_size_aligned(bytes, align),
err_msg(SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, align));
SIZE_FORMAT " is not aligned to " SIZE_FORMAT, bytes, align);
// Signal to OS that we want large pages for addresses
// from addr, addr + bytes
@ -3956,8 +3955,8 @@ void os::Solaris::set_signal_handler(int sig, bool set_installed,
// libjsig also interposes the sigaction() call below and saves the
// old sigaction on it own.
} else {
fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig));
fatal("Encountered unexpected pre-existing sigaction handler "
"%#lx for signal %d.", (long)oldhand, sig);
}
}
@ -4403,8 +4402,7 @@ void os::init(void) {
page_size = sysconf(_SC_PAGESIZE);
if (page_size == -1) {
fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
strerror(errno)));
fatal("os_solaris.cpp: os::init: sysconf failed (%s)", strerror(errno));
}
init_page_sizes((size_t) page_size);
@ -4416,7 +4414,7 @@ void os::init(void) {
int fd = ::open("/dev/zero", O_RDWR);
if (fd < 0) {
fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno)));
fatal("os::init: cannot open /dev/zero (%s)", strerror(errno));
} else {
Solaris::set_dev_zero_fd(fd);

7
hotspot/src/os/solaris/vm/threadCritical_solaris.cpp
View file

@ -48,8 +48,8 @@ ThreadCritical::ThreadCritical() {
thread_t owner = thr_self();
if (global_mut_owner != owner) {
if (os::Solaris::mutex_lock(&global_mut))
fatal(err_msg("ThreadCritical::ThreadCritical: mutex_lock failed (%s)",
strerror(errno)));
fatal("ThreadCritical::ThreadCritical: mutex_lock failed (%s)",
strerror(errno));
assert(global_mut_count == 0, "must have clean count");
assert(global_mut_owner == -1, "must have clean owner");
}
@ -68,8 +68,7 @@ ThreadCritical::~ThreadCritical() {
if (global_mut_count == 0) {
global_mut_owner = -1;
if (os::Solaris::mutex_unlock(&global_mut))
fatal(err_msg("ThreadCritical::~ThreadCritical: mutex_unlock failed "
"(%s)", strerror(errno)));
fatal("ThreadCritical::~ThreadCritical: mutex_unlock failed (%s)", strerror(errno));
}
} else {
assert (Threads::number_of_threads() == 0, "valid only during initialization");

3
hotspot/src/os/solaris/vm/vmError_solaris.cpp
View file

@ -117,8 +117,7 @@ static void crash_handler(int sig, siginfo_t* info, void* ucVoid) {
return;
}
VMError err(NULL, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(NULL, sig, pc, info, ucVoid);
}
void VMError::reset_signal_handlers() {

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

@ -823,7 +823,7 @@ jlong offset() {
java_origin.wMilliseconds = 0;
FILETIME jot;
if (!SystemTimeToFileTime(&java_origin, &jot)) {
fatal(err_msg("Error = %d\nWindows error", GetLastError()));
fatal("Error = %d\nWindows error", GetLastError());
}
_calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime);
_has_calculated_offset = 1;
@ -1936,7 +1936,7 @@ int os::get_last_error() {
WindowsSemaphore::WindowsSemaphore(uint value) {
_semaphore = ::CreateSemaphore(NULL, value, LONG_MAX, NULL);
guarantee(_semaphore != NULL, err_msg("CreateSemaphore failed with error code: %lu", GetLastError()));
guarantee(_semaphore != NULL, "CreateSemaphore failed with error code: %lu", GetLastError());
}
WindowsSemaphore::~WindowsSemaphore() {
@ -1947,14 +1947,14 @@ void WindowsSemaphore::signal(uint count) {
if (count > 0) {
BOOL ret = ::ReleaseSemaphore(_semaphore, count, NULL);
assert(ret != 0, err_msg("ReleaseSemaphore failed with error code: %lu", GetLastError()));
assert(ret != 0, "ReleaseSemaphore failed with error code: %lu", GetLastError());
}
}
void WindowsSemaphore::wait() {
DWORD ret = ::WaitForSingleObject(_semaphore, INFINITE);
assert(ret != WAIT_FAILED, err_msg("WaitForSingleObject failed with error code: %lu", GetLastError()));
assert(ret == WAIT_OBJECT_0, err_msg("WaitForSingleObject failed with return value: %lu", ret));
assert(ret != WAIT_FAILED, "WaitForSingleObject failed with error code: %lu", GetLastError());
assert(ret == WAIT_OBJECT_0, "WaitForSingleObject failed with return value: %lu", ret);
}
// sun.misc.Signal
@ -2344,8 +2344,7 @@ LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
static inline void report_error(Thread* t, DWORD exception_code,
address addr, void* siginfo, void* context) {
VMError err(t, exception_code, addr, siginfo, context);
err.report_and_die();
VMError::report_and_die(t, exception_code, addr, siginfo, context);
// If UseOsErrorReporting, this will return here and save the error file
// somewhere where we can find it in the minidump.
@ -3325,7 +3324,7 @@ void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
assert(mesg != NULL, "mesg must be specified");
if (!pd_commit_memory(addr, size, exec)) {
warn_fail_commit_memory(addr, size, exec);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
}
}
@ -5259,7 +5258,7 @@ bool os::check_heap(bool force) {
}
DWORD err = GetLastError();
if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
fatal(err_msg("heap walk aborted with error %d", err));
fatal("heap walk aborted with error %d", err);
}
HeapUnlock(heap);
}
@ -5978,8 +5977,8 @@ void TestReserveMemorySpecial_test() {
os::release_memory_special(actual_location, expected_allocation_size);
// only now check, after releasing any memory to avoid any leaks.
assert(actual_location == expected_location,
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));
"Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
expected_location, expected_allocation_size, actual_location);
}
}

5
hotspot/src/os/windows/vm/vmError_windows.cpp
View file

@ -70,9 +70,8 @@ address VMError::get_resetted_sighandler(int sig) {
LONG WINAPI crash_handler(struct _EXCEPTION_POINTERS* exceptionInfo) {
DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
VMError err(NULL, exception_code, NULL,
exceptionInfo->ExceptionRecord, exceptionInfo->ContextRecord);
err.report_and_die();
VMError::report_and_die(NULL, exception_code, NULL, exceptionInfo->ExceptionRecord,
exceptionInfo->ContextRecord);
return EXCEPTION_CONTINUE_SEARCH;
}

3
hotspot/src/os_cpu/aix_ppc/vm/os_aix_ppc.cpp
View file

@ -468,8 +468,7 @@ report_and_die:
sigaddset(&newset, sig);
sigthreadmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return 0;

9
hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp
View file

@ -731,8 +731,7 @@ JVM_handle_bsd_signal(int sig,
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return false;
@ -865,7 +864,7 @@ static void current_stack_region(address * bottom, size_t * size) {
int rslt = pthread_stackseg_np(pthread_self(), &ss);
if (rslt != 0)
fatal(err_msg("pthread_stackseg_np failed with err = %d", rslt));
fatal("pthread_stackseg_np failed with err = %d", rslt);
*bottom = (address)((char *)ss.ss_sp - ss.ss_size);
*size = ss.ss_size;
@ -876,12 +875,12 @@ static void current_stack_region(address * bottom, size_t * size) {
// JVM needs to know exact stack location, abort if it fails
if (rslt != 0)
fatal(err_msg("pthread_attr_init failed with err = %d", rslt));
fatal("pthread_attr_init failed with err = %d", rslt);
rslt = pthread_attr_get_np(pthread_self(), &attr);
if (rslt != 0)
fatal(err_msg("pthread_attr_get_np failed with err = %d", rslt));
fatal("pthread_attr_get_np failed with err = %d", rslt);
if (pthread_attr_getstackaddr(&attr, (void **)bottom) != 0 ||
pthread_attr_getstacksize(&attr, size) != 0) {

8
hotspot/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp
View file

@ -320,8 +320,7 @@ static void current_stack_region(address *bottom, size_t *size) {
int rslt = pthread_stackseg_np(pthread_self(), &ss);
if (rslt != 0)
fatal(err_msg("pthread_stackseg_np failed with err = " INT32_FORMAT,
rslt));
fatal("pthread_stackseg_np failed with err = " INT32_FORMAT, rslt);
stack_top = (address) ss.ss_sp;
stack_bytes = ss.ss_size;
@ -333,13 +332,12 @@ static void current_stack_region(address *bottom, size_t *size) {
// JVM needs to know exact stack location, abort if it fails
if (rslt != 0)
fatal(err_msg("pthread_attr_init failed with err = " INT32_FORMAT, rslt));
fatal("pthread_attr_init failed with err = " INT32_FORMAT, rslt);
rslt = pthread_attr_get_np(pthread_self(), &attr);
if (rslt != 0)
fatal(err_msg("pthread_attr_get_np failed with err = " INT32_FORMAT,
rslt));
fatal("pthread_attr_get_np failed with err = " INT32_FORMAT, rslt);
if (pthread_attr_getstackaddr(&attr, (void **) &stack_bottom) != 0 ||
pthread_attr_getstacksize(&attr, &stack_bytes) != 0) {

5
hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
View file

@ -464,8 +464,7 @@ JVM_handle_linux_signal(int sig,
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return true; // Mute compiler
@ -558,7 +557,7 @@ static void current_stack_region(address * bottom, size_t * size) {
if (rslt == ENOMEM) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
} else {
fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
fatal("pthread_getattr_np failed with errno = %d", rslt);
}
}

5
hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
View file

@ -439,8 +439,7 @@ report_and_die:
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return false;
@ -531,7 +530,7 @@ static void current_stack_region(address * bottom, size_t * size) {
if (rslt == ENOMEM) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
} else {
fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
fatal("pthread_getattr_np failed with errno = %d", rslt);
}
}

5
hotspot/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp
View file

@ -172,7 +172,7 @@ static void current_stack_region(address* bottom, size_t* size) {
if (rslt == ENOMEM) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
} else {
fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
fatal("pthread_getattr_np failed with errno = %d", rslt);
}
}
@ -692,8 +692,7 @@ JVM_handle_linux_signal(int sig,
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
}

5
hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
View file

@ -542,8 +542,7 @@ JVM_handle_linux_signal(int sig,
sigaddset(&newset, sig);
sigprocmask(SIG_UNBLOCK, &newset, NULL);
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return true; // Mute compiler
@ -689,7 +688,7 @@ static void current_stack_region(address * bottom, size_t * size) {
if (rslt == ENOMEM) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
} else {
fatal(err_msg("pthread_getattr_np failed with errno = %d", rslt));
fatal("pthread_getattr_np failed with errno = %d", rslt);
}
}

6
hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp
View file

@ -328,7 +328,7 @@ static void current_stack_region(address *bottom, size_t *size) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "pthread_getattr_np");
}
else {
fatal(err_msg("pthread_getattr_np failed with errno = %d", res));
fatal("pthread_getattr_np failed with errno = %d", res);
}
}
@ -336,7 +336,7 @@ static void current_stack_region(address *bottom, size_t *size) {
size_t stack_bytes;
res = pthread_attr_getstack(&attr, (void **) &stack_bottom, &stack_bytes);
if (res != 0) {
fatal(err_msg("pthread_attr_getstack failed with errno = %d", res));
fatal("pthread_attr_getstack failed with errno = %d", res);
}
address stack_top = stack_bottom + stack_bytes;
@ -348,7 +348,7 @@ static void current_stack_region(address *bottom, size_t *size) {
size_t guard_bytes;
res = pthread_attr_getguardsize(&attr, &guard_bytes);
if (res != 0) {
fatal(err_msg("pthread_attr_getguardsize failed with errno = %d", res));
fatal("pthread_attr_getguardsize failed with errno = %d", res);
}
int guard_pages = align_size_up(guard_bytes, page_bytes) / page_bytes;
assert(guard_bytes == guard_pages * page_bytes, "unaligned guard");

3
hotspot/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp
View file

@ -549,8 +549,7 @@ JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid,
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "Out of swap space to map in thread stack.");
}
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
}

3
hotspot/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp
View file

@ -707,8 +707,7 @@ JVM_handle_solaris_signal(int sig, siginfo_t* info, void* ucVoid,
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "Out of swap space to map in thread stack.");
}
VMError err(t, sig, pc, info, ucVoid);
err.report_and_die();
VMError::report_and_die(t, sig, pc, info, ucVoid);
ShouldNotReachHere();
return false;

1
hotspot/src/share/vm/Xusage.txt
View file

@ -7,6 +7,7 @@
-Xbootclasspath/p:<directories and zip/jar files separated by ;>
prepend in front of bootstrap class path
-Xnoclassgc disable class garbage collection
-Xlog:<opts> control JVM logging, use -Xlog:help for details
-Xloggc:<file> log GC status to a file with time stamps
-Xbatch disable background compilation
-Xms<size> set initial Java heap size

3
hotspot/src/share/vm/asm/assembler.cpp
View file

@ -43,8 +43,7 @@ AbstractAssembler::AbstractAssembler(CodeBuffer* code) {
CodeSection* cs = code->insts();
cs->clear_mark(); // new assembler kills old mark
if (cs->start() == NULL) {
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, err_msg("CodeCache: no room for %s",
code->name()));
vm_exit_out_of_memory(0, OOM_MMAP_ERROR, "CodeCache: no room for %s", code->name());
}
_code_section = cs;
_oop_recorder= code->oop_recorder();

2
hotspot/src/share/vm/asm/codeBuffer.hpp
View file

@ -173,7 +173,7 @@ class CodeSection VALUE_OBJ_CLASS_SPEC {
bool allocates(address pc) const { return pc >= _start && pc < _limit; }
bool allocates2(address pc) const { return pc >= _start && pc <= _limit; }
void set_end(address pc) { assert(allocates2(pc), err_msg("not in CodeBuffer memory: " INTPTR_FORMAT " <= " INTPTR_FORMAT " <= " INTPTR_FORMAT, p2i(_start), p2i(pc), p2i(_limit))); _end = pc; }
void set_end(address pc) { assert(allocates2(pc), "not in CodeBuffer memory: " INTPTR_FORMAT " <= " INTPTR_FORMAT " <= " INTPTR_FORMAT, p2i(_start), p2i(pc), p2i(_limit)); _end = pc; }
void set_mark(address pc) { assert(contains2(pc), "not in codeBuffer");
_mark = pc; }
void set_mark_off(int offset) { assert(contains2(offset+_start),"not in codeBuffer");

43
hotspot/src/share/vm/asm/register.hpp
View file

@ -121,8 +121,7 @@ inline void assert_different_registers(
) {
assert(
a != b,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT "",
p2i(a), p2i(b))
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT "", p2i(a), p2i(b)
);
}
@ -135,9 +134,9 @@ inline void assert_different_registers(
assert(
a != b && a != c
&& b != c,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c))
p2i(a), p2i(b), p2i(c)
);
}
@ -152,9 +151,9 @@ inline void assert_different_registers(
a != b && a != c && a != d
&& b != c && b != d
&& c != d,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d))
p2i(a), p2i(b), p2i(c), p2i(d)
);
}
@ -171,9 +170,9 @@ inline void assert_different_registers(
&& b != c && b != d && b != e
&& c != d && c != e
&& d != e,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e)
);
}
@ -192,10 +191,10 @@ inline void assert_different_registers(
&& c != d && c != e && c != f
&& d != e && d != f
&& e != f,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f)
);
}
@ -216,10 +215,10 @@ inline void assert_different_registers(
&& d != e && d != f && d != g
&& e != f && e != g
&& f != g,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g)
);
}
@ -242,10 +241,10 @@ inline void assert_different_registers(
&& e != f && e != g && e != h
&& f != g && f != h
&& g != h,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h)
);
}
@ -270,11 +269,11 @@ inline void assert_different_registers(
&& f != g && f != h && f != i
&& g != h && g != i
&& h != i,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
", i=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i)
);
}
@ -300,11 +299,11 @@ inline void assert_different_registers(
&& g != h && g != i && g != j
&& h != i && h != j
&& i != j,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j)
);
}
@ -332,11 +331,11 @@ inline void assert_different_registers(
&& h != i && h != j && h !=k
&& i != j && i !=k
&& j !=k,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k)
);
}
@ -366,12 +365,12 @@ inline void assert_different_registers(
&& i != j && i !=k && i !=l
&& j !=k && j !=l
&& k !=l,
err_msg_res("registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
"registers must be different: a=" INTPTR_FORMAT ", b=" INTPTR_FORMAT
", c=" INTPTR_FORMAT ", d=" INTPTR_FORMAT ", e=" INTPTR_FORMAT
", f=" INTPTR_FORMAT ", g=" INTPTR_FORMAT ", h=" INTPTR_FORMAT
", i=" INTPTR_FORMAT ", j=" INTPTR_FORMAT ", k=" INTPTR_FORMAT
", l=" INTPTR_FORMAT "",
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k), p2i(l))
p2i(a), p2i(b), p2i(c), p2i(d), p2i(e), p2i(f), p2i(g), p2i(h), p2i(i), p2i(j), p2i(k), p2i(l)
);
}

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

@ -4018,7 +4018,7 @@ bool GraphBuilder::try_method_handle_inline(ciMethod* callee) {
break;
default:
fatal(err_msg("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid)));
fatal("unexpected intrinsic %d: %s", iid, vmIntrinsics::name_at(iid));
break;
}
set_state(state_before);

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

@ -462,7 +462,7 @@ void LIR_Assembler::emit_call(LIR_OpJavaCall* op) {
vtable_call(op);
break;
default:
fatal(err_msg_res("unexpected op code: %s", op->name()));
fatal("unexpected op code: %s", op->name());
break;
}

9
hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
View file

@ -920,7 +920,7 @@ LIR_Opr LIRGenerator::round_item(LIR_Opr opr) {
LIR_Opr LIRGenerator::force_to_spill(LIR_Opr value, BasicType t) {
assert(type2size[t] == type2size[value->type()],
err_msg_res("size mismatch: t=%s, value->type()=%s", type2name(t), type2name(value->type())));
"size mismatch: t=%s, value->type()=%s", type2name(t), type2name(value->type()));
if (!value->is_register()) {
// force into a register
LIR_Opr r = new_register(value->type());
@ -1630,6 +1630,9 @@ void LIRGenerator::CardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc*
__ move(dirty, card_addr);
__ branch_destination(L_already_dirty->label());
} else {
if (UseConcMarkSweepGC && CMSPrecleaningEnabled) {
__ membar_storestore();
}
__ move(dirty, card_addr);
}
#endif
@ -2829,7 +2832,7 @@ void LIRGenerator::do_OsrEntry(OsrEntry* x) {
void LIRGenerator::invoke_load_arguments(Invoke* x, LIRItemList* args, const LIR_OprList* arg_list) {
assert(args->length() == arg_list->length(),
err_msg_res("args=%d, arg_list=%d", args->length(), arg_list->length()));
"args=%d, arg_list=%d", args->length(), arg_list->length());
for (int i = x->has_receiver() ? 1 : 0; i < args->length(); i++) {
LIRItem* param = args->at(i);
LIR_Opr loc = arg_list->at(i);
@ -2973,7 +2976,7 @@ void LIRGenerator::do_Invoke(Invoke* x) {
break;
}
default:
fatal(err_msg("unexpected bytecode: %s", Bytecodes::name(x->code())));
fatal("unexpected bytecode: %s", Bytecodes::name(x->code()));
break;
}

8
hotspot/src/share/vm/ci/ciKlass.cpp
View file

@ -66,8 +66,8 @@ ciKlass::ciKlass(ciSymbol* name, BasicType bt) : ciType(bt) {
// ------------------------------------------------------------------
// ciKlass::is_subtype_of
bool ciKlass::is_subtype_of(ciKlass* that) {
assert(this->is_loaded(), err_msg("must be loaded: %s", this->name()->as_quoted_ascii()));
assert(that->is_loaded(), err_msg("must be loaded: %s", that->name()->as_quoted_ascii()));
assert(this->is_loaded(), "must be loaded: %s", this->name()->as_quoted_ascii());
assert(that->is_loaded(), "must be loaded: %s", that->name()->as_quoted_ascii());
// Check to see if the klasses are identical.
if (this == that) {
@ -85,8 +85,8 @@ bool ciKlass::is_subtype_of(ciKlass* that) {
// ------------------------------------------------------------------
// ciKlass::is_subclass_of
bool ciKlass::is_subclass_of(ciKlass* that) {
assert(this->is_loaded(), err_msg("must be loaded: %s", this->name()->as_quoted_ascii()));
assert(that->is_loaded(), err_msg("must be loaded: %s", that->name()->as_quoted_ascii()));
assert(this->is_loaded(), "must be loaded: %s", this->name()->as_quoted_ascii());
assert(that->is_loaded(), "must be loaded: %s", that->name()->as_quoted_ascii());
VM_ENTRY_MARK;
Klass* this_klass = get_Klass();

4
hotspot/src/share/vm/ci/ciMethod.cpp
View file

@ -576,13 +576,13 @@ void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
void ciMethod::assert_virtual_call_type_ok(int bci) {
assert(java_code_at_bci(bci) == Bytecodes::_invokevirtual ||
java_code_at_bci(bci) == Bytecodes::_invokeinterface, err_msg("unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci))));
java_code_at_bci(bci) == Bytecodes::_invokeinterface, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
}
void ciMethod::assert_call_type_ok(int bci) {
assert(java_code_at_bci(bci) == Bytecodes::_invokestatic ||
java_code_at_bci(bci) == Bytecodes::_invokespecial ||
java_code_at_bci(bci) == Bytecodes::_invokedynamic, err_msg("unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci))));
java_code_at_bci(bci) == Bytecodes::_invokedynamic, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
}
/**

8
hotspot/src/share/vm/ci/ciMethodData.cpp
View file

@ -122,7 +122,7 @@ void ciMethodData::load_extra_data() {
// An empty slot or ArgInfoData entry marks the end of the trap data
return;
default:
fatal(err_msg("bad tag = %d", dp_dst->tag()));
fatal("bad tag = %d", dp_dst->tag());
}
}
}
@ -289,7 +289,7 @@ ciProfileData* ciMethodData::bci_to_extra_data(int bci, ciMethod* m, bool& two_f
break;
}
default:
fatal(err_msg("bad tag = %d", dp->tag()));
fatal("bad tag = %d", dp->tag());
}
}
return NULL;
@ -578,7 +578,7 @@ void ciMethodData::dump_replay_data_extra_data_helper(outputStream* out, int rou
break;
}
default:
fatal(err_msg("bad tag = %d", dp->tag()));
fatal("bad tag = %d", dp->tag());
}
}
}
@ -690,7 +690,7 @@ void ciMethodData::print_data_on(outputStream* st) {
data = new ciSpeculativeTrapData(dp);
break;
default:
fatal(err_msg("unexpected tag %d", dp->tag()));
fatal("unexpected tag %d", dp->tag());
}
st->print("%d", dp_to_di(data->dp()));
st->fill_to(6);

2
hotspot/src/share/vm/ci/ciReplay.cpp
View file

@ -730,7 +730,7 @@ class CompileReplay : public StackObj {
if (parsed_two_word == i) continue;
default:
fatal(err_msg_res("Unexpected tag: %d", cp->tag_at(i).value()));
fatal("Unexpected tag: %d", cp->tag_at(i).value());
break;
}

2
hotspot/src/share/vm/ci/ciTypeFlow.cpp
View file

@ -1964,7 +1964,7 @@ ciTypeFlow::ciTypeFlow(ciEnv* env, ciMethod* method, int osr_bci) {
_has_irreducible_entry = false;
_osr_bci = osr_bci;
_failure_reason = NULL;
assert(0 <= start_bci() && start_bci() < code_size() , err_msg("correct osr_bci argument: 0 <= %d < %d", start_bci(), code_size()));
assert(0 <= start_bci() && start_bci() < code_size() , "correct osr_bci argument: 0 <= %d < %d", start_bci(), code_size());
_work_list = NULL;
_ciblock_count = _methodBlocks->num_blocks();

11
hotspot/src/share/vm/classfile/altHashing.cpp
View file

@ -262,10 +262,9 @@ void AltHashing::testMurmur3_32_ByteArray() {
juint final_hash = murmur3_32(hashes, 4*256);
assert (MURMUR3_32_X86_CHECK_VALUE == final_hash,
err_msg(
"Calculated hash result not as expected. Expected %08X got %08X\n",
MURMUR3_32_X86_CHECK_VALUE,
final_hash));
final_hash);
}
void AltHashing::testEquivalentHashes() {
@ -276,24 +275,24 @@ void AltHashing::testEquivalentHashes() {
jbytes = murmur3_32(TWO_BYTE, 2);
jchars = murmur3_32(ONE_CHAR, 1);
assert (jbytes == jchars,
err_msg("Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars));
"Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars);
jbytes = murmur3_32(FOUR_BYTE, 4);
jchars = murmur3_32(TWO_CHAR, 2);
ints = murmur3_32(ONE_INT, 1);
assert ((jbytes == jchars) && (jbytes == ints),
err_msg("Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints));
"Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints);
jbytes = murmur3_32(SIX_BYTE, 6);
jchars = murmur3_32(THREE_CHAR, 3);
assert (jbytes == jchars,
err_msg("Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars));
"Hashes did not match. b:%08x != c:%08x\n", jbytes, jchars);
jbytes = murmur3_32(EIGHT_BYTE, 8);
jchars = murmur3_32(FOUR_CHAR, 4);
ints = murmur3_32(TWO_INT, 2);
assert ((jbytes == jchars) && (jbytes == ints),
err_msg("Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints));
"Hashes did not match. b:%08x != c:%08x != i:%08x\n", jbytes, jchars, ints);
}
// Returns true if the alternate hashcode is correct

7
hotspot/src/share/vm/classfile/classFileParser.cpp
View file

@ -319,12 +319,12 @@ PRAGMA_DIAG_PUSH
PRAGMA_FORMAT_NONLITERAL_IGNORED
void ClassFileParser::report_assert_property_failure(const char* msg, TRAPS) {
ResourceMark rm(THREAD);
fatal(err_msg(msg, _class_name->as_C_string()));
fatal(msg, _class_name->as_C_string());
}
void ClassFileParser::report_assert_property_failure(const char* msg, int index, TRAPS) {
ResourceMark rm(THREAD);
fatal(err_msg(msg, index, _class_name->as_C_string()));
fatal(msg, index, _class_name->as_C_string());
}
PRAGMA_DIAG_POP
@ -492,8 +492,7 @@ constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
break;
}
default:
fatal(err_msg("bad constant pool tag value %u",
cp->tag_at(index).value()));
fatal("bad constant pool tag value %u", cp->tag_at(index).value());
ShouldNotReachHere();
break;
} // end of switch

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

@ -913,7 +913,7 @@ Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() {
}
// Nothing more for the iterator to hand out.
assert(head == NULL, err_msg("head is " PTR_FORMAT ", expected not null:", p2i(head)));
assert(head == NULL, "head is " PTR_FORMAT ", expected not null:", p2i(head));
return NULL;
}

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

@ -119,7 +119,7 @@ MetadataOnStackBuffer* MetadataOnStackMark::allocate_buffer() {
allocated = new MetadataOnStackBuffer();
}
assert(!allocated->is_full(), err_msg("Should not be full: " PTR_FORMAT, p2i(allocated)));
assert(!allocated->is_full(), "Should not be full: " PTR_FORMAT, p2i(allocated));
return allocated;
}

16
hotspot/src/share/vm/classfile/stringTable.cpp
View file

@ -312,12 +312,12 @@ void StringTable::buckets_oops_do(OopClosure* f, int start_idx, int end_idx) {
const int limit = the_table()->table_size();
assert(0 <= start_idx && start_idx <= limit,
err_msg("start_idx (%d) is out of bounds", start_idx));
"start_idx (%d) is out of bounds", start_idx);
assert(0 <= end_idx && end_idx <= limit,
err_msg("end_idx (%d) is out of bounds", end_idx));
"end_idx (%d) is out of bounds", end_idx);
assert(start_idx <= end_idx,
err_msg("Index ordering: start_idx=%d, end_idx=%d",
start_idx, end_idx));
"Index ordering: start_idx=%d, end_idx=%d",
start_idx, end_idx);
for (int i = start_idx; i < end_idx; i += 1) {
HashtableEntry<oop, mtSymbol>* entry = the_table()->bucket(i);
@ -335,12 +335,12 @@ void StringTable::buckets_unlink_or_oops_do(BoolObjectClosure* is_alive, OopClos
const int limit = the_table()->table_size();
assert(0 <= start_idx && start_idx <= limit,
err_msg("start_idx (%d) is out of bounds", start_idx));
"start_idx (%d) is out of bounds", start_idx);
assert(0 <= end_idx && end_idx <= limit,
err_msg("end_idx (%d) is out of bounds", end_idx));
"end_idx (%d) is out of bounds", end_idx);
assert(start_idx <= end_idx,
err_msg("Index ordering: start_idx=%d, end_idx=%d",
start_idx, end_idx));
"Index ordering: start_idx=%d, end_idx=%d",
start_idx, end_idx);
for (int i = start_idx; i < end_idx; ++i) {
HashtableEntry<oop, mtSymbol>** p = the_table()->bucket_addr(i);

10
hotspot/src/share/vm/classfile/systemDictionary.cpp
View file

@ -229,9 +229,9 @@ Klass* SystemDictionary::resolve_or_fail(Symbol* class_name,
Klass* SystemDictionary::resolve_or_null(Symbol* class_name, Handle class_loader, Handle protection_domain, TRAPS) {
assert(!THREAD->is_Compiler_thread(),
err_msg("can not load classes with compiler thread: class=%s, classloader=%s",
"can not load classes with compiler thread: class=%s, classloader=%s",
class_name->as_C_string(),
class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string()));
class_loader.is_null() ? "null" : class_loader->klass()->name()->as_C_string());
if (FieldType::is_array(class_name)) {
return resolve_array_class_or_null(class_name, class_loader, protection_domain, THREAD);
} else if (FieldType::is_obj(class_name)) {
@ -2264,7 +2264,7 @@ methodHandle SystemDictionary::find_method_handle_intrinsic(vmIntrinsics::ID iid
assert(MethodHandles::is_signature_polymorphic(iid) &&
MethodHandles::is_signature_polymorphic_intrinsic(iid) &&
iid != vmIntrinsics::_invokeGeneric,
err_msg("must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid)));
"must be a known MH intrinsic iid=%d: %s", iid, vmIntrinsics::name_at(iid));
unsigned int hash = invoke_method_table()->compute_hash(signature, iid);
int index = invoke_method_table()->hash_to_index(hash);
@ -2390,7 +2390,7 @@ static bool is_always_visible_class(oop mirror) {
if (klass->oop_is_typeArray()) {
return true; // primitive array
}
assert(klass->oop_is_instance(), klass->external_name());
assert(klass->oop_is_instance(), "%s", klass->external_name());
return klass->is_public() &&
(InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::Object_klass()) || // java.lang
InstanceKlass::cast(klass)->is_same_class_package(SystemDictionary::MethodHandle_klass())); // java.lang.invoke
@ -2443,7 +2443,7 @@ Handle SystemDictionary::find_method_handle_type(Symbol* signature,
mirror = ss.as_java_mirror(class_loader, protection_domain,
SignatureStream::NCDFError, CHECK_(empty));
}
assert(!oopDesc::is_null(mirror), ss.as_symbol(THREAD)->as_C_string());
assert(!oopDesc::is_null(mirror), "%s", ss.as_symbol(THREAD)->as_C_string());
if (ss.at_return_type())
rt = Handle(THREAD, mirror);
else

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

@ -365,7 +365,7 @@ CodeBlob* CodeCache::allocate(int size, int code_blob_type, bool strict) {
// Possibly wakes up the sweeper thread.
NMethodSweeper::notify(code_blob_type);
assert_locked_or_safepoint(CodeCache_lock);
assert(size > 0, err_msg_res("Code cache allocation request must be > 0 but is %d", size));
assert(size > 0, "Code cache allocation request must be > 0 but is %d", size);
if (size <= 0) {
return NULL;
}
@ -817,7 +817,7 @@ double CodeCache::reverse_free_ratio(int code_blob_type) {
double max_capacity = (double)heap->max_capacity();
double result = max_capacity / unallocated_capacity;
assert (max_capacity >= unallocated_capacity, "Must be");
assert (result >= 1.0, err_msg_res("reverse_free_ratio must be at least 1. It is %f", result));
assert (result >= 1.0, "reverse_free_ratio must be at least 1. It is %f", result);
return result;
}

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

@ -400,7 +400,7 @@ int Dependencies::dep_args(Dependencies::DepType dept) {
}
void Dependencies::check_valid_dependency_type(DepType dept) {
guarantee(FIRST_TYPE <= dept && dept < TYPE_LIMIT, err_msg("invalid dependency type: %d", (int) dept));
guarantee(FIRST_TYPE <= dept && dept < TYPE_LIMIT, "invalid dependency type: %d", (int) dept);
}
// for the sake of the compiler log, print out current dependencies:

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

@ -225,6 +225,6 @@ void ImplicitExceptionTable::verify(nmethod *nm) const {
for (uint i = 0; i < len(); i++) {
if ((*adr(i) > (unsigned int)nm->insts_size()) ||
(*(adr(i)+1) > (unsigned int)nm->insts_size()))
fatal(err_msg("Invalid offset in ImplicitExceptionTable at " PTR_FORMAT, _data));
fatal("Invalid offset in ImplicitExceptionTable at " PTR_FORMAT, _data);
}
}

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

@ -1709,7 +1709,7 @@ static bool clean_if_nmethod_is_unloaded(CompiledICorStaticCall *ic, address add
// Clean inline caches pointing to both zombie and not_entrant methods
if (!nm->is_in_use() || (nm->method()->code() != nm)) {
ic->set_to_clean();
assert(ic->is_clean(), err_msg("nmethod " PTR_FORMAT "not clean %s", from, from->method()->name_and_sig_as_C_string()));
assert(ic->is_clean(), "nmethod " PTR_FORMAT "not clean %s", from, from->method()->name_and_sig_as_C_string());
}
}
@ -2540,7 +2540,7 @@ void nmethod::verify() {
ResourceMark rm;
if (!CodeCache::contains(this)) {
fatal(err_msg("nmethod at " INTPTR_FORMAT " not in zone", this));
fatal("nmethod at " INTPTR_FORMAT " not in zone", this);
}
if(is_native_method() )
@ -2548,8 +2548,7 @@ void nmethod::verify() {
nmethod* nm = CodeCache::find_nmethod(verified_entry_point());
if (nm != this) {
fatal(err_msg("findNMethod did not find this nmethod (" INTPTR_FORMAT ")",
this));
fatal("findNMethod did not find this nmethod (" INTPTR_FORMAT ")", this);
}
for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {

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

@ -67,7 +67,7 @@ StubQueue::StubQueue(StubInterface* stub_interface, int buffer_size,
intptr_t size = round_to(buffer_size, 2*BytesPerWord);
BufferBlob* blob = BufferBlob::create(name, size);
if( blob == NULL) {
vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, err_msg("CodeCache: no room for %s", name));
vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for %s", name);
}
_stub_interface = stub_interface;
_buffer_size = blob->content_size();

6
hotspot/src/share/vm/code/vtableStubs.cpp
View file

@ -222,9 +222,9 @@ extern "C" void bad_compiled_vtable_index(JavaThread* thread, oop receiver, int
InstanceKlass* ik = InstanceKlass::cast(klass);
klassVtable* vt = ik->vtable();
ik->print();
fatal(err_msg("bad compiled vtable dispatch: receiver " INTPTR_FORMAT ", "
fatal("bad compiled vtable dispatch: receiver " INTPTR_FORMAT ", "
"index %d (vtable length %d)",
(address)receiver, index, vt->length()));
(address)receiver, index, vt->length());
}
#endif // Product
#endif // PRODUCT

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

@ -1669,8 +1669,8 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
}
if (PrintCompilation) {
FormatBufferResource msg = retry_message != NULL ?
err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) :
err_msg_res("COMPILE SKIPPED: %s", ci_env.failure_reason());
FormatBufferResource("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) :
FormatBufferResource("COMPILE SKIPPED: %s", ci_env.failure_reason());
task->print(tty, msg);
}
} else {

4
hotspot/src/share/vm/gc/cms/adaptiveFreeList.cpp
View file

@ -133,7 +133,7 @@ void AdaptiveFreeList<Chunk>::verify_stats() const {
+ _allocation_stats.coal_births() + 1) // Total Production Stock + 1
>= (_allocation_stats.split_deaths() + _allocation_stats.coal_deaths()
+ (ssize_t)count()), // Total Current Stock + depletion
err_msg("FreeList " PTR_FORMAT " of size " SIZE_FORMAT
"FreeList " PTR_FORMAT " of size " SIZE_FORMAT
" violates Conservation Principle: "
"prev_sweep(" SIZE_FORMAT ")"
" + split_births(" SIZE_FORMAT ")"
@ -143,7 +143,7 @@ void AdaptiveFreeList<Chunk>::verify_stats() const {
" + count(" SSIZE_FORMAT ")",
p2i(this), size(), _allocation_stats.prev_sweep(), _allocation_stats.split_births(),
_allocation_stats.coal_births(), _allocation_stats.split_deaths(),
_allocation_stats.coal_deaths(), count()));
_allocation_stats.coal_deaths(), count());
}
#endif

4
hotspot/src/share/vm/gc/cms/allocationStats.hpp
View file

@ -105,9 +105,9 @@ class AllocationStats VALUE_OBJ_CLASS_SPEC {
ssize_t demand = prev_sweep() - (ssize_t)count + split_births() + coal_births()
- split_deaths() - coal_deaths();
assert(demand >= 0,
err_msg("Demand (" SSIZE_FORMAT ") should be non-negative for "
"Demand (" SSIZE_FORMAT ") should be non-negative for "
PTR_FORMAT " (size=" SIZE_FORMAT ")",
demand, p2i(this), count));
demand, p2i(this), count);
// Defensive: adjust for imprecision in event counting
if (demand < 0) {
demand = 0;

8
hotspot/src/share/vm/gc/cms/compactibleFreeListSpace.cpp
View file

@ -1959,9 +1959,9 @@ void CompactibleFreeListSpace::save_marks() {
MemRegion ur = used_region();
MemRegion urasm = used_region_at_save_marks();
assert(ur.contains(urasm),
err_msg(" Error at save_marks(): [" PTR_FORMAT "," PTR_FORMAT ")"
" Error at save_marks(): [" PTR_FORMAT "," PTR_FORMAT ")"
" should contain [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(ur.start()), p2i(ur.end()), p2i(urasm.start()), p2i(urasm.end())));
p2i(ur.start()), p2i(ur.end()), p2i(urasm.start()), p2i(urasm.end()));
#endif
// inform allocator that promotions should be tracked.
assert(_promoInfo.noPromotions(), "_promoInfo inconsistency");
@ -2875,9 +2875,9 @@ FreeChunk* CompactibleFreeListSpace::get_n_way_chunk_to_split(size_t word_sz, si
smallSplitBirth(rem);
}
assert(n * word_sz == fc->size(),
err_msg("Chunk size " SIZE_FORMAT " is not exactly splittable by "
"Chunk size " SIZE_FORMAT " is not exactly splittable by "
SIZE_FORMAT " sized chunks of size " SIZE_FORMAT,
fc->size(), n, word_sz));
fc->size(), n, word_sz);
return fc;
}

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

@ -1593,7 +1593,7 @@ void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
SerialOldTracer* gc_tracer = GenMarkSweep::gc_tracer();
gc_tracer->report_gc_start(gch->gc_cause(), gc_timer->gc_start());
GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL, gc_tracer->gc_id());
GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL);
// Temporarily widen the span of the weak reference processing to
// the entire heap.
@ -2825,7 +2825,6 @@ class CMSPhaseAccounting: public StackObj {
public:
CMSPhaseAccounting(CMSCollector *collector,
const char *phase,
const GCId gc_id,
bool print_cr = true);
~CMSPhaseAccounting();
@ -2834,7 +2833,6 @@ class CMSPhaseAccounting: public StackObj {
const char *_phase;
elapsedTimer _wallclock;
bool _print_cr;
const GCId _gc_id;
public:
// Not MT-safe; so do not pass around these StackObj's
@ -2850,15 +2848,14 @@ class CMSPhaseAccounting: public StackObj {
CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector,
const char *phase,
const GCId gc_id,
bool print_cr) :
_collector(collector), _phase(phase), _print_cr(print_cr), _gc_id(gc_id) {
_collector(collector), _phase(phase), _print_cr(print_cr) {
if (PrintCMSStatistics != 0) {
_collector->resetYields();
}
if (PrintGCDetails) {
gclog_or_tty->gclog_stamp(_gc_id);
gclog_or_tty->gclog_stamp();
gclog_or_tty->print_cr("[%s-concurrent-%s-start]",
_collector->cmsGen()->short_name(), _phase);
}
@ -2872,7 +2869,7 @@ CMSPhaseAccounting::~CMSPhaseAccounting() {
_collector->stopTimer();
_wallclock.stop();
if (PrintGCDetails) {
gclog_or_tty->gclog_stamp(_gc_id);
gclog_or_tty->gclog_stamp();
gclog_or_tty->print("[%s-concurrent-%s: %3.3f/%3.3f secs]",
_collector->cmsGen()->short_name(),
_phase, _collector->timerValue(), _wallclock.seconds());
@ -2951,7 +2948,7 @@ void CMSCollector::checkpointRootsInitialWork() {
setup_cms_unloading_and_verification_state();
NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork",
PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
PrintGCDetails && Verbose, true, _gc_timer_cm);)
// Reset all the PLAB chunk arrays if necessary.
if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) {
@ -3054,7 +3051,7 @@ bool CMSCollector::markFromRoots() {
CMSTokenSyncWithLocks ts(true, bitMapLock());
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
CMSPhaseAccounting pa(this, "mark", _gc_tracer_cm->gc_id(), !PrintGCDetails);
CMSPhaseAccounting pa(this, "mark", !PrintGCDetails);
bool res = markFromRootsWork();
if (res) {
_collectorState = Precleaning;
@ -3476,7 +3473,7 @@ class Par_ConcMarkingClosure: public MetadataAwareOopClosure {
// been published), so we do not need to check for
// uninitialized objects before pushing here.
void Par_ConcMarkingClosure::do_oop(oop obj) {
assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
assert(obj->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
@ -3751,7 +3748,7 @@ void CMSCollector::preclean() {
_start_sampling = false;
}
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
CMSPhaseAccounting pa(this, "preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails);
preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1);
}
CMSTokenSync x(true); // is cms thread
@ -3780,7 +3777,7 @@ void CMSCollector::abortable_preclean() {
// we will never do an actual abortable preclean cycle.
if (get_eden_used() > CMSScheduleRemarkEdenSizeThreshold) {
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
CMSPhaseAccounting pa(this, "abortable-preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
CMSPhaseAccounting pa(this, "abortable-preclean", !PrintGCDetails);
// We need more smarts in the abortable preclean
// loop below to deal with cases where allocation
// in young gen is very very slow, and our precleaning
@ -3925,7 +3922,7 @@ size_t CMSCollector::preclean_work(bool clean_refs, bool clean_survivor) {
GCTimer *gc_timer = NULL; // Currently not tracing concurrent phases
rp->preclean_discovered_references(
rp->is_alive_non_header(), &keep_alive, &complete_trace, &yield_cl,
gc_timer, _gc_tracer_cm->gc_id());
gc_timer);
}
if (clean_survivor) { // preclean the active survivor space(s)
@ -4261,7 +4258,7 @@ void CMSCollector::checkpointRootsFinal() {
// expect it to be false and set to true
FlagSetting fl(gch->_is_gc_active, false);
NOT_PRODUCT(GCTraceTime t("Scavenge-Before-Remark",
PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
PrintGCDetails && Verbose, true, _gc_timer_cm);)
gch->do_collection(true, // full (i.e. force, see below)
false, // !clear_all_soft_refs
0, // size
@ -4279,7 +4276,7 @@ void CMSCollector::checkpointRootsFinal() {
}
void CMSCollector::checkpointRootsFinalWork() {
NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm);)
assert(haveFreelistLocks(), "must have free list locks");
assert_lock_strong(bitMapLock());
@ -4329,11 +4326,10 @@ void CMSCollector::checkpointRootsFinalWork() {
// the most recent young generation GC, minus those cleaned up by the
// concurrent precleaning.
if (CMSParallelRemarkEnabled) {
GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm);
do_remark_parallel();
} else {
GCTraceTime t("Rescan (non-parallel) ", PrintGCDetails, false,
_gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("Rescan (non-parallel) ", PrintGCDetails, false, _gc_timer_cm);
do_remark_non_parallel();
}
}
@ -4341,7 +4337,7 @@ void CMSCollector::checkpointRootsFinalWork() {
verify_overflow_empty();
{
NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm);)
refProcessingWork();
}
verify_work_stacks_empty();
@ -5116,7 +5112,7 @@ void CMSCollector::do_remark_non_parallel() {
NULL, // space is set further below
&_markBitMap, &_markStack, &mrias_cl);
{
GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm);
// Iterate over the dirty cards, setting the corresponding bits in the
// mod union table.
{
@ -5153,7 +5149,7 @@ void CMSCollector::do_remark_non_parallel() {
Universe::verify();
}
{
GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm);
verify_work_stacks_empty();
@ -5175,7 +5171,7 @@ void CMSCollector::do_remark_non_parallel() {
}
{
GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm);
verify_work_stacks_empty();
@ -5194,7 +5190,7 @@ void CMSCollector::do_remark_non_parallel() {
}
{
GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm);
verify_work_stacks_empty();
@ -5403,7 +5399,7 @@ void CMSCollector::refProcessingWork() {
_span, &_markBitMap, &_markStack,
&cmsKeepAliveClosure, false /* !preclean */);
{
GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm);
ReferenceProcessorStats stats;
if (rp->processing_is_mt()) {
@ -5428,15 +5424,13 @@ void CMSCollector::refProcessingWork() {
&cmsKeepAliveClosure,
&cmsDrainMarkingStackClosure,
&task_executor,
_gc_timer_cm,
_gc_tracer_cm->gc_id());
_gc_timer_cm);
} else {
stats = rp->process_discovered_references(&_is_alive_closure,
&cmsKeepAliveClosure,
&cmsDrainMarkingStackClosure,
NULL,
_gc_timer_cm,
_gc_tracer_cm->gc_id());
_gc_timer_cm);
}
_gc_tracer_cm->report_gc_reference_stats(stats);
@ -5447,7 +5441,7 @@ void CMSCollector::refProcessingWork() {
if (should_unload_classes()) {
{
GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm);
// Unload classes and purge the SystemDictionary.
bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure);
@ -5460,13 +5454,13 @@ void CMSCollector::refProcessingWork() {
}
{
GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm);
// Clean up unreferenced symbols in symbol table.
SymbolTable::unlink();
}
{
GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm);
// Delete entries for dead interned strings.
StringTable::unlink(&_is_alive_closure);
}
@ -5534,7 +5528,7 @@ void CMSCollector::sweep() {
_intra_sweep_timer.start();
{
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
CMSPhaseAccounting pa(this, "sweep", _gc_tracer_cm->gc_id(), !PrintGCDetails);
CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails);
// First sweep the old gen
{
CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(),
@ -5719,7 +5713,7 @@ void CMSCollector::reset(bool concurrent) {
// Clear the mark bitmap (no grey objects to start with)
// for the next cycle.
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
CMSPhaseAccounting cmspa(this, "reset", _gc_tracer_cm->gc_id(), !PrintGCDetails);
CMSPhaseAccounting cmspa(this, "reset", !PrintGCDetails);
HeapWord* curAddr = _markBitMap.startWord();
while (curAddr < _markBitMap.endWord()) {
@ -5771,7 +5765,7 @@ void CMSCollector::reset(bool concurrent) {
void CMSCollector::do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause) {
TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL, _gc_tracer_cm->gc_id());
GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL);
TraceCollectorStats tcs(counters());
switch (op) {
@ -6458,7 +6452,7 @@ void SurvivorSpacePrecleanClosure::do_yield_work() {
// isMarked() query is "safe".
bool ScanMarkedObjectsAgainClosure::do_object_bm(oop p, MemRegion mr) {
// Ignore mark word because we are running concurrent with mutators
assert(p->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(p)));
assert(p->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(p));
HeapWord* addr = (HeapWord*)p;
assert(_span.contains(addr), "we are scanning the CMS generation");
bool is_obj_array = false;
@ -6893,7 +6887,7 @@ void PushAndMarkVerifyClosure::handle_stack_overflow(HeapWord* lost) {
}
void PushAndMarkVerifyClosure::do_oop(oop obj) {
assert(obj->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
assert(obj->is_oop_or_null(), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
if (_span.contains(addr) && !_verification_bm->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@ -6991,7 +6985,7 @@ void Par_PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) {
void PushOrMarkClosure::do_oop(oop obj) {
// Ignore mark word because we are running concurrent with mutators.
assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
assert(obj->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
if (_span.contains(addr) && !_bitMap->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@ -7029,7 +7023,7 @@ void PushOrMarkClosure::do_oop(narrowOop* p) { PushOrMarkClosure::do_oop_work(p)
void Par_PushOrMarkClosure::do_oop(oop obj) {
// Ignore mark word because we are running concurrent with mutators.
assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
assert(obj->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@ -7106,7 +7100,7 @@ void PushAndMarkClosure::do_oop(oop obj) {
// path and may be at the end of the global overflow list (so
// the mark word may be NULL).
assert(obj->is_oop_or_null(true /* ignore mark word */),
err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
"Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
@ -7186,7 +7180,7 @@ void Par_PushAndMarkClosure::do_oop(oop obj) {
// the debugger, is_oop_or_null(false) may subsequently start
// to hold.
assert(obj->is_oop_or_null(true),
err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
"Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
@ -7423,7 +7417,7 @@ size_t SweepClosure::do_blk_careful(HeapWord* addr) {
// coalesced chunk to the appropriate free list.
if (inFreeRange()) {
assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit,
err_msg("freeFinger() " PTR_FORMAT " is out-of-bounds", p2i(freeFinger())));
"freeFinger() " PTR_FORMAT " is out-of-bounds", p2i(freeFinger()));
flush_cur_free_chunk(freeFinger(),
pointer_delta(addr, freeFinger()));
if (CMSTraceSweeper) {
@ -7825,10 +7819,10 @@ void SweepClosure::lookahead_and_flush(FreeChunk* fc, size_t chunk_size) {
assert(inFreeRange(), "Should only be called if currently in a free range.");
HeapWord* const eob = ((HeapWord*)fc) + chunk_size;
assert(_sp->used_region().contains(eob - 1),
err_msg("eob = " PTR_FORMAT " eob-1 = " PTR_FORMAT " _limit = " PTR_FORMAT
"eob = " PTR_FORMAT " eob-1 = " PTR_FORMAT " _limit = " PTR_FORMAT
" out of bounds wrt _sp = [" PTR_FORMAT "," PTR_FORMAT ")"
" when examining fc = " PTR_FORMAT "(" SIZE_FORMAT ")",
p2i(eob), p2i(eob-1), p2i(_limit), p2i(_sp->bottom()), p2i(_sp->end()), p2i(fc), chunk_size));
p2i(eob), p2i(eob-1), p2i(_limit), p2i(_sp->bottom()), p2i(_sp->end()), p2i(fc), chunk_size);
if (eob >= _limit) {
assert(eob == _limit || fc->is_free(), "Only a free chunk should allow us to cross over the limit");
if (CMSTraceSweeper) {

8
hotspot/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp
View file

@ -296,8 +296,8 @@ class ChunkArray: public CHeapObj<mtGC> {
size_t end() {
assert(_index <= capacity(),
err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT "): out of bounds",
_index, _capacity));
"_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT "): out of bounds",
_index, _capacity);
return _index;
} // exclusive
@ -322,9 +322,9 @@ class ChunkArray: public CHeapObj<mtGC> {
} else {
++_overflows;
assert(_index == _capacity,
err_msg("_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT
"_index (" SIZE_FORMAT ") > _capacity (" SIZE_FORMAT
"): out of bounds at overflow#" SIZE_FORMAT,
_index, _capacity, _overflows));
_index, _capacity, _overflows);
}
}
};

2
hotspot/src/share/vm/gc/cms/concurrentMarkSweepThread.cpp
View file

@ -26,6 +26,7 @@
#include "classfile/systemDictionary.hpp"
#include "gc/cms/concurrentMarkSweepGeneration.inline.hpp"
#include "gc/cms/concurrentMarkSweepThread.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/genCollectedHeap.hpp"
#include "oops/instanceRefKlass.hpp"
#include "oops/oop.inline.hpp"
@ -124,6 +125,7 @@ void ConcurrentMarkSweepThread::run() {
while (!_should_terminate) {
sleepBeforeNextCycle();
if (_should_terminate) break;
GCIdMark gc_id_mark;
GCCause::Cause cause = _collector->_full_gc_requested ?
_collector->_full_gc_cause : GCCause::_cms_concurrent_mark;
_collector->collect_in_background(cause);

10
hotspot/src/share/vm/gc/cms/parCardTableModRefBS.cpp
View file

@ -43,7 +43,7 @@ non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr,
uint n_threads) {
assert(n_threads > 0, "expected n_threads > 0");
assert(n_threads <= ParallelGCThreads,
err_msg("n_threads: %u > ParallelGCThreads: %u", n_threads, ParallelGCThreads));
"n_threads: %u > ParallelGCThreads: %u", n_threads, ParallelGCThreads);
// Make sure the LNC array is valid for the space.
jbyte** lowest_non_clean;
@ -370,18 +370,18 @@ process_chunk_boundaries(Space* sp,
- lowest_non_clean_base_chunk_index;
if (last_chunk_index_to_check > last_chunk_index) {
assert(last_block + last_block_size > used.end(),
err_msg("Inconsistency detected: last_block [" PTR_FORMAT "," PTR_FORMAT "]"
"Inconsistency detected: last_block [" PTR_FORMAT "," PTR_FORMAT "]"
" does not exceed used.end() = " PTR_FORMAT ","
" yet last_chunk_index_to_check " INTPTR_FORMAT
" exceeds last_chunk_index " INTPTR_FORMAT,
p2i(last_block), p2i(last_block + last_block_size),
p2i(used.end()),
last_chunk_index_to_check, last_chunk_index));
last_chunk_index_to_check, last_chunk_index);
assert(sp->used_region().end() > used.end(),
err_msg("Expansion did not happen: "
"Expansion did not happen: "
"[" PTR_FORMAT "," PTR_FORMAT ") -> [" PTR_FORMAT "," PTR_FORMAT ")",
p2i(sp->used_region().start()), p2i(sp->used_region().end()),
p2i(used.start()), p2i(used.end())));
p2i(used.start()), p2i(used.end()));
NOISY(tty->print_cr(" process_chunk_boundary: heap expanded; explicitly bounding last_chunk");)
last_chunk_index_to_check = last_chunk_index;
}

6
hotspot/src/share/vm/gc/cms/parNewGeneration.cpp
View file

@ -896,7 +896,7 @@ void ParNewGeneration::collect(bool full,
size_policy->minor_collection_begin();
}
GCTraceTime t1(GCCauseString("GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL, _gc_tracer.gc_id());
GCTraceTime t1(GCCauseString("GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL);
// Capture heap used before collection (for printing).
size_t gch_prev_used = gch->used();
@ -959,13 +959,13 @@ void ParNewGeneration::collect(bool full,
ParNewRefProcTaskExecutor task_executor(*this, *_old_gen, thread_state_set);
stats = rp->process_discovered_references(&is_alive, &keep_alive,
&evacuate_followers, &task_executor,
_gc_timer, _gc_tracer.gc_id());
_gc_timer);
} else {
thread_state_set.flush();
gch->save_marks();
stats = rp->process_discovered_references(&is_alive, &keep_alive,
&evacuate_followers, NULL,
_gc_timer, _gc_tracer.gc_id());
_gc_timer);
}
_gc_tracer.report_gc_reference_stats(stats);
if (!promotion_failed()) {

2
hotspot/src/share/vm/gc/cms/promotionInfo.hpp
View file

@ -73,7 +73,7 @@ class PromotedObject VALUE_OBJ_CLASS_SPEC {
} else {
res = (PromotedObject*)(_next & next_mask);
}
assert(oop(res)->is_oop_or_null(true /* ignore mark word */), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(oop(res))));
assert(oop(res)->is_oop_or_null(true /* ignore mark word */), "Expected an oop or NULL at " PTR_FORMAT, p2i(oop(res)));
return res;
}
inline void setNext(PromotedObject* x) {

6
hotspot/src/share/vm/gc/cms/vmCMSOperations.cpp
View file

@ -58,7 +58,7 @@ void VM_CMS_Operation::release_and_notify_pending_list_lock() {
void VM_CMS_Operation::verify_before_gc() {
if (VerifyBeforeGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
GCTraceTime tm("Verify Before", false, false, _collector->_gc_timer_cm, _collector->_gc_tracer_cm->gc_id());
GCTraceTime tm("Verify Before", false, false, _collector->_gc_timer_cm);
HandleMark hm;
FreelistLocker x(_collector);
MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
@ -70,7 +70,7 @@ void VM_CMS_Operation::verify_before_gc() {
void VM_CMS_Operation::verify_after_gc() {
if (VerifyAfterGC &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
GCTraceTime tm("Verify After", false, false, _collector->_gc_timer_cm, _collector->_gc_tracer_cm->gc_id());
GCTraceTime tm("Verify After", false, false, _collector->_gc_timer_cm);
HandleMark hm;
FreelistLocker x(_collector);
MutexLockerEx y(_collector->bitMapLock(), Mutex::_no_safepoint_check_flag);
@ -134,6 +134,7 @@ void VM_CMS_Initial_Mark::doit() {
return;
}
HS_PRIVATE_CMS_INITMARK_BEGIN();
GCIdMark gc_id_mark(_gc_id);
_collector->_gc_timer_cm->register_gc_pause_start("Initial Mark");
@ -161,6 +162,7 @@ void VM_CMS_Final_Remark::doit() {
return;
}
HS_PRIVATE_CMS_REMARK_BEGIN();
GCIdMark gc_id_mark(_gc_id);
_collector->_gc_timer_cm->register_gc_pause_start("Final Mark");

5
hotspot/src/share/vm/gc/cms/vmCMSOperations.hpp
View file

@ -27,6 +27,7 @@
#include "gc/cms/concurrentMarkSweepGeneration.hpp"
#include "gc/shared/gcCause.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/vmGCOperations.hpp"
#include "runtime/vm_operations.hpp"
@ -53,6 +54,7 @@ class VM_CMS_Operation: public VM_Operation {
protected:
CMSCollector* _collector; // associated collector
bool _prologue_succeeded; // whether doit_prologue succeeded
uint _gc_id;
bool lost_race() const;
@ -63,7 +65,8 @@ class VM_CMS_Operation: public VM_Operation {
public:
VM_CMS_Operation(CMSCollector* collector):
_collector(collector),
_prologue_succeeded(false) {}
_prologue_succeeded(false),
_gc_id(GCId::current()) {}
~VM_CMS_Operation() {}
// The legal collector state for executing this CMS op.

2
hotspot/src/share/vm/gc/cms/yieldingWorkgroup.cpp
View file

@ -24,6 +24,7 @@
#include "precompiled.hpp"
#include "gc/cms/yieldingWorkgroup.hpp"
#include "gc/shared/gcId.hpp"
#include "utilities/macros.hpp"
YieldingFlexibleGangWorker::YieldingFlexibleGangWorker(YieldingFlexibleWorkGang* gang, int id)
@ -340,6 +341,7 @@ void YieldingFlexibleGangWorker::loop() {
// Now, release the gang mutex and do the work.
{
MutexUnlockerEx mul(gang_monitor, Mutex::_no_safepoint_check_flag);
GCIdMark gc_id_mark(data.task()->gc_id());
data.task()->work(id); // This might include yielding
}
// Reacquire monitor and note completion of this worker

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

@ -155,8 +155,8 @@ class TestBufferingOopClosure {
#define assert_testCount(got, expected) \
assert((got) == (expected), \
err_msg("Expected: %d, got: %d, when running testCount(%d, %d, %d)", \
(got), (expected), num_narrow, num_full, do_oop_order))
"Expected: %d, got: %d, when running testCount(%d, %d, %d)", \
(got), (expected), num_narrow, num_full, do_oop_order)
assert_testCount(num_narrow, coc.narrow_oop_count());
assert_testCount(num_full, coc.full_oop_count());
@ -192,9 +192,9 @@ class TestBufferingOopClosure {
#define assert_testIsBufferEmptyOrFull(got, expected) \
assert((got) == (expected), \
err_msg("Expected: %d, got: %d. testIsBufferEmptyOrFull(%d, %d, %s, %s)", \
"Expected: %d, got: %d. testIsBufferEmptyOrFull(%d, %d, %s, %s)", \
(got), (expected), num_narrow, num_full, \
BOOL_TO_STR(expect_empty), BOOL_TO_STR(expect_full)))
BOOL_TO_STR(expect_empty), BOOL_TO_STR(expect_full))
assert_testIsBufferEmptyOrFull(expect_empty, boc.is_buffer_empty());
assert_testIsBufferEmptyOrFull(expect_full, boc.is_buffer_full());
@ -232,8 +232,8 @@ class TestBufferingOopClosure {
boc.done();
assert(boc.is_buffer_empty(),
err_msg("Should be empty after call to done(). testEmptyAfterDone(%d, %d)",
num_narrow, num_full));
"Should be empty after call to done(). testEmptyAfterDone(%d, %d)",
num_narrow, num_full);
}
static void testEmptyAfterDone() {

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

@ -91,10 +91,8 @@ CollectionSetChooser::CollectionSetChooser() :
#ifndef PRODUCT
void CollectionSetChooser::verify() {
guarantee(_end <= regions_length(),
err_msg("_end: %u regions length: %u", _end, regions_length()));
guarantee(_front <= _end,
err_msg("_front: %u _end: %u", _front, _end));
guarantee(_end <= regions_length(), "_end: %u regions length: %u", _end, regions_length());
guarantee(_front <= _end, "_front: %u _end: %u", _front, _end);
uint index = 0;
size_t sum_of_reclaimable_bytes = 0;
while (index < _front) {
@ -108,19 +106,19 @@ void CollectionSetChooser::verify() {
guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
guarantee(!curr->is_young(), "should not be young!");
guarantee(!curr->is_pinned(),
err_msg("Pinned region should not be in collection set (index %u)", curr->hrm_index()));
"Pinned region should not be in collection set (index %u)", curr->hrm_index());
if (prev != NULL) {
guarantee(order_regions(prev, curr) != 1,
err_msg("GC eff prev: %1.4f GC eff curr: %1.4f",
prev->gc_efficiency(), curr->gc_efficiency()));
"GC eff prev: %1.4f GC eff curr: %1.4f",
prev->gc_efficiency(), curr->gc_efficiency());
}
sum_of_reclaimable_bytes += curr->reclaimable_bytes();
prev = curr;
}
guarantee(sum_of_reclaimable_bytes == _remaining_reclaimable_bytes,
err_msg("reclaimable bytes inconsistent, "
"reclaimable bytes inconsistent, "
"remaining: " SIZE_FORMAT " sum: " SIZE_FORMAT,
_remaining_reclaimable_bytes, sum_of_reclaimable_bytes));
_remaining_reclaimable_bytes, sum_of_reclaimable_bytes);
}
#endif // !PRODUCT
@ -151,7 +149,7 @@ void CollectionSetChooser::sort_regions() {
void CollectionSetChooser::add_region(HeapRegion* hr) {
assert(!hr->is_pinned(),
err_msg("Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index()));
"Pinned region shouldn't be added to the collection set (index %u)", hr->hrm_index());
assert(!hr->is_young(), "should not be young!");
_regions.append(hr);
_end++;

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

@ -73,9 +73,7 @@ public:
HeapRegion* res = NULL;
if (_front < _end) {
res = regions_at(_front);
assert(res != NULL,
err_msg("Unexpected NULL hr in _regions at index %u",
_front));
assert(res != NULL, "Unexpected NULL hr in _regions at index %u", _front);
}
return res;
}
@ -88,9 +86,9 @@ public:
assert(_front < _end, "pre-condition");
regions_at_put(_front, NULL);
assert(hr->reclaimable_bytes() <= _remaining_reclaimable_bytes,
err_msg("remaining reclaimable bytes inconsistent "
"remaining reclaimable bytes inconsistent "
"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();
_front += 1;
return hr;

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

@ -41,6 +41,7 @@
#include "gc/g1/heapRegionRemSet.hpp"
#include "gc/g1/heapRegionSet.inline.hpp"
#include "gc/g1/suspendibleThreadSet.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/gcTimer.hpp"
#include "gc/shared/gcTrace.hpp"
#include "gc/shared/gcTraceTime.hpp"
@ -245,10 +246,6 @@ MemRegion CMBitMap::getAndClearMarkedRegion(HeapWord* addr,
CMMarkStack::CMMarkStack(ConcurrentMark* cm) :
_base(NULL), _cm(cm)
#ifdef ASSERT
, _drain_in_progress(false)
, _drain_in_progress_yields(false)
#endif
{}
bool CMMarkStack::allocate(size_t capacity) {
@ -362,30 +359,6 @@ bool CMMarkStack::par_pop_arr(oop* ptr_arr, int max, int* n) {
}
}
template<class OopClosureClass>
bool CMMarkStack::drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after) {
assert(!_drain_in_progress || !_drain_in_progress_yields || yield_after
|| SafepointSynchronize::is_at_safepoint(),
"Drain recursion must be yield-safe.");
bool res = true;
debug_only(_drain_in_progress = true);
debug_only(_drain_in_progress_yields = yield_after);
while (!isEmpty()) {
oop newOop = pop();
assert(G1CollectedHeap::heap()->is_in_reserved(newOop), "Bad pop");
assert(newOop->is_oop(), "Expected an oop");
assert(bm == NULL || bm->isMarked((HeapWord*)newOop),
"only grey objects on this stack");
newOop->oop_iterate(cl);
if (yield_after && _cm->do_yield_check()) {
res = false;
break;
}
}
debug_only(_drain_in_progress = false);
return res;
}
void CMMarkStack::note_start_of_gc() {
assert(_saved_index == -1,
"note_start_of_gc()/end_of_gc() bracketed incorrectly");
@ -399,7 +372,7 @@ void CMMarkStack::note_end_of_gc() {
// only check this once per GC anyway, so it won't be a performance
// issue in any way.
guarantee(_saved_index == _index,
err_msg("saved index: %d index: %d", _saved_index, _index));
"saved index: %d index: %d", _saved_index, _index);
_saved_index = -1;
}
@ -520,7 +493,6 @@ ConcurrentMark::ConcurrentMark(G1CollectedHeap* g1h, G1RegionToSpaceMapper* prev
_has_overflown(false),
_concurrent(false),
_has_aborted(false),
_aborted_gc_id(GCId::undefined()),
_restart_for_overflow(false),
_concurrent_marking_in_progress(false),
@ -794,8 +766,8 @@ void ConcurrentMark::set_concurrency_and_phase(uint active_tasks, bool concurren
// in a STW phase.
assert(!concurrent_marking_in_progress(), "invariant");
assert(out_of_regions(),
err_msg("only way to get here: _finger: " PTR_FORMAT ", _heap_end: " PTR_FORMAT,
p2i(_finger), p2i(_heap_end)));
"only way to get here: _finger: " PTR_FORMAT ", _heap_end: " PTR_FORMAT,
p2i(_finger), p2i(_heap_end));
}
}
@ -991,7 +963,7 @@ void ConcurrentMark::enter_first_sync_barrier(uint worker_id) {
force_overflow()->update();
if (G1Log::fine()) {
gclog_or_tty->gclog_stamp(concurrent_gc_id());
gclog_or_tty->gclog_stamp();
gclog_or_tty->print_cr("[GC concurrent-mark-reset-for-overflow]");
}
}
@ -1181,7 +1153,7 @@ void ConcurrentMark::scanRootRegions() {
// should not attempt to do any further work.
if (root_regions()->scan_in_progress()) {
if (G1Log::fine()) {
gclog_or_tty->gclog_stamp(concurrent_gc_id());
gclog_or_tty->gclog_stamp();
gclog_or_tty->print_cr("[GC concurrent-root-region-scan-start]");
}
@ -1195,7 +1167,7 @@ void ConcurrentMark::scanRootRegions() {
_parallel_workers->run_task(&task);
if (G1Log::fine()) {
gclog_or_tty->gclog_stamp(concurrent_gc_id());
gclog_or_tty->gclog_stamp();
gclog_or_tty->print_cr("[GC concurrent-root-region-scan-end, %1.7lf secs]", os::elapsedTime() - scan_start);
}
@ -1235,7 +1207,8 @@ void ConcurrentMark::markFromRoots() {
}
// Helper class to get rid of some boilerplate code.
class G1CMTraceTime : public GCTraceTime {
class G1CMTraceTime : public StackObj {
GCTraceTimeImpl _gc_trace_time;
static bool doit_and_prepend(bool doit) {
if (doit) {
gclog_or_tty->put(' ');
@ -1245,8 +1218,7 @@ class G1CMTraceTime : public GCTraceTime {
public:
G1CMTraceTime(const char* title, bool doit)
: GCTraceTime(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm(),
G1CollectedHeap::heap()->concurrent_mark()->concurrent_gc_id()) {
: _gc_trace_time(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm()) {
}
};
@ -1415,9 +1387,9 @@ public:
HeapWord* start = hr->bottom();
assert(start <= hr->end() && start <= ntams && ntams <= hr->end(),
err_msg("Preconditions not met - "
"Preconditions not met - "
"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".
start = _bm->getNextMarkedWordAddress(start, ntams);
@ -1717,11 +1689,11 @@ class FinalCountDataUpdateClosure: public CMCountDataClosureBase {
}
assert(end_idx <= _card_bm->size(),
err_msg("oob: end_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
end_idx, _card_bm->size()));
"oob: end_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
end_idx, _card_bm->size());
assert(start_idx < _card_bm->size(),
err_msg("oob: start_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
start_idx, _card_bm->size()));
"oob: start_idx= " SIZE_FORMAT ", bitmap size= " SIZE_FORMAT,
start_idx, _card_bm->size());
_cm->set_card_bitmap_range(_card_bm, start_idx, end_idx, true /* is_par */);
}
@ -2391,8 +2363,7 @@ void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
&g1_keep_alive,
&g1_drain_mark_stack,
executor,
g1h->gc_timer_cm(),
concurrent_gc_id());
g1h->gc_timer_cm());
g1h->gc_tracer_cm()->report_gc_reference_stats(stats);
// The do_oop work routines of the keep_alive and drain_marking_stack
@ -2471,7 +2442,7 @@ private:
// object; it could instead have been a stale reference.
oop obj = static_cast<oop>(entry);
assert(obj->is_oop(true /* ignore mark word */),
err_msg("Invalid oop in SATB buffer: " PTR_FORMAT, p2i(obj)));
"Invalid oop in SATB buffer: " PTR_FORMAT, p2i(obj));
_task->make_reference_grey(obj, hr);
}
}
@ -2588,9 +2559,9 @@ void ConcurrentMark::checkpointRootsFinalWork() {
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
guarantee(has_overflown() ||
satb_mq_set.completed_buffers_num() == 0,
err_msg("Invariant: has_overflown = %s, num buffers = %d",
"Invariant: has_overflown = %s, num buffers = %d",
BOOL_TO_STR(has_overflown()),
satb_mq_set.completed_buffers_num()));
satb_mq_set.completed_buffers_num());
print_stats();
}
@ -2724,11 +2695,11 @@ public:
void operator()(oop obj) const {
guarantee(obj->is_oop(),
err_msg("Non-oop " PTR_FORMAT ", phase: %s, info: %d",
p2i(obj), _phase, _info));
"Non-oop " PTR_FORMAT ", phase: %s, info: %d",
p2i(obj), _phase, _info);
guarantee(!_g1h->obj_in_cs(obj),
err_msg("obj: " PTR_FORMAT " in CSet, phase: %s, info: %d",
p2i(obj), _phase, _info));
"obj: " PTR_FORMAT " in CSet, phase: %s, info: %d",
p2i(obj), _phase, _info);
}
};
@ -2761,8 +2732,8 @@ void ConcurrentMark::verify_no_cset_oops() {
// here.
HeapRegion* global_hr = _g1h->heap_region_containing_raw(global_finger);
guarantee(global_hr == NULL || global_finger == global_hr->bottom(),
err_msg("global finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(global_finger), HR_FORMAT_PARAMS(global_hr)));
"global finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(global_finger), HR_FORMAT_PARAMS(global_hr));
}
// Verify the task fingers
@ -2775,8 +2746,8 @@ void ConcurrentMark::verify_no_cset_oops() {
HeapRegion* task_hr = _g1h->heap_region_containing_raw(task_finger);
guarantee(task_hr == NULL || task_finger == task_hr->bottom() ||
!task_hr->in_collection_set(),
err_msg("task finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(task_finger), HR_FORMAT_PARAMS(task_hr)));
"task finger: " PTR_FORMAT " region: " HR_FORMAT,
p2i(task_finger), HR_FORMAT_PARAMS(task_hr));
}
}
}
@ -2816,10 +2787,10 @@ class AggregateCountDataHRClosure: public HeapRegionClosure {
HeapWord* end = hr->end();
assert(start <= limit && limit <= hr->top() && hr->top() <= hr->end(),
err_msg("Preconditions not met - "
"Preconditions not met - "
"start: " PTR_FORMAT ", limit: " 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");
@ -2988,8 +2959,6 @@ void ConcurrentMark::abort() {
}
_first_overflow_barrier_sync.abort();
_second_overflow_barrier_sync.abort();
_aborted_gc_id = _g1h->gc_tracer_cm()->gc_id();
assert(!_aborted_gc_id.is_undefined(), "ConcurrentMark::abort() executed more than once?");
_has_aborted = true;
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
@ -3004,13 +2973,6 @@ void ConcurrentMark::abort() {
_g1h->register_concurrent_cycle_end();
}
const GCId& ConcurrentMark::concurrent_gc_id() {
if (has_aborted()) {
return _aborted_gc_id;
}
return _g1h->gc_tracer_cm()->gc_id();
}
static void print_ms_time_info(const char* prefix, const char* name,
NumberSeq& ns) {
gclog_or_tty->print_cr("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).",

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

@ -28,7 +28,6 @@
#include "classfile/javaClasses.hpp"
#include "gc/g1/g1RegionToSpaceMapper.hpp"
#include "gc/g1/heapRegionSet.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/taskqueue.hpp"
class G1CollectedHeap;
@ -183,15 +182,6 @@ class CMMarkStack VALUE_OBJ_CLASS_SPEC {
bool _overflow;
bool _should_expand;
DEBUG_ONLY(bool _drain_in_progress;)
DEBUG_ONLY(bool _drain_in_progress_yields;)
oop pop() {
if (!isEmpty()) {
return _base[--_index] ;
}
return NULL;
}
public:
CMMarkStack(ConcurrentMark* cm);
@ -213,17 +203,6 @@ class CMMarkStack VALUE_OBJ_CLASS_SPEC {
// operations, which use the same locking strategy.
bool par_pop_arr(oop* ptr_arr, int max, int* n);
// Drain the mark stack, applying the given closure to all fields of
// objects on the stack. (That is, continue until the stack is empty,
// even if closure applications add entries to the stack.) The "bm"
// argument, if non-null, may be used to verify that only marked objects
// are on the mark stack. If "yield_after" is "true", then the
// concurrent marker performing the drain offers to yield after
// processing each object. If a yield occurs, stops the drain operation
// and returns false. Otherwise, returns true.
template<class OopClosureClass>
bool drain(OopClosureClass* cl, CMBitMap* bm, bool yield_after = false);
bool isEmpty() { return _index == 0; }
int maxElems() { return _capacity; }
@ -425,7 +404,6 @@ protected:
volatile bool _concurrent;
// Set at the end of a Full GC so that marking aborts
volatile bool _has_aborted;
GCId _aborted_gc_id;
// Used when remark aborts due to an overflow to indicate that
// another concurrent marking phase should start
@ -768,8 +746,6 @@ public:
bool has_aborted() { return _has_aborted; }
const GCId& concurrent_gc_id();
// This prints the global/local fingers. It is used for debugging.
NOT_PRODUCT(void print_finger();)

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

@ -197,9 +197,9 @@ inline bool CMBitMapRO::iterate(BitMapClosure* cl) {
assert(_bmStartWord <= (addr) && (addr) < (_bmStartWord + _bmWordSize), \
"outside underlying space?"); \
assert(G1CollectedHeap::heap()->is_in_exact(addr), \
err_msg("Trying to access not available bitmap " PTR_FORMAT \
"Trying to access not available bitmap " PTR_FORMAT \
" 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) {
check_mark(addr);
@ -225,8 +225,7 @@ inline bool CMBitMap::parClear(HeapWord* addr) {
template<typename Fn>
inline void CMMarkStack::iterate(Fn fn) {
assert(_saved_index == _index,
err_msg("saved index: %d index: %d", _saved_index, _index));
assert(_saved_index == _index, "saved index: %d index: %d", _saved_index, _index);
for (int i = 0; i < _index; ++i) {
fn(_base[i]);
}
@ -385,7 +384,7 @@ inline void CMTask::deal_with_reference(oop obj) {
increment_refs_reached();
HeapWord* objAddr = (HeapWord*) obj;
assert(obj->is_oop_or_null(true /* ignore mark word */), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
assert(obj->is_oop_or_null(true /* ignore mark word */), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj));
if (_g1h->is_in_g1_reserved(objAddr)) {
assert(obj != NULL, "null check is implicit");
if (!_nextMarkBitMap->isMarked(objAddr)) {
@ -427,9 +426,9 @@ inline void ConcurrentMark::grayRoot(oop obj, size_t word_size,
// assert that word_size is under an upper bound which is its
// containing region's capacity.
assert(word_size * HeapWordSize <= hr->capacity(),
err_msg("size: " SIZE_FORMAT " capacity: " SIZE_FORMAT " " HR_FORMAT,
"size: " SIZE_FORMAT " capacity: " SIZE_FORMAT " " HR_FORMAT,
word_size * HeapWordSize, hr->capacity(),
HR_FORMAT_PARAMS(hr)));
HR_FORMAT_PARAMS(hr));
if (addr < hr->next_top_at_mark_start()) {
if (!_nextMarkBitMap->isMarked(addr)) {

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

@ -30,6 +30,7 @@
#include "gc/g1/g1MMUTracker.hpp"
#include "gc/g1/suspendibleThreadSet.hpp"
#include "gc/g1/vm_operations_g1.hpp"
#include "gc/shared/gcId.hpp"
#include "gc/shared/gcTrace.hpp"
#include "memory/resourceArea.hpp"
#include "runtime/vmThread.hpp"
@ -85,7 +86,7 @@ void ConcurrentMarkThread::cm_log(bool doit, bool join_sts, const char* fmt, ...
SuspendibleThreadSetJoiner sts_joiner(join_sts);
va_list args;
va_start(args, fmt);
gclog_or_tty->gclog_stamp(cm()->concurrent_gc_id());
gclog_or_tty->gclog_stamp();
gclog_or_tty->vprint_cr(fmt, args);
va_end(args);
}
@ -108,6 +109,7 @@ void ConcurrentMarkThread::run() {
break;
}
GCIdMark gc_id_mark;
{
ResourceMark rm;
HandleMark hm;
@ -194,7 +196,7 @@ void ConcurrentMarkThread::run() {
// reclaimed by cleanup.
double cleanup_start_sec = os::elapsedTime();
cm_log(G1Log::fine(), true, "[GC concurrent-cleanup-start]");
cm_log(G1Log::fine(), false, "[GC concurrent-cleanup-start]");
// Now do the concurrent cleanup operation.
_cm->completeCleanup();

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

@ -91,7 +91,7 @@ size_t G1AllocRegion::fill_up_remaining_space(HeapRegion* alloc_region,
}
size_t G1AllocRegion::retire(bool fill_up) {
assert(_alloc_region != NULL, ar_ext_msg(this, "not initialized properly"));
assert_alloc_region(_alloc_region != NULL, "not initialized properly");
size_t result = 0;
@ -101,15 +101,14 @@ size_t G1AllocRegion::retire(bool fill_up) {
// We never have to check whether the active region is empty or not,
// and potentially free it if it is, given that it's guaranteed that
// it will never be empty.
assert(!alloc_region->is_empty(),
ar_ext_msg(this, "the alloc region should never be empty"));
assert_alloc_region(!alloc_region->is_empty(),
"the alloc region should never be empty");
if (fill_up) {
result = fill_up_remaining_space(alloc_region, _bot_updates);
}
assert(alloc_region->used() >= _used_bytes_before,
ar_ext_msg(this, "invariant"));
assert_alloc_region(alloc_region->used() >= _used_bytes_before, "invariant");
size_t allocated_bytes = alloc_region->used() - _used_bytes_before;
retire_region(alloc_region, allocated_bytes);
_used_bytes_before = 0;
@ -122,8 +121,8 @@ size_t G1AllocRegion::retire(bool fill_up) {
HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size,
bool force) {
assert(_alloc_region == _dummy_region, ar_ext_msg(this, "pre-condition"));
assert(_used_bytes_before == 0, ar_ext_msg(this, "pre-condition"));
assert_alloc_region(_alloc_region == _dummy_region, "pre-condition");
assert_alloc_region(_used_bytes_before == 0, "pre-condition");
trace("attempting region allocation");
HeapRegion* new_alloc_region = allocate_new_region(word_size, force);
@ -132,7 +131,7 @@ HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size,
// Need to do this before the allocation
_used_bytes_before = new_alloc_region->used();
HeapWord* result = allocate(new_alloc_region, word_size, _bot_updates);
assert(result != NULL, ar_ext_msg(this, "the allocation should succeeded"));
assert_alloc_region(result != NULL, "the allocation should succeeded");
OrderAccess::storestore();
// Note that we first perform the allocation and then we store the
@ -148,17 +147,10 @@ HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size,
ShouldNotReachHere();
}
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,
_name, message, _count, BOOL_TO_STR(_bot_updates),
p2i(_alloc_region), _used_bytes_before);
}
void G1AllocRegion::init() {
trace("initializing");
assert(_alloc_region == NULL && _used_bytes_before == 0,
ar_ext_msg(this, "pre-condition"));
assert(_dummy_region != NULL, ar_ext_msg(this, "should have been set"));
assert_alloc_region(_alloc_region == NULL && _used_bytes_before == 0, "pre-condition");
assert_alloc_region(_dummy_region != NULL, "should have been set");
_alloc_region = _dummy_region;
_count = 0;
trace("initialized");
@ -168,11 +160,10 @@ void G1AllocRegion::set(HeapRegion* alloc_region) {
trace("setting");
// We explicitly check that the region is not empty to make sure we
// maintain the "the alloc region cannot be empty" invariant.
assert(alloc_region != NULL && !alloc_region->is_empty(),
ar_ext_msg(this, "pre-condition"));
assert(_alloc_region == _dummy_region &&
assert_alloc_region(alloc_region != NULL && !alloc_region->is_empty(), "pre-condition");
assert_alloc_region(_alloc_region == _dummy_region &&
_used_bytes_before == 0 && _count == 0,
ar_ext_msg(this, "pre-condition"));
"pre-condition");
_used_bytes_before = alloc_region->used();
_alloc_region = alloc_region;
@ -184,8 +175,7 @@ void G1AllocRegion::update_alloc_region(HeapRegion* alloc_region) {
trace("update");
// We explicitly check that the region is not empty to make sure we
// maintain the "the alloc region cannot be empty" invariant.
assert(alloc_region != NULL && !alloc_region->is_empty(),
ar_ext_msg(this, "pre-condition"));
assert_alloc_region(alloc_region != NULL && !alloc_region->is_empty(), "pre-condition");
_alloc_region = alloc_region;
_alloc_region->set_allocation_context(allocation_context());
@ -197,8 +187,7 @@ HeapRegion* G1AllocRegion::release() {
trace("releasing");
HeapRegion* alloc_region = _alloc_region;
retire(false /* fill_up */);
assert(_alloc_region == _dummy_region,
ar_ext_msg(this, "post-condition of retire()"));
assert_alloc_region(_alloc_region == _dummy_region, "post-condition of retire()");
_alloc_region = NULL;
trace("released");
return (alloc_region == _dummy_region) ? NULL : alloc_region;

12
hotspot/src/share/vm/gc/g1/g1AllocRegion.hpp
View file

@ -34,8 +34,6 @@ class G1CollectedHeap;
// 0 -> no tracing, 1 -> basic tracing, 2 -> basic + allocation tracing
#define G1_ALLOC_REGION_TRACING 0
class ar_ext_msg;
// A class that holds a region that is active in satisfying allocation
// requests, potentially issued in parallel. When the active region is
// full it will be retired and replaced with a new one. The
@ -44,7 +42,6 @@ class ar_ext_msg;
// replaced.
class G1AllocRegion VALUE_OBJ_CLASS_SPEC {
friend class ar_ext_msg;
private:
// The active allocating region we are currently allocating out
@ -131,8 +128,6 @@ private:
// to allocate a new region even if the max has been reached.
HeapWord* new_alloc_region_and_allocate(size_t word_size, bool force);
void fill_in_ext_msg(ar_ext_msg* msg, const char* message);
protected:
// Retire the active allocating region. If fill_up is true then make
// sure that the region is full before we retire it so that no one
@ -278,11 +273,4 @@ public:
virtual HeapRegion* release();
};
class ar_ext_msg : public err_msg {
public:
ar_ext_msg(G1AllocRegion* alloc_region, const char *message) : err_msg("%s", "") {
alloc_region->fill_in_ext_msg(this, message);
}
};
#endif // SHARE_VM_GC_G1_G1ALLOCREGION_HPP

22
hotspot/src/share/vm/gc/g1/g1AllocRegion.inline.hpp
View file

@ -28,10 +28,18 @@
#include "gc/g1/g1AllocRegion.hpp"
#include "gc/g1/heapRegion.inline.hpp"
#define assert_alloc_region(p, message) \
do { \
assert((p), "[%s] %s c: %u b: %s r: " PTR_FORMAT " u: " SIZE_FORMAT, \
_name, (message), _count, BOOL_TO_STR(_bot_updates), \
p2i(_alloc_region), _used_bytes_before); \
} while (0)
inline HeapWord* G1AllocRegion::allocate(HeapRegion* alloc_region,
size_t word_size,
bool bot_updates) {
assert(alloc_region != NULL, err_msg("pre-condition"));
assert(alloc_region != NULL, "pre-condition");
if (!bot_updates) {
return alloc_region->allocate_no_bot_updates(word_size);
@ -50,8 +58,8 @@ inline HeapWord* G1AllocRegion::par_allocate(HeapRegion* alloc_region,
size_t desired_word_size,
size_t* actual_word_size,
bool bot_updates) {
assert(alloc_region != NULL, err_msg("pre-condition"));
assert(!alloc_region->is_empty(), err_msg("pre-condition"));
assert(alloc_region != NULL, "pre-condition");
assert(!alloc_region->is_empty(), "pre-condition");
if (!bot_updates) {
return alloc_region->par_allocate_no_bot_updates(min_word_size, desired_word_size, actual_word_size);
@ -69,10 +77,10 @@ inline HeapWord* G1AllocRegion::attempt_allocation(size_t min_word_size,
size_t desired_word_size,
size_t* actual_word_size,
bool bot_updates) {
assert(bot_updates == _bot_updates, ar_ext_msg(this, "pre-condition"));
assert_alloc_region(bot_updates == _bot_updates, "pre-condition");
HeapRegion* alloc_region = _alloc_region;
assert(alloc_region != NULL, ar_ext_msg(this, "not initialized properly"));
assert_alloc_region(alloc_region != NULL, "not initialized properly");
HeapWord* result = par_allocate(alloc_region, min_word_size, desired_word_size, actual_word_size, bot_updates);
if (result != NULL) {
@ -113,8 +121,8 @@ inline HeapWord* G1AllocRegion::attempt_allocation_locked(size_t min_word_size,
inline HeapWord* G1AllocRegion::attempt_allocation_force(size_t word_size,
bool bot_updates) {
assert(bot_updates == _bot_updates, ar_ext_msg(this, "pre-condition"));
assert(_alloc_region != NULL, ar_ext_msg(this, "not initialized properly"));
assert_alloc_region(bot_updates == _bot_updates, "pre-condition");
assert_alloc_region(_alloc_region != NULL, "not initialized properly");
trace("forcing alloc", word_size, word_size);
HeapWord* result = new_alloc_region_and_allocate(word_size, true /* force */);

38
hotspot/src/share/vm/gc/g1/g1Allocator.cpp
View file

@ -54,7 +54,7 @@ void G1Allocator::reuse_retained_old_region(EvacuationInfo& evacuation_info,
HeapRegion* retained_region = *retained_old;
*retained_old = NULL;
assert(retained_region == NULL || !retained_region->is_archive(),
err_msg("Archive region should not be alloc region (index %u)", retained_region->hrm_index()));
"Archive region should not be alloc region (index %u)", retained_region->hrm_index());
// We will discard the current GC alloc region if:
// a) it's in the collection set (it can happen!),
@ -147,8 +147,8 @@ HeapWord* G1Allocator::par_allocate_during_gc(InCSetState dest,
size_t temp = 0;
HeapWord* result = par_allocate_during_gc(dest, word_size, word_size, &temp, context);
assert(result == NULL || temp == word_size,
err_msg("Requested " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT,
word_size, temp, p2i(result)));
"Requested " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT,
word_size, temp, p2i(result));
return result;
}
@ -276,16 +276,16 @@ HeapWord* G1PLABAllocator::allocate_direct_or_new_plab(InCSetState dest,
context);
assert(buf == NULL || ((actual_plab_size >= required_in_plab) && (actual_plab_size <= plab_word_size)),
err_msg("Requested at minimum " SIZE_FORMAT ", desired " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT,
required_in_plab, plab_word_size, actual_plab_size, p2i(buf)));
"Requested at minimum " SIZE_FORMAT ", desired " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT,
required_in_plab, plab_word_size, actual_plab_size, p2i(buf));
if (buf != NULL) {
alloc_buf->set_buf(buf, actual_plab_size);
HeapWord* const obj = alloc_buf->allocate(word_sz);
assert(obj != NULL, err_msg("PLAB should have been big enough, tried to allocate "
assert(obj != NULL, "PLAB should have been big enough, tried to allocate "
SIZE_FORMAT " requiring " SIZE_FORMAT " PLAB size " SIZE_FORMAT,
word_sz, required_in_plab, plab_word_size));
word_sz, required_in_plab, plab_word_size);
return obj;
}
// Otherwise.
@ -354,7 +354,7 @@ bool G1ArchiveAllocator::alloc_new_region() {
if (hr == NULL) {
return false;
}
assert(hr->is_empty(), err_msg("expected empty region (index %u)", hr->hrm_index()));
assert(hr->is_empty(), "expected empty region (index %u)", hr->hrm_index());
hr->set_archive();
_g1h->old_set_add(hr);
_g1h->hr_printer()->alloc(hr, G1HRPrinter::Archive);
@ -383,15 +383,15 @@ HeapWord* G1ArchiveAllocator::archive_mem_allocate(size_t word_size) {
}
HeapWord* old_top = _allocation_region->top();
assert(_bottom >= _allocation_region->bottom(),
err_msg("inconsistent allocation state: " PTR_FORMAT " < " PTR_FORMAT,
p2i(_bottom), p2i(_allocation_region->bottom())));
"inconsistent allocation state: " PTR_FORMAT " < " PTR_FORMAT,
p2i(_bottom), p2i(_allocation_region->bottom()));
assert(_max <= _allocation_region->end(),
err_msg("inconsistent allocation state: " PTR_FORMAT " > " PTR_FORMAT,
p2i(_max), p2i(_allocation_region->end())));
"inconsistent allocation state: " PTR_FORMAT " > " PTR_FORMAT,
p2i(_max), p2i(_allocation_region->end()));
assert(_bottom <= old_top && old_top <= _max,
err_msg("inconsistent allocation state: expected "
"inconsistent allocation state: expected "
PTR_FORMAT " <= " PTR_FORMAT " <= " PTR_FORMAT,
p2i(_bottom), p2i(old_top), p2i(_max)));
p2i(_bottom), p2i(old_top), p2i(_max));
// Allocate the next word_size words in the current allocation chunk.
// If allocation would cross the _max boundary, insert a filler and begin
@ -430,9 +430,9 @@ HeapWord* G1ArchiveAllocator::archive_mem_allocate(size_t word_size) {
void G1ArchiveAllocator::complete_archive(GrowableArray<MemRegion>* ranges,
size_t end_alignment_in_bytes) {
assert((end_alignment_in_bytes >> LogHeapWordSize) < HeapRegion::min_region_size_in_words(),
err_msg("alignment " SIZE_FORMAT " too large", end_alignment_in_bytes));
"alignment " SIZE_FORMAT " too large", end_alignment_in_bytes);
assert(is_size_aligned(end_alignment_in_bytes, HeapWordSize),
err_msg("alignment " SIZE_FORMAT " is not HeapWord (%u) aligned", end_alignment_in_bytes, HeapWordSize));
"alignment " SIZE_FORMAT " is not HeapWord (%u) aligned", end_alignment_in_bytes, HeapWordSize);
// If we've allocated nothing, simply return.
if (_allocation_region == NULL) {
@ -465,8 +465,8 @@ void G1ArchiveAllocator::complete_archive(GrowableArray<MemRegion>* ranges,
// MemRegions to the GrowableArray provided by the caller.
int index = _allocated_regions.length() - 1;
assert(_allocated_regions.at(index) == _allocation_region,
err_msg("expected region %u at end of array, found %u",
_allocation_region->hrm_index(), _allocated_regions.at(index)->hrm_index()));
"expected region %u at end of array, found %u",
_allocation_region->hrm_index(), _allocated_regions.at(index)->hrm_index());
HeapWord* base_address = _allocation_region->bottom();
HeapWord* top = base_address;
@ -482,7 +482,7 @@ void G1ArchiveAllocator::complete_archive(GrowableArray<MemRegion>* ranges,
index = index - 1;
}
assert(top != base_address, err_msg("zero-sized range, address " PTR_FORMAT, p2i(base_address)));
assert(top != base_address, "zero-sized range, address " PTR_FORMAT, p2i(base_address));
ranges->append(MemRegion(base_address, pointer_delta(top, base_address)));
_allocated_regions.clear();
_allocation_region = NULL;

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

@ -295,9 +295,9 @@ public:
virtual G1PLAB* alloc_buffer(InCSetState dest, AllocationContext_t context) {
assert(dest.is_valid(),
err_msg("Allocation buffer index out-of-bounds: " CSETSTATE_FORMAT, dest.value()));
"Allocation buffer index out-of-bounds: " CSETSTATE_FORMAT, dest.value());
assert(_alloc_buffers[dest.value()] != NULL,
err_msg("Allocation buffer is NULL: " CSETSTATE_FORMAT, dest.value()));
"Allocation buffer is NULL: " CSETSTATE_FORMAT, dest.value());
return _alloc_buffers[dest.value()];
}

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

@ -36,7 +36,7 @@ HeapWord* G1Allocator::attempt_allocation(size_t word_size, AllocationContext_t
HeapWord* G1Allocator::attempt_allocation_locked(size_t word_size, AllocationContext_t context) {
HeapWord* result = mutator_alloc_region(context)->attempt_allocation_locked(word_size, false /* bot_updates */);
assert(result != NULL || mutator_alloc_region(context)->get() == NULL,
err_msg("Must not have a mutator alloc region if there is no memory, but is " PTR_FORMAT, p2i(mutator_alloc_region(context)->get())));
"Must not have a mutator alloc region if there is no memory, but is " PTR_FORMAT, p2i(mutator_alloc_region(context)->get()));
return result;
}

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

@ -36,19 +36,21 @@ address G1BiasedMappedArrayBase::create_new_base_array(size_t length, size_t ele
#ifndef PRODUCT
void G1BiasedMappedArrayBase::verify_index(idx_t index) const {
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(), "Index out of bounds index: " SIZE_FORMAT " length: " SIZE_FORMAT, index, length());
}
void G1BiasedMappedArrayBase::verify_biased_index(idx_t biased_index) const {
guarantee(_biased_base != NULL, "Array not initialized");
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()));
"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 {
guarantee(_biased_base != NULL, "Array not initialized");
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()));
"Biased index out of inclusive bounds, index: " SIZE_FORMAT " bias: " SIZE_FORMAT " length: " SIZE_FORMAT,
biased_index, bias(), length());
}
class TestMappedArray : public G1BiasedMappedArray<int> {
@ -65,7 +67,7 @@ public:
REGION_SIZE_IN_WORDS * HeapWordSize);
// Check address calculation (bounds)
assert(array.bottom_address_mapped() == fake_heap,
err_msg("bottom mapped address should be " PTR_FORMAT ", but is " PTR_FORMAT, p2i(fake_heap), p2i(array.bottom_address_mapped())));
"bottom mapped address should be " PTR_FORMAT ", but is " PTR_FORMAT, p2i(fake_heap), p2i(array.bottom_address_mapped()));
assert(array.end_address_mapped() == (fake_heap + REGION_SIZE_IN_WORDS * NUM_REGIONS), "must be");
int* bottom = array.address_mapped_to(fake_heap);

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

@ -56,7 +56,7 @@ protected:
void initialize_base(address base, size_t length, size_t bias, size_t elem_size, uint shift_by) {
assert(base != NULL, "just checking");
assert(length > 0, "just checking");
assert(shift_by < sizeof(uintptr_t) * 8, err_msg("Shifting by %u, larger than word size?", shift_by));
assert(shift_by < sizeof(uintptr_t) * 8, "Shifting by %u, larger than word size?", shift_by);
_base = base;
_length = length;
_biased_base = base - (bias * elem_size);
@ -69,13 +69,13 @@ protected:
void initialize(HeapWord* bottom, HeapWord* end, size_t target_elem_size_in_bytes, size_t mapping_granularity_in_bytes) {
assert(mapping_granularity_in_bytes > 0, "just checking");
assert(is_power_of_2(mapping_granularity_in_bytes),
err_msg("mapping granularity must be power of 2, is %zd", mapping_granularity_in_bytes));
"mapping granularity must be power of 2, is %zd", mapping_granularity_in_bytes);
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,
mapping_granularity_in_bytes, p2i(bottom)));
"bottom mapping area address must be a multiple of mapping granularity %zd, is " PTR_FORMAT,
mapping_granularity_in_bytes, p2i(bottom));
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,
mapping_granularity_in_bytes, p2i(end)));
"end mapping area address must be a multiple of mapping granularity %zd, is " PTR_FORMAT,
mapping_granularity_in_bytes, p2i(end));
size_t num_target_elems = pointer_delta(end, bottom, mapping_granularity_in_bytes);
idx_t bias = (uintptr_t)bottom / mapping_granularity_in_bytes;
address base = create_new_base_array(num_target_elems, target_elem_size_in_bytes);

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

@ -69,14 +69,14 @@ bool G1BlockOffsetSharedArray::is_card_boundary(HeapWord* p) const {
#ifdef ASSERT
void G1BlockOffsetSharedArray::check_index(size_t index, const char* msg) const {
assert((index) < (_reserved.word_size() >> LogN_words),
err_msg("%s - index: " SIZE_FORMAT ", _vs.committed_size: " SIZE_FORMAT,
msg, (index), (_reserved.word_size() >> LogN_words)));
"%s - index: " SIZE_FORMAT ", _vs.committed_size: " SIZE_FORMAT,
msg, (index), (_reserved.word_size() >> LogN_words));
assert(G1CollectedHeap::heap()->is_in_exact(address_for_index_raw(index)),
err_msg("Index " SIZE_FORMAT " corresponding to " PTR_FORMAT
"Index " SIZE_FORMAT " corresponding to " PTR_FORMAT
" (%u) is not in committed area.",
(index),
p2i(address_for_index_raw(index)),
G1CollectedHeap::heap()->addr_to_region(address_for_index_raw(index))));
G1CollectedHeap::heap()->addr_to_region(address_for_index_raw(index)));
}
#endif // ASSERT
@ -192,27 +192,27 @@ void G1BlockOffsetArray::check_all_cards(size_t start_card, size_t end_card) con
u_char entry = _array->offset_array(c);
if (c - start_card > BlockOffsetArray::power_to_cards_back(1)) {
guarantee(entry > N_words,
err_msg("Should be in logarithmic region - "
"Should be in logarithmic region - "
"entry: %u, "
"_array->offset_array(c): %u, "
"N_words: %u",
(uint)entry, (uint)_array->offset_array(c), (uint)N_words));
(uint)entry, (uint)_array->offset_array(c), (uint)N_words);
}
size_t backskip = BlockOffsetArray::entry_to_cards_back(entry);
size_t landing_card = c - backskip;
guarantee(landing_card >= (start_card - 1), "Inv");
if (landing_card >= start_card) {
guarantee(_array->offset_array(landing_card) <= entry,
err_msg("Monotonicity - landing_card offset: %u, "
"Monotonicity - landing_card offset: %u, "
"entry: %u",
(uint)_array->offset_array(landing_card), (uint)entry));
(uint)_array->offset_array(landing_card), (uint)entry);
} else {
guarantee(landing_card == start_card - 1, "Tautology");
// Note that N_words is the maximum offset value
guarantee(_array->offset_array(landing_card) <= N_words,
err_msg("landing card offset: %u, "
"landing card offset: %u, "
"N_words: %u",
(uint)_array->offset_array(landing_card), (uint)N_words));
(uint)_array->offset_array(landing_card), (uint)N_words);
}
}
}
@ -271,9 +271,9 @@ G1BlockOffsetArray::forward_to_block_containing_addr_slow(HeapWord* q,
HeapWord* next_boundary = _array->address_for_index(n_index) +
(n_index == next_index ? 0 : N_words);
assert(next_boundary <= _array->_end,
err_msg("next_boundary is beyond the end of the covered region "
"next_boundary is beyond the end of the covered region "
" next_boundary " PTR_FORMAT " _array->_end " PTR_FORMAT,
p2i(next_boundary), p2i(_array->_end)));
p2i(next_boundary), p2i(_array->_end));
if (addr >= gsp()->top()) return gsp()->top();
while (next_boundary < addr) {
while (n <= next_boundary) {
@ -361,25 +361,23 @@ void G1BlockOffsetArray::alloc_block_work2(HeapWord** threshold_, size_t* index_
// is checked by an assertion above.
size_t start_index = _array->index_for(blk_start);
HeapWord* boundary = _array->address_for_index(start_index);
assert((_array->offset_array(orig_index) == 0 &&
blk_start == boundary) ||
(_array->offset_array(orig_index) > 0 &&
_array->offset_array(orig_index) <= N_words),
err_msg("offset array should have been set - "
assert((_array->offset_array(orig_index) == 0 && blk_start == boundary) ||
(_array->offset_array(orig_index) > 0 && _array->offset_array(orig_index) <= N_words),
"offset array should have been set - "
"orig_index offset: %u, "
"blk_start: " PTR_FORMAT ", "
"boundary: " PTR_FORMAT,
(uint)_array->offset_array(orig_index),
p2i(blk_start), p2i(boundary)));
p2i(blk_start), p2i(boundary));
for (size_t j = orig_index + 1; j <= end_index; j++) {
assert(_array->offset_array(j) > 0 &&
_array->offset_array(j) <=
(u_char) (N_words+BlockOffsetArray::N_powers-1),
err_msg("offset array should have been set - "
"offset array should have been set - "
"%u not > 0 OR %u not <= %u",
(uint) _array->offset_array(j),
(uint) _array->offset_array(j),
(uint) (N_words+BlockOffsetArray::N_powers-1)));
(uint) (N_words+BlockOffsetArray::N_powers-1));
}
#endif
}
@ -402,8 +400,8 @@ void G1BlockOffsetArray::verify() const {
size_t obj_size = block_size(obj);
obj_end = obj + obj_size;
guarantee(obj_end > obj && obj_end <= gsp()->top(),
err_msg("Invalid object end. obj: " PTR_FORMAT " obj_size: " SIZE_FORMAT " obj_end: " PTR_FORMAT " top: " PTR_FORMAT,
p2i(obj), obj_size, p2i(obj_end), p2i(gsp()->top())));
"Invalid object end. obj: " PTR_FORMAT " obj_size: " SIZE_FORMAT " obj_end: " PTR_FORMAT " top: " PTR_FORMAT,
p2i(obj), obj_size, p2i(obj_end), p2i(gsp()->top()));
}
} else {
// Because we refine the BOT based on which cards are dirty there is not much we can verify here.
@ -414,13 +412,13 @@ void G1BlockOffsetArray::verify() const {
size_t max_backskip = current_card - start_card;
guarantee(backskip <= max_backskip,
err_msg("Going backwards beyond the start_card. start_card: " SIZE_FORMAT " current_card: " SIZE_FORMAT " backskip: " SIZE_FORMAT,
start_card, current_card, backskip));
"Going backwards beyond the start_card. start_card: " SIZE_FORMAT " current_card: " SIZE_FORMAT " backskip: " SIZE_FORMAT,
start_card, current_card, backskip);
HeapWord* backskip_address = _array->address_for_index(current_card - backskip);
guarantee(backskip_address >= gsp()->bottom(),
err_msg("Going backwards beyond bottom of the region: bottom: " PTR_FORMAT ", backskip_address: " PTR_FORMAT,
p2i(gsp()->bottom()), p2i(backskip_address)));
"Going backwards beyond bottom of the region: bottom: " PTR_FORMAT ", backskip_address: " PTR_FORMAT,
p2i(gsp()->bottom()), p2i(backskip_address));
}
}
}

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

@ -80,8 +80,8 @@ public:
virtual void set_bottom(HeapWord* new_bottom) {
assert(new_bottom <= _end,
err_msg("new_bottom (" PTR_FORMAT ") > _end (" PTR_FORMAT ")",
p2i(new_bottom), p2i(_end)));
"new_bottom (" PTR_FORMAT ") > _end (" PTR_FORMAT ")",
p2i(new_bottom), p2i(_end));
_bottom = new_bottom;
resize(pointer_delta(_end, _bottom));
}
@ -149,9 +149,8 @@ private:
void check_offset(size_t offset, const char* msg) const {
assert(offset <= N_words,
err_msg("%s - "
"offset: " SIZE_FORMAT ", N_words: %u",
msg, offset, (uint)N_words));
"%s - offset: " SIZE_FORMAT ", N_words: %u",
msg, offset, (uint)N_words);
}
// Bounds checking accessors:

Some files were not shown because too many files have changed in this diff Show more