bool CppInterpreter::contains(address pc) {
#ifdef PRODUCT
ShouldNotCallThis();
#else
return false; // make frame::print_value_on work
#endif // !PRODUCT
}
virtual void eval_constant(Compile* C) {
#ifdef ASSERT
tty->print("missing MachConstantNode eval_constant function: ");
dump();
#endif
ShouldNotCallThis();
}
//------------------------------emit-------------------------------------------
void MachNode::emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const {
#ifdef ASSERT
tty->print("missing MachNode emit function: ");
dump();
#endif
ShouldNotCallThis();
}
void MetaspaceShared::generate_vtable_methods(void** vtbl_list,
void** vtable,
char** md_top,
char* md_end,
char** mc_top,
char* mc_end) {
ShouldNotCallThis();
}
void test_error_handler(size_t test_num)
{
if (test_num == 0) return;
// If asserts are disabled, use the corresponding guarantee instead.
size_t n = test_num;
NOT_DEBUG(if (n <= 2) n += 2);
const char* const str = "hello";
const size_t num = (size_t)os::vm_page_size();
const char* const eol = os::line_separator();
const char* const msg = "this message should be truncated during formatting";
// Keep this in sync with test/runtime/6888954/vmerrors.sh.
switch (n) {
case 1:
assert(str == NULL, "expected null");
case 2:
assert(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 3:
guarantee(str == NULL, "expected null");
case 4:
guarantee(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 5:
fatal("expected null");
case 6:
fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 7:
fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s",
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg));
case 8:
vm_exit_out_of_memory(num, "ChunkPool::allocate");
case 9:
ShouldNotCallThis();
case 10:
ShouldNotReachHere();
case 11:
Unimplemented();
// This is last because it does not generate an hs_err* file on Windows.
case 12:
os::signal_raise(SIGSEGV);
default:
ShouldNotReachHere();
}
}
nmethod *SharedRuntime::generate_native_wrapper(MacroAssembler *masm,
methodHandle method,
int compile_id,
BasicType *sig_bt,
VMRegPair *regs,
BasicType ret_type) {
#ifdef SHARK
return SharkCompiler::compiler()->generate_native_wrapper(masm,
method,
compile_id,
sig_bt,
ret_type);
#else
ShouldNotCallThis();
#endif // SHARK
}
void controlled_crash(int how) {
if (how == 0) return;
// If asserts are disabled, use the corresponding guarantee instead.
NOT_DEBUG(if (how <= 2) how += 2);
const char* const str = "hello";
const size_t num = (size_t)os::vm_page_size();
const char* const eol = os::line_separator();
const char* const msg = "this message should be truncated during formatting";
char * const dataPtr = NULL; // bad data pointer
const void (*funcPtr)(void) = (const void(*)()) 0xF; // bad function pointer
// Keep this in sync with test/runtime/6888954/vmerrors.sh.
switch (how) {
case 1: vmassert(str == NULL, "expected null");
case 2: vmassert(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 3: guarantee(str == NULL, "expected null");
case 4: guarantee(num == 1023 && *str == 'X',
err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 5: fatal("expected null");
case 6: fatal(err_msg("num=" SIZE_FORMAT " str=\"%s\"", num, str));
case 7: fatal(err_msg("%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s%s# "
"%s%s# %s%s# %s%s# %s%s# %s",
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg, eol,
msg, eol, msg, eol, msg, eol, msg, eol, msg));
case 8: vm_exit_out_of_memory(num, OOM_MALLOC_ERROR, "ChunkPool::allocate");
case 9: ShouldNotCallThis();
case 10: ShouldNotReachHere();
case 11: Unimplemented();
// There's no guarantee the bad data pointer will crash us
// so "break" out to the ShouldNotReachHere().
case 12: *dataPtr = '\0'; break;
// There's no guarantee the bad function pointer will crash us
// so "break" out to the ShouldNotReachHere().
case 13: (*funcPtr)(); break;
case 14: crash_with_segfault(); break;
case 15: crash_with_sigfpe(); break;
default: tty->print_cr("ERROR: %d: unexpected test_num value.", how);
}
ShouldNotReachHere();
}
address code_end() const { ShouldNotCallThis(); return NULL; } // points to the first byte after the code
// Debugging
void verify() { ShouldNotCallThis(); } // verifies the Stub
static int code_size_to_size(int code_size) { ShouldNotCallThis(); return 0; } // computes the size given the code size
// Code info
address code_begin() const { ShouldNotCallThis(); return NULL; } // points to the first byte of the code
int VtableStub::pd_code_alignment() {
ShouldNotCallThis();
}
// General info/converters
int size() const { ShouldNotCallThis(); return 0; } // must return the size provided by initialize
void* _ValueObj::operator new(size_t size) { ShouldNotCallThis(); return 0; };
address CppInterpreter::return_entry(TosState state, int length) {
ShouldNotCallThis();
}
void finalize() { ShouldNotCallThis(); }
void do_object(oop obj) {
ShouldNotCallThis();
}
const char* FloatRegisterImpl::name() const {
ShouldNotCallThis();
}
RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr,
Register tmp,
int offset) {
ShouldNotCallThis();
}
oop Generation::par_promote(int thread_num,
oop obj, markOop m, size_t word_sz) {
// Could do a bad general impl here that gets a lock. But no.
ShouldNotCallThis();
return NULL;
}
void print() { ShouldNotCallThis(); } // prints some information about the stub
void* StackObj::operator new(size_t size) { ShouldNotCallThis(); return 0; };
ZeroEntry() {
ShouldNotCallThis();
}
VtableStub* VtableStubs::create_itable_stub(int vtable_index) {
ShouldNotCallThis();
}
void finalize() { ShouldNotCallThis(); } // called before the stub is deallocated
int VtableStub::pd_code_size_limit(bool is_vtable_stub) {
ShouldNotCallThis();
}
void StackObj::operator delete(void* p) { ShouldNotCallThis(); };
frame frame::sender_for_compiled_frame(RegisterMap *map) const {
ShouldNotCallThis();
return sender(map);
}
void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); };
// Initialization/finalization
void initialize(int size) { ShouldNotCallThis(); } // called to initialize/specify the stub's size