X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fhppa-arch.c;h=ba7550cbb3d6efb47884021f0ac91d2d646847f4;hb=4ba392170e98744f0ef0b8e08a5d42b988f1d0c9;hp=04af27b2451919f9df86dad7ceba96428a0a3a6c;hpb=79cc569a97e444389350ea3f5b1017374fe16bec;p=sbcl.git diff --git a/src/runtime/hppa-arch.c b/src/runtime/hppa-arch.c index 04af27b..ba7550c 100644 --- a/src/runtime/hppa-arch.c +++ b/src/runtime/hppa-arch.c @@ -23,18 +23,23 @@ #include "interrupt.h" #include "interr.h" #include "breakpoint.h" -#include "monitor.h" void arch_init(void) { return; } +static inline unsigned int +os_context_pc(os_context_t *context) +{ + return (unsigned int)(*os_context_pc_addr(context)); +} + os_vm_address_t arch_get_bad_addr(int signal, siginfo_t *siginfo, os_context_t *context) { - return siginfo->si_addr; + return (os_vm_address_t)siginfo->si_addr; #if 0 -#ifdef hpux +#ifdef LISP_FEATURE_HPUX struct save_state *state; os_vm_address_t addr; @@ -77,33 +82,66 @@ unsigned char *arch_internal_error_arguments(os_context_t *context) boolean arch_pseudo_atomic_atomic(os_context_t *context) { - return ((*os_context_register_addr(context,reg_ALLOC)) & 4); + /* FIXME: this foreign_function_call_active test is dubious at + * best. If a foreign call is made in a pseudo atomic section + * (?) or more likely a pseudo atomic section is in a foreign + * call then an interrupt is executed immediately. Maybe it + * has to do with C code not maintaining pseudo atomic + * properly. MG - 2005-08-10 + * + * The foreign_function_call_active used to live at each call-site + * to arch_pseudo_atomic_atomic, but this seems clearer. + * --NS 2007-05-15 */ + + // FIX-lav: use accessor macro instead + return (!foreign_function_call_active) && + *(&((ucontext_t *) context)->uc_mcontext.ss_wide.ss_64.ss_gr7) & 4; } void arch_set_pseudo_atomic_interrupted(os_context_t *context) { - *os_context_register_addr(context,reg_ALLOC) |= 1; + + *(&((ucontext_t *) context)->uc_mcontext.ss_wide.ss_64.ss_gr7) |= 1; +/* on hpux do we need to watch out for the barbarian ? */ +#ifdef LISP_FEATURE_HPUX + *((os_context_register_t *) &((ucontext_t *) context)->uc_mcontext.ss_flags) + |= SS_MODIFIEDWIDE; +#endif +} + +/* FIXME: untested */ +void arch_clear_pseudo_atomic_interrupted(os_context_t *context) +{ + *(&((ucontext_t *) context)->uc_mcontext.ss_wide.ss_64.ss_gr7) &= ~1; +#ifdef LISP_FEATURE_HPUX + *((os_context_register_t *) &((ucontext_t *) context)->uc_mcontext.ss_flags) + |= SS_MODIFIEDWIDE; +#endif } void arch_skip_instruction(os_context_t *context) { - ((char *) *os_context_pc_addr(context)) = ((char *) *os_context_npc_addr(context)); - ((char *) *os_context_npc_addr(context)) += 4; + *((unsigned int *) os_context_pc_addr(context)) = *((unsigned int *) os_context_npc_addr(context)); + *((unsigned int *) os_context_npc_addr(context)) += 4; +#ifdef LISP_FEATURE_HPUX + *((os_context_register_t *) &((ucontext_t *) context)->uc_mcontext.ss_flags) + |= SS_MODIFIEDWIDE; +#endif } -unsigned long arch_install_breakpoint(void *pc) +unsigned int arch_install_breakpoint(void *pc) { - unsigned long *ulpc = (unsigned long *)pc; - unsigned long orig_inst = *ulpc; + unsigned int *ulpc = (unsigned int *)pc; + unsigned int orig_inst = *ulpc; *ulpc = trap_Breakpoint; os_flush_icache((os_vm_address_t)pc, sizeof(*ulpc)); return orig_inst; } -void arch_remove_breakpoint(void *pc, unsigned long orig_inst) +void arch_remove_breakpoint(void *pc, unsigned int orig_inst) { - unsigned long *ulpc = (unsigned long *)pc; + unsigned int *ulpc = (unsigned int *)pc; *ulpc = orig_inst; os_flush_icache((os_vm_address_t)pc, sizeof(*ulpc)); @@ -111,20 +149,21 @@ void arch_remove_breakpoint(void *pc, unsigned long orig_inst) void arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) { + fprintf(stderr, "arch_do_displaced_inst() WARNING: stub.\n"); /* FIXME: Fill this in */ #if 0 -#ifdef hpux +#ifdef LISP_FEATURE_HPUX /* We change the next-pc to point to a breakpoint instruction, restore */ /* the original instruction, and exit. We would like to be able to */ /* sigreturn, but we can't, because this is hpux. */ - unsigned long *pc = (unsigned long *)(SC_PC(scp) & ~3); + unsigned int *pc = (unsigned int *)(SC_PC(scp) & ~3); NextPc = SC_NPC(scp); - SC_NPC(scp) = (unsigned)SingleStepTraps | (SC_NPC(scp)&3); + SC_NPC(scp) = (unsigned int)SingleStepTraps | (SC_NPC(scp)&3); BreakpointAddr = pc; *pc = orig_inst; - os_flush_icache((os_vm_address_t)pc, sizeof(unsigned long)); + os_flush_icache((os_vm_address_t)pc, sizeof(unsigned int)); #else /* We set the recovery counter to cover one instruction, put the */ /* original instruction back in, and then resume. We will then trap */ @@ -133,14 +172,15 @@ void arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) ((struct hp800_thread_state *)scp->sc_ap)->cr0 = 1; scp->sc_ps |= 0x10; - *(unsigned long *)SC_PC(scp) = orig_inst; + *(unsigned int *)SC_PC(scp) = orig_inst; sigreturn(scp); #endif #endif } -#ifdef hpux +#ifdef LISP_FEATURE_HPUX +#if 0 static void restore_breakpoint(struct sigcontext *scp) { /* We just single-stepped over an instruction that we want to replace */ @@ -148,12 +188,12 @@ static void restore_breakpoint(struct sigcontext *scp) /* state so that we will continue as if nothing happened. */ if (NextPc == NULL) - lose("SingleStepBreakpoint trap at strange time."); + lose("SingleStepBreakpoint trap at strange time.\n"); - if ((SC_PC(scp)&~3) == (unsigned long)SingleStepTraps) { + if ((SC_PC(scp)&~3) == (unsigned int)SingleStepTraps) { /* The next instruction was not nullified. */ SC_PC(scp) = NextPc; - if ((SC_NPC(scp)&~3) == (unsigned long)SingleStepTraps + 4) { + if ((SC_NPC(scp)&~3) == (unsigned int)SingleStepTraps + 4) { /* The instruction we just stepped over was not a branch, so */ /* we need to fix it up. If it was a branch, it will point to */ /* the correct place. */ @@ -170,88 +210,85 @@ static void restore_breakpoint(struct sigcontext *scp) if (BreakpointAddr) { *BreakpointAddr = trap_Breakpoint; os_flush_icache((os_vm_address_t)BreakpointAddr, - sizeof(unsigned long)); + sizeof(unsigned int)); BreakpointAddr = NULL; } } #endif - -static void sigtrap_handler(int signal, siginfo_t *siginfo, void *void_context) -{ - os_context_t *context = arch_os_get_context(&void_context); - unsigned long bad_inst; - -#if 0 - printf("sigtrap_handler, pc=0x%08x, alloc=0x%08x\n", scp->sc_pcoqh, - SC_REG(scp,reg_ALLOC)); #endif - bad_inst = *(unsigned long *)(*os_context_pc_addr(context) & ~3); - if (bad_inst & 0xfc001fe0) - interrupt_handle_now(signal, siginfo, context); - else { - int im5 = bad_inst & 0x1f; - switch (im5) { - case trap_Halt: - fake_foreign_function_call(context); - lose("%%primitive halt called; the party is over.\n"); - case trap_PendingInterrupt: - arch_skip_instruction(context); - interrupt_handle_pending(context); - break; +void +arch_handle_breakpoint(os_context_t *context) +{ + /*sigsetmask(scp->sc_mask); */ + handle_breakpoint(context); +} - case trap_Error: - case trap_Cerror: - interrupt_internal_error(signal, siginfo, context, im5==trap_Cerror); - break; +void +arch_handle_fun_end_breakpoint(os_context_t *context) +{ + /*sigsetmask(scp->sc_mask); */ + unsigned long pc; + pc = (unsigned long) + handle_fun_end_breakpoint(context); + *os_context_pc_addr(context) = pc; + *os_context_npc_addr(context) = pc + 4; + *((os_context_register_t *) &((ucontext_t *) context)->uc_mcontext.ss_flags) + |= SS_MODIFIEDWIDE; +} - case trap_Breakpoint: - /*sigsetmask(scp->sc_mask); */ - handle_breakpoint(signal, siginfo, context); - break; - case trap_FunEndBreakpoint: - /*sigsetmask(scp->sc_mask); */ - { - unsigned long pc; - pc = (unsigned long) - handle_fun_end_breakpoint(signal, siginfo, context); - *os_context_pc_addr(context) = pc; - *os_context_npc_addr(context) = pc + 4; - } - break; +//FIX-lav: this whole is copied from mips +void +arch_handle_single_step_trap(os_context_t *context, int trap) +{ + unsigned int code = *((u32 *)(os_context_pc(context))); + int register_offset = code >> 11 & 0x1f; + handle_single_step_trap(context, trap, register_offset); + arch_skip_instruction(context); +} - case trap_SingleStepBreakpoint: - /* Uh, FIXME */ -#ifdef hpux - restore_breakpoint(context); -#endif - break; +static void +sigtrap_handler(int signal, siginfo_t *siginfo, os_context_t *context) +{ + unsigned int bad_inst; - default: - interrupt_handle_now(signal, siginfo, context); - break; - } + bad_inst = *(unsigned int *)(*os_context_pc_addr(context) & ~3); + if (bad_inst & 0xfc001fe0) + interrupt_handle_now(signal, siginfo, context); + else { + int im5 = bad_inst & 0x1f; + handle_trap(context, im5); } } -static void sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context) +static void +sigill_handler(int signal, siginfo_t *siginfo, os_context_t *context) +{ + unsigned int bad_inst; + + bad_inst = *(unsigned int *)(*os_context_pc_addr(context) & ~3); + if (bad_inst == 9) { /* pending-interrupt */ + arch_clear_pseudo_atomic_interrupted(context); + arch_skip_instruction(context); + interrupt_handle_pending(context); + } else { + handle_trap(context,bad_inst); + } +} + +static void sigfpe_handler(int signal, siginfo_t *siginfo, + os_context_t *context) { - os_context_t *context = arch_os_get_context(&void_context); - unsigned long badinst; + unsigned int badinst; int opcode, r1, r2, t; long op1, op2, res; -#if 0 - printf("sigfpe_handler, pc=0x%08x, alloc=0x%08x\n", scp->sc_pcoqh, - SC_REG(scp,reg_ALLOC)); -#endif - switch (siginfo->si_code) { case FPE_INTOVF: /*I_OVFLO: */ - badinst = *(unsigned long *)(*os_context_pc_addr(context) & ~3); + badinst = *(unsigned int *)(*os_context_pc_addr(context) & ~3); opcode = badinst >> 26; if (opcode == 2) { @@ -281,7 +318,7 @@ static void sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context) /* Add or subtract immediate. */ op1 = ((badinst >> 3) & 0xff) | ((-badinst&1)<<8); r2 = (badinst >> 16) & 0x1f; - op2 = fixnum_value(*os_context_register_addr(context, r1)); + op2 = fixnum_value(*os_context_register_addr(context, r2)); t = (badinst >> 21) & 0x1f; if (opcode == 0x2d) res = op1 + op2; @@ -290,7 +327,6 @@ static void sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context) } else goto not_interesting; - /* ?? What happens here if we hit the end of dynamic space? */ dynamic_space_free_pointer = (lispobj *) *os_context_register_addr(context, reg_ALLOC); *os_context_register_addr(context, t) = alloc_number(res); @@ -299,15 +335,20 @@ static void sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context) arch_skip_instruction(context); break; - - case 0: /* I_COND: ?? Maybe tagged add?? FIXME */ - badinst = *(unsigned long *)(*os_context_pc_addr(context) & ~3); +//#ifdef LINUX +// case 0: +//#endif + case FPE_COND: + badinst = *(unsigned int *)(*os_context_pc_addr(context) & ~3); if ((badinst&0xfffff800) == (0xb000e000|reg_ALLOC<<21|reg_ALLOC<<16)) { - /* It is an ADDIT,OD i,ALLOC,ALLOC instruction that trapped. */ - /* That means that it is the end of a pseudo-atomic. So do the */ - /* add stripping off the pseudo-atomic-interrupted bit, and then */ - /* tell the machine-independent code to process the pseudo- */ - /* atomic. */ + /* It is an ADDIT,OD i,ALLOC,ALLOC instruction that trapped. + * That means that it is the end of a pseudo-atomic. So do the + * add stripping off the pseudo-atomic-interrupted bit, and then + * tell the machine-independent code to process the pseudo- + * atomic. We cant skip the instruction because it holds + * extra-bytes that we must add to reg_alloc in context. + * It is so because we optimized away 'addi ,extra-bytes reg_alloc' + */ int immed = (badinst>>1)&0x3ff; if (badinst & 1) immed |= -1<<10; @@ -330,14 +371,14 @@ static void sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context) the light of day. Since the instructions that we need to fix up tend not to be doing unaligned memory access, this should be a safe workaround. -- CSR, 2002-08-17 */ -static void sigbus_handler(int signal, siginfo_t *siginfo, void *void_context) +static void sigbus_handler(int signal, siginfo_t *siginfo, + os_context_t *context) { - os_context_t *context = arch_os_get_context(&void_context); - unsigned long badinst; + unsigned int badinst; int opcode, r1, r2, t; long op1, op2, res; - badinst = *(unsigned long *)(*os_context_pc_addr(context) & ~3); + badinst = *(unsigned int *)(*os_context_pc_addr(context) & ~3); /* First, test for the pseudo-atomic instruction */ if ((badinst & 0xfffff800) == (0xb000e000 | reg_ALLOC<<21 | @@ -382,7 +423,7 @@ static void sigbus_handler(int signal, siginfo_t *siginfo, void *void_context) /* Add or subtract immediate. */ op1 = ((badinst >> 3) & 0xff) | ((-badinst&1)<<8); r2 = (badinst >> 16) & 0x1f; - op2 = fixnum_value(*os_context_register_addr(context, r1)); + op2 = fixnum_value(*os_context_register_addr(context, r2)); t = (badinst >> 21) & 0x1f; if (opcode == 0x2d) res = op1 + op2; @@ -406,52 +447,22 @@ static void sigbus_handler(int signal, siginfo_t *siginfo, void *void_context) } } +static void +ignore_handler(int signal, siginfo_t *siginfo, os_context_t *context) +{ +} +/* this routine installs interrupt handlers that will + * bypass the lisp interrupt handlers */ void arch_install_interrupt_handlers(void) { undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler); + undoably_install_low_level_interrupt_handler(SIGILL,sigill_handler); undoably_install_low_level_interrupt_handler(SIGFPE,sigfpe_handler); /* FIXME: beyond 2.4.19-pa4 this shouldn't be necessary. */ undoably_install_low_level_interrupt_handler(SIGBUS,sigbus_handler); -} - - -lispobj funcall0(lispobj function) -{ - lispobj *args = current_control_stack_pointer; - - return call_into_lisp(function, args, 0); -} - -lispobj funcall1(lispobj function, lispobj arg0) -{ - lispobj *args = current_control_stack_pointer; - - current_control_stack_pointer += 1; - args[0] = arg0; - - return call_into_lisp(function, args, 1); -} - -lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1) -{ - lispobj *args = current_control_stack_pointer; - - current_control_stack_pointer += 2; - args[0] = arg0; - args[1] = arg1; - - return call_into_lisp(function, args, 2); -} - -lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2) -{ - lispobj *args = current_control_stack_pointer; - - current_control_stack_pointer += 3; - args[0] = arg0; - args[1] = arg1; - args[2] = arg2; - - return call_into_lisp(function, args, 3); +#ifdef LISP_FEATURE_HPUX + undoably_install_low_level_interrupt_handler(SIGXCPU,ignore_handler); + undoably_install_low_level_interrupt_handler(SIGXFSZ,ignore_handler); +#endif }