Exemple #1
0
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();
  }
Exemple #3
0
//------------------------------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();
}
Exemple #5
0
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
}
Exemple #7
0
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();
}
Exemple #8
0
 address code_end() const                       { ShouldNotCallThis(); return NULL; }   // points to the first byte after the code
Exemple #9
0
 // Debugging
 void    verify()                               { ShouldNotCallThis(); }                // verifies the Stub
Exemple #10
0
 static  int code_size_to_size(int code_size)   { ShouldNotCallThis(); return 0; }      // computes the size given the code size
Exemple #11
0
 // Code info
 address code_begin() const                     { ShouldNotCallThis(); return NULL; }   // points to the first byte of    the code
int VtableStub::pd_code_alignment() {
  ShouldNotCallThis();
}
Exemple #13
0
 // 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; };
Exemple #15
0
address CppInterpreter::return_entry(TosState state, int length) {
  ShouldNotCallThis();
}
 void    finalize()                             { ShouldNotCallThis(); }
Exemple #17
0
 void do_object(oop obj) {
   ShouldNotCallThis();
 }
Exemple #18
0
const char* FloatRegisterImpl::name() const {
    ShouldNotCallThis();
}
 RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr,
                                       Register  tmp,
                                       int       offset) {
   ShouldNotCallThis();
 }
Exemple #20
0
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;
}
Exemple #21
0
 void    print()                                { ShouldNotCallThis(); }                // prints some information about the stub
void* StackObj::operator new(size_t size)  { ShouldNotCallThis(); return 0; };
Exemple #23
0
 ZeroEntry() {
   ShouldNotCallThis();
 }
VtableStub* VtableStubs::create_itable_stub(int vtable_index) {
  ShouldNotCallThis();
}
Exemple #25
0
 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(); };
Exemple #30
0
 // Initialization/finalization
 void    initialize(int size)                   { ShouldNotCallThis(); }                // called to initialize/specify the stub's size