-/* src/vm/jit/x86_64/md.c - machine dependent x86_64 Linux functions
+/* src/vm/jit/s390/md.c - machine dependent s390 Linux functions
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 2006, 2007, 2008, 2010
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Christian Thalinger
-
- Changes: Edwin Steiner
-
- $Id: md.c 8097 2007-06-17 14:50:16Z pm $
-
*/
+
#define _GNU_SOURCE
#include "config.h"
#include <assert.h>
+#include <stdint.h>
#include <stdlib.h>
#include <ucontext.h>
#include "vm/jit/s390/md-abi.h"
-#if defined(ENABLE_THREADS)
-# include "threads/threads-common.h"
-# include "threads/native/threads.h"
-#endif
+#include "threads/thread.hpp"
+
+#include "vm/exceptions.hpp"
+#include "vm/signallocal.hpp"
-#include "vm/exceptions.h"
-#include "vm/signallocal.h"
-#include "vm/jit/asmpart.h"
+#include "vm/jit/abi.h"
+#include "vm/jit/executionstate.h"
#include "vm/jit/methodheader.h"
-#include "vm/jit/stacktrace.h"
+#include "vm/jit/methodtree.h"
+#include "vm/jit/stacktrace.hpp"
+#include "vm/jit/trap.hpp"
#if !defined(NDEBUG) && defined(ENABLE_DISASSEMBLER)
-#include "vmcore/options.h" /* XXX debug */
-#include "vm/jit/disass.h" /* XXX debug */
+#include "vm/options.h" /* XXX debug */
#endif
-#include "vm/jit/codegen-common.h"
+#include "vm/jit/codegen-common.hpp"
#include "vm/jit/s390/codegen.h"
+#include "vm/jit/s390/md.h"
-#include <assert.h>
-#define OOPS() assert(0);
/* prototypes *****************************************************************/
+u1 *exceptions_handle_exception(java_object_t *xptro, u1 *xpc, u1 *pv, u1 *sp);
+
void md_signal_handler_sigill(int sig, siginfo_t *siginfo, void *_p);
void md_dump_context(u1 *pc, mcontext_t *mc);
int i;
u1 *pv;
methodinfo *m;
-
+
union {
u8 l;
fpreg_t fr;
log_println("Program counter: 0x%08X", pc);
- pv = codegen_get_pv_from_pc_nocheck(pc);
+ pv = methodtree_find_nocheck(pc);
+
if (pv == NULL) {
log_println("No java method found at location.");
} else {
- m = ((codeinfo *)(pv + CodeinfoPointer))->m;
+ m = (*(codeinfo **)(pv + CodeinfoPointer))->m;
log_println(
"Java method: class %s, method %s, descriptor %s.",
- utf_bytes(m->class->name), utf_bytes(m->name), utf_bytes(m->descriptor)
+ m->clazz->name->text, m->name->text, m->descriptor->text
);
}
log_println("\tf%d\t0x%016llX\t(double)%e\t(float)%f", i, freg.l, freg.fr.d, freg.fr.f);
}
-#if defined(ENABLE_THREADS)
log_println("Dumping the current stacktrace:");
- threads_print_stacktrace();
-#endif
-
+ stacktrace_print_current();
}
-/* md_signal_handler_sigsegv ***************************************************
-
- NullPointerException signal handler for hardware null pointer
- check.
-
-*******************************************************************************/
-
+/**
+ * NullPointerException signal handler for hardware null pointer check.
+ */
void md_signal_handler_sigsegv(int sig, siginfo_t *siginfo, void *_p)
{
- ucontext_t *_uc;
- mcontext_t *_mc;
- u1 *pv;
- u1 *sp;
- u1 *ra;
- u1 *xpc;
- s4 type;
- ptrint val;
- java_objectheader *e;
- s4 base;
- s4 is_null;
-
- _uc = (ucontext_t *) _p;
- _mc = &_uc->uc_mcontext;
-
- xpc = (u1 *)_mc->psw.addr;
-
- /* Check opcodes and verify it is a null pointer exception */
-
- switch (xpc[0]) {
- case 0x58: /* L */
- case 0x50: /* ST */
- base = (xpc[2] >> 4) & 0xF;
- if (base == 0) {
- is_null = 1;
- } else if (_mc->gregs[base] == 0) {
- is_null = 1;
- } else {
- is_null = 0;
- }
- break;
- }
+ ucontext_t* _uc = (ucontext_t *) _p;
+ mcontext_t* _mc = &_uc->uc_mcontext;
- if (! is_null) {
-#if !defined(NDEBUG)
- md_dump_context(xpc, _mc);
-#endif
- vm_abort("%s: segmentation fault at %p, aborting.", __FUNCTION__, xpc);
- }
+ void* xpc = (u1 *) _mc->psw.addr;
- pv = (u1 *)_mc->gregs[REG_PV] - N_PV_OFFSET;
- sp = (u1 *)_mc->gregs[REG_SP];
- ra = xpc;
- type = EXCEPTION_HARDWARE_NULLPOINTER;
- val = 0;
-
- e = exceptions_new_hardware_exception(pv, sp, ra, xpc, type, val);
-
- _mc->gregs[REG_ITMP2_XPC] = (ptrint) xpc;
- _mc->gregs[REG_ITMP1_XPTR] = (ptrint) e;
- _mc->psw.addr = (ptrint) asm_handle_exception;
+ // Handle the trap.
+ trap_handle(TRAP_SIGSEGV, xpc, _p);
}
-void md_signal_handler_sigill(int sig, siginfo_t *siginfo, void *_p) {
- ucontext_t *_uc;
- mcontext_t *_mc;
- u1 *xpc;
- u1 *ra;
- u1 *pv;
- u1 *sp;
- s4 type;
- ptrint val;
- java_objectheader *e;
- s4 reg;
-
- _uc = (ucontext_t *) _p;
- _mc = &_uc->uc_mcontext;
- xpc = ra = siginfo->si_addr;
-
- /* Our trap instruction has the format: { 0x02, one_byte_of_data }. */
-
- if ((siginfo->si_code == ILL_ILLOPC) && (xpc[0] == 0x02)) {
-
- /* bits 7-4 contain a register holding a value */
- reg = (xpc[1] >> 4) & 0xF;
-
- /* bits 3-0 designate the exception type */
- type = xpc[1] & 0xF;
-
- pv = (u1 *)_mc->gregs[REG_PV] - N_PV_OFFSET;
- sp = (u1 *)_mc->gregs[REG_SP];
- val = (ptrint)_mc->gregs[reg];
-
- e = exceptions_new_hardware_exception(pv, sp, ra, xpc, type, val);
+/**
+ * Illegal Instruction signal handler for hardware exception checks.
+ */
+void md_signal_handler_sigill(int sig, siginfo_t *siginfo, void *_p)
+{
+ ucontext_t* _uc = (ucontext_t *) _p;
+ mcontext_t* _mc = &_uc->uc_mcontext;
- _mc->gregs[REG_ITMP1_XPTR] = (ptrint)e;
- _mc->gregs[REG_ITMP2_XPC] = (ptrint)xpc;
- _mc->psw.addr = (ptrint) asm_handle_exception;
+ void* xpc = siginfo->si_addr;
- } else {
-#if !defined(NDEBUG)
- md_dump_context(xpc, _mc);
-#endif
- vm_abort("%s: illegal instruction at %p, aborting.", __FUNCTION__, xpc);
- }
+ // Handle the trap.
+ trap_handle(TRAP_SIGILL, xpc, _p);
}
/* md_signal_handler_sigfpe ****************************************************
void md_signal_handler_sigfpe(int sig, siginfo_t *siginfo, void *_p)
{
- ucontext_t *_uc;
- mcontext_t *_mc;
- u1 *pv;
- u1 *sp;
- u1 *ra;
- u1 *xpc;
- u1 *pc;
- s4 r1, r2;
- s4 type;
- ptrint val;
- java_objectheader *e;
-
- _uc = (ucontext_t *) _p;
- _mc = &_uc->uc_mcontext;
+ ucontext_t* _uc = (ucontext_t *) _p;
+ mcontext_t* _mc = &_uc->uc_mcontext;
- /* Instruction that raised signal */
- xpc = siginfo->si_addr;
+ void* xpc = siginfo->si_addr;
- /* Check opcodes */
+ if (N_RR_GET_OPC(xpc) == OPC_DR) { /* DR */
- if (xpc[0] == 0x1D) { /* DR */
-
- r1 = (xpc[1] >> 4) & 0xF;
- r2 = xpc[1] & 0xF;
+ int r1 = N_RR_GET_REG1(xpc);
+ int r2 = N_RR_GET_REG2(xpc);
if (
(_mc->gregs[r1] == 0xFFFFFFFF) &&
(_mc->gregs[r1 + 1] == 0x80000000) &&
(_mc->gregs[r2] == 0xFFFFFFFF)
) {
- /* handle special case */
+ /* handle special case 0x80000000 / 0xFFFFFFFF that fails on hardware */
/* next instruction */
- pc = (u1 *)_mc->psw.addr;
- /* reminder */
+ u1 *pc = (u1 *)_mc->psw.addr;
+ /* remainder */
_mc->gregs[r1] = 0;
/* quotient */
_mc->gregs[r1 + 1] = 0x80000000;
/* continue at next instruction */
_mc->psw.addr = (ptrint) pc;
- return;
- } else if (_mc->gregs[r2] == 0) {
- /* division by 0 */
-
- pv = (u1 *)_mc->gregs[REG_PV] - N_PV_OFFSET;
- sp = (u1 *)_mc->gregs[REG_SP];
- ra = xpc;
-
- type = EXCEPTION_HARDWARE_ARITHMETIC;
- val = 0;
-
- e = exceptions_new_hardware_exception(pv, sp, ra, xpc, type, val);
-
- _mc->gregs[REG_ITMP1_XPTR] = (ptrint)e;
- _mc->gregs[REG_ITMP2_XPC] = (ptrint)xpc;
- _mc->psw.addr = (ptrint) asm_handle_exception;
-
return;
}
}
- /* Could not handle signal */
-
-#if !defined(NDEBUG)
- md_dump_context(xpc, _mc);
-#endif
- vm_abort("%s: floating point exception at %p, aborting.", __FUNCTION__, xpc);
+ // Handle the trap.
+ trap_handle(TRAP_SIGFPE, xpc, _p);
}
#endif
-#if defined(ENABLE_THREADS)
-void md_critical_section_restart(ucontext_t *_uc)
+/**
+ * Read the given context into an executionstate.
+ *
+ * @param es execution state
+ * @param context machine context
+ */
+void md_executionstate_read(executionstate_t* es, void* context)
{
+ ucontext_t *_uc;
mcontext_t *_mc;
- u1 *pc;
- void *npc;
+ int i;
+ _uc = (ucontext_t *) context;
_mc = &_uc->uc_mcontext;
- pc = (u1 *)_mc->psw.addr;
-
- npc = critical_find_restart_point(pc);
-
- if (npc != NULL) {
- log_println("%s: pc=%p, npc=%p", __FUNCTION__, pc, npc);
- _mc->psw.addr = (ptrint) npc;
- }
-}
-#endif
-
-
-/* md_codegen_patch_branch *****************************************************
-
- Back-patches a branch instruction.
-
-*******************************************************************************/
-
-void md_codegen_patch_branch(codegendata *cd, s4 branchmpc, s4 targetmpc)
-{
-
- s4 *mcodeptr;
- s4 disp; /* branch displacement */
-
- /* calculate the patch position */
-
- mcodeptr = (s4 *) (cd->mcodebase + branchmpc);
-
- /* Calculate the branch displacement. */
+ /* read special registers */
+ es->pc = (u1 *) _mc->psw.addr;
+ es->sp = (u1 *) _mc->gregs[REG_SP];
+ es->pv = (u1 *) _mc->gregs[REG_PV] - N_PV_OFFSET;
+ es->ra = (u1 *) _mc->gregs[REG_RA];
- disp = targetmpc - branchmpc;
- disp += 4; /* size of branch */
- disp /= 2; /* specified in halfwords */
+ /* read integer registers */
+ for (i = 0; i < INT_REG_CNT; i++)
+ es->intregs[i] = _mc->gregs[i];
- ASSERT_VALID_BRANCH(disp);
+ /* read float registers */
+ /* Do not use the assignment operator '=', as the type of
+ * the _mc->sc_fpregs[i] can cause invalid conversions. */
- /* patch the branch instruction before the mcodeptr */
-
- mcodeptr[-1] |= (disp & 0xFFFF);
+ assert(sizeof(_mc->fpregs.fprs) == sizeof(es->fltregs));
+ os_memcpy(&es->fltregs, &_mc->fpregs.fprs, sizeof(_mc->fpregs.fprs));
}
-/* md_stacktrace_get_returnaddress *********************************************
-
- Returns the return address of the current stackframe, specified by
- the passed stack pointer and the stack frame size.
+/**
+ * Write the given executionstate back to the context.
+ *
+ * @param es execution state
+ * @param context machine context
+ */
+void md_executionstate_write(executionstate_t* es, void* context)
+{
+ ucontext_t *_uc;
+ mcontext_t *_mc;
+ int i;
-*******************************************************************************/
+ _uc = (ucontext_t *) context;
+ _mc = &_uc->uc_mcontext;
-u1 *md_stacktrace_get_returnaddress(u1 *sp, u4 framesize)
-{
- u1 *ra;
+ /* write integer registers */
+ for (i = 0; i < INT_REG_CNT; i++)
+ _mc->gregs[i] = es->intregs[i];
- /* on S390 the return address is located on the top of the stackframe */
+ /* write float registers */
+ /* Do not use the assignment operator '=', as the type of
+ * the _mc->sc_fpregs[i] can cause invalid conversions. */
- ra = *((u1 **) (sp + framesize - SIZEOF_VOID_P));
+ assert(sizeof(_mc->fpregs.fprs) == sizeof(es->fltregs));
+ os_memcpy(&_mc->fpregs.fprs, &es->fltregs, sizeof(_mc->fpregs.fprs));
- return ra;
+ /* write special registers */
+ _mc->psw.addr = (ptrint) es->pc;
+ _mc->gregs[REG_SP] = (ptrint) es->sp;
+ _mc->gregs[REG_PV] = (ptrint) es->pv + N_PV_OFFSET;
+ _mc->gregs[REG_RA] = (ptrint) es->ra;
}
-/* md_get_method_patch_address *************************************************
+/* md_jit_method_patch_address *************************************************
Gets the patch address of the currently compiled method. The offset
is extracted from the load instruction(s) before the jump and added
*******************************************************************************/
-u1 *md_get_method_patch_address(u1 *ra, stackframeinfo *sfi, u1 *mptr)
+void *md_jit_method_patch_address(void* pv, void *ra, void *mptr)
{
- u1 base, index;
- s4 offset;
- u1 *pa; /* patch address */
+ uint8_t *pc;
+ uint8_t base, index;
+ int32_t offset;
+ void *pa; /* patch address */
/* go back to the load before the call instruction */
- ra = ra - 2 /* sizeof bcr */ - 4 /* sizeof l */;
+ pc = ((uint8_t *) ra) - SZ_BCR - SZ_L;
/* get the base register of the load */
- base = ra[2] >> 4;
- index = ra[1] & 0xF;
+ base = N_RX_GET_BASE(pc);
+ index = N_RX_GET_INDEX(pc);
/* check for the different calls */
switch (base) {
- case 0xd:
+ case REG_PV:
/* INVOKESTATIC/SPECIAL */
-
switch (index) {
- case 0x0:
+ case R0:
/* the offset is in the load instruction */
- offset = ((*(u2 *)(ra + 2)) & 0xFFF) + N_PV_OFFSET;
+ offset = N_RX_GET_DISP(pc) + N_PV_OFFSET;
break;
- case 0x1:
+ case REG_ITMP1:
/* the offset is in the immediate load before the load */
- offset = *((s2 *) (ra - 2));
+ offset = N_RI_GET_IMM(pc - SZ_L);
break;
default:
assert(0);
/* add the offset to the procedure vector */
- pa = sfi->pv + offset;
-
+ pa = ((uint8_t *) pv) + offset;
break;
- case 0xc:
+ case REG_METHODPTR:
/* mptr relative */
/* INVOKEVIRTUAL/INTERFACE */
- offset = *((u2 *)(ra + 2)) & 0xFFF;
+ offset = N_RX_GET_DISP(pc);
+
+ /* return NULL if no mptr was specified (used for replacement) */
+
+ if (mptr == NULL)
+ return NULL;
/* add offset to method pointer */
- pa = mptr + offset;
+ pa = (uint8_t *)mptr + offset;
break;
+
default:
/* catch any problems */
- assert(0);
+ vm_abort("md_jit_method_patch_address");
break;
}
}
-/* md_codegen_get_pv_from_pc ***************************************************
+/**
+ * Decode the trap instruction at the given PC.
+ *
+ * @param trp information about trap to be filled
+ * @param sig signal number
+ * @param xpc exception PC
+ * @param es execution state of the machine
+ * @return true if trap was decoded successfully, false otherwise.
+ */
+bool md_trap_decode(trapinfo_t* trp, int sig, void* xpc, executionstate_t* es)
+{
+ switch (sig) {
+ case TRAP_SIGILL:
+ if (N_RR_GET_OPC(xpc) == OPC_ILL) {
+ int32_t reg = N_ILL_GET_REG(xpc);
+ trp->type = N_ILL_GET_TYPE(xpc);
+ trp->value = es->intregs[reg];
+ return true;
+ }
+ return false;
- On this architecture just a wrapper function to
- codegen_get_pv_from_pc.
+ case TRAP_SIGSEGV:
+ {
+ int is_null;
+ int32_t base;
+ switch (N_RX_GET_OPC(xpc)) {
+ case OPC_L:
+ case OPC_ST:
+ case OPC_CL: /* array size check on NULL array */
+ base = N_RX_GET_BASE(xpc);
+ if (base == 0) {
+ is_null = 1;
+ } else if (es->intregs[base] == 0) {
+ is_null = 1;
+ } else {
+ is_null = 0;
+ }
+ break;
+ default:
+ is_null = 0;
+ break;
+ }
-*******************************************************************************/
+ // Check for implicit NullPointerException.
+ if (is_null) {
+ trp->type = TRAP_NullPointerException;
+ trp->value = 0;
+ return true;
+ }
-u1 *md_codegen_get_pv_from_pc(u1 *ra)
-{
- u1 *pv;
+ return false;
+ }
- /* Get the start address of the function which contains this
- address from the method table. */
+ case TRAP_SIGFPE:
+ {
+ if (N_RR_GET_OPC(xpc) == OPC_DR) {
+ int r2 = N_RR_GET_REG2(xpc);
+ if (es->intregs[r2] == 0) {
+ trp->type = TRAP_ArithmeticException;
+ trp->value = 0;
+ return true;
+ }
+ }
- pv = codegen_get_pv_from_pc(ra);
+ return false;
+ }
- return pv;
+ default:
+ return false;
+ }
}
-/* md_cacheflush ***************************************************************
- Calls the system's function to flush the instruction and data
- cache.
+/* md_patch_replacement_point **************************************************
-*******************************************************************************/
+ Patch the given replacement point.
-void md_cacheflush(u1 *addr, s4 nbytes)
+*******************************************************************************/
+#if defined(ENABLE_REPLACEMENT)
+void md_patch_replacement_point(u1 *pc, u1 *savedmcode, bool revert)
{
- /* do nothing */
+ assert(0);
}
+#endif
+void md_handle_exception(int32_t *regs, int64_t *fregs, int32_t *out) {
+
+ uint8_t *xptr;
+ uint8_t *xpc;
+ uint8_t *sp;
+ uint8_t *pv;
+ uint8_t *ra;
+ uint8_t *handler;
+ int32_t framesize;
+ int32_t intsave;
+ int32_t fltsave;
+ int64_t *savearea;
+ int i;
+ int reg;
+ int loops = 0;
-/* md_icacheflush **************************************************************
+ /* get registers */
- Calls the system's function to flush the instruction cache.
+ xptr = *(uint8_t **)(regs + REG_ITMP1_XPTR);
+ xpc = *(uint8_t **)(regs + REG_ITMP2_XPC);
+ sp = *(uint8_t **)(regs + REG_SP);
-*******************************************************************************/
-void md_icacheflush(u1 *addr, s4 nbytes)
-{
- /* do nothing */
-}
+ /* initialize number of calle saved int regs to restore to 0 */
+ out[0] = 0;
+ /* initialize number of calle saved flt regs to restore to 0 */
+ out[1] = 0;
-/* md_dcacheflush **************************************************************
+ do {
- Calls the system's function to flush the data cache.
+ ++loops;
-*******************************************************************************/
+ pv = methodtree_find(xpc);
-void md_dcacheflush(u1 *addr, s4 nbytes)
-{
- /* do nothing */
-}
+ handler = exceptions_handle_exception((java_object_t *)xptr, xpc, pv, sp);
+ if (handler == NULL) {
-/* md_patch_replacement_point **************************************************
+ /* exception was not handled
+ * get values of calee saved registers and remove stack frame
+ */
- Patch the given replacement point.
+ /* read stuff from data segment */
-*******************************************************************************/
-#if 0
-void md_patch_replacement_point(rplpoint *rp)
-{
- u8 mcode;
+ framesize = *(int32_t *)(pv + FrameSize);
- /* XXX this is probably unsafe! */
+ intsave = *(int32_t *)(pv + IntSave);
+ if (intsave > out[0]) {
+ out[0] = intsave;
+ }
- /* save the current machine code */
- mcode = *(u8*)rp->pc;
+ fltsave = *(int32_t *)(pv + FltSave);
+ if (fltsave > out[1]) {
+ out[1] = fltsave;
+ }
- /* write spinning instruction */
- *(u2*)(rp->pc) = 0xebfe;
+ /* pointer to register save area */
- /* write 5th byte */
- rp->pc[4] = (rp->mcode >> 32);
+ savearea = (int64_t *)(sp + framesize - 8);
- /* write first word */
- *(u4*)(rp->pc) = (u4) rp->mcode;
+ /* return address */
- /* store saved mcode */
- rp->mcode = mcode;
-
-#if !defined(NDEBUG) && defined(ENABLE_DISASSEMBLER)
- {
- u1* u1ptr = rp->pc;
- DISASSINSTR(u1ptr);
- fflush(stdout);
- }
-#endif
-
- /* XXX if required asm_cacheflush(rp->pc,8); */
+ ra = *(uint8_t **)(sp + framesize - 8);
+
+ /* restore saved registers */
+
+ for (i = 0; i < intsave; ++i) {
+ --savearea;
+ reg = abi_registers_integer_saved[INT_SAV_CNT - 1 - i];
+ regs[reg] = *(int32_t *)(savearea);
+ }
+
+ for (i = 0; i < fltsave; ++i) {
+ --savearea;
+ reg = abi_registers_float_saved[FLT_SAV_CNT - 1 - i];
+ fregs[reg] = *savearea;
+ }
+
+ /* remove stack frame */
+
+ sp += framesize;
+
+ /* new xpc is call before return address */
+
+ xpc = ra - 2;
+
+ } else {
+ xpc = handler;
+ }
+ } while (handler == NULL);
+
+ /* write new values for registers */
+
+ *(uint8_t **)(regs + REG_ITMP1_XPTR) = xptr;
+ *(uint8_t **)(regs + REG_ITMP2_XPC) = xpc;
+ *(uint8_t **)(regs + REG_SP) = sp;
+ *(uint8_t **)(regs + REG_PV) = pv - 0XFFC;
+
+ /* maybe leaf flag */
+
+ out[2] = (loops == 1);
}
-#endif
+
/*
* These are local overrides for various environment variables in Emacs.
* Please do not remove this and leave it at the end of the file, where
projects / cacao.git / blobdiff