src/runtime/ppc-arch.c

   1 #include <stdio.h>
   2
   3 #include "arch.h"
   4 #include "sbcl.h"
   5 #include "globals.h"
   6 #include "validate.h"
   7 #include "os.h"
   8 #include "lispregs.h"
   9 #include "signal.h"
  10 #include "interrupt.h"
  11 #include "interr.h"
  12
  13   /* The header files may not define PT_DAR/PT_DSISR.  This definition
  14      is correct for all versions of ppc linux >= 2.0.30
  15
  16      As of DR2.1u4, MkLinux doesn't pass these registers to signal
  17      handlers correctly; a patch is necessary in order to (partially)
  18      correct this.
  19
  20      Even with the patch, the DSISR may not have its 'write' bit set
  21      correctly (it tends not to be set if the fault was caused by
  22      something other than a protection violation.)
  23
  24      Caveat callers.  */
  25
  26 #ifndef PT_DAR
  27 #define PT_DAR          41
  28 #endif
  29
  30 #ifndef PT_DSISR
  31 #define PT_DSISR        42
  32 #endif
  33
  34 void arch_init() {
  35 }
  36
  37 os_vm_address_t
  38 arch_get_bad_addr(int sig, siginfo_t *code, os_context_t *context)
  39 {
  40     unsigned int *pc =  (unsigned int *)(*os_context_pc_addr(context));
  41     os_vm_address_t addr;
  42
  43
  44     /* Make sure it's not the pc thats bogus, and that it was lisp code */
  45     /* that caused the fault. */
  46     if ((((unsigned long)pc) & 3) != 0 ||
  47         ((pc < READ_ONLY_SPACE_START ||
  48           pc >= READ_ONLY_SPACE_START+READ_ONLY_SPACE_SIZE) &&
  49          ((lispobj *)pc < current_dynamic_space ||
  50           (lispobj *)pc >= current_dynamic_space + DYNAMIC_SPACE_SIZE)))
  51         return 0;
  52
  53
  54     addr = (os_vm_address_t) (*os_context_register_addr(context,PT_DAR));
  55     return addr;
  56 }
  57
  58
  59 void
  60 arch_skip_instruction(os_context_t *context)
  61 {
  62     ((char*)*os_context_pc_addr(context)) +=4;
  63 }
  64
  65 unsigned char *
  66 arch_internal_error_arguments(os_context_t *context)
  67 {
  68     return (unsigned char *)(*os_context_pc_addr(context)+4);
  69 }
  70
  71
  72 boolean
  73 arch_pseudo_atomic_atomic(os_context_t *context)
  74 {
  75     return ((*os_context_register_addr(context,reg_ALLOC)) & 4);
  76 }
  77
  78 #define PSEUDO_ATOMIC_INTERRUPTED_BIAS 0x7f000000
  79
  80 void
  81 arch_set_pseudo_atomic_interrupted(os_context_t *context)
  82 {
  83     *os_context_register_addr(context,reg_NL3)
  84         += PSEUDO_ATOMIC_INTERRUPTED_BIAS;
  85 }
  86
  87 unsigned long
  88 arch_install_breakpoint(void *pc)
  89 {
  90     unsigned long *ptr = (unsigned long *)pc;
  91     unsigned long result = *ptr;
  92     *ptr = (3<<26) | (5 << 21) | trap_Breakpoint;
  93     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
  94     return result;
  95 }
  96
  97 void
  98 arch_remove_breakpoint(void *pc, unsigned long orig_inst)
  99 {
 100     *(unsigned long *)pc = orig_inst;
 101     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
 102 }
 103
 104 static unsigned long *skipped_break_addr, displaced_after_inst;
 105 static sigset_t orig_sigmask;
 106
 107 void
 108 arch_do_displaced_inst(os_context_t *context,unsigned int orig_inst)
 109 {
 110     /* not sure how we ensure that we get the breakpoint reinstalled
 111      * after doing this -dan */
 112     unsigned long *pc = (unsigned long *)(*os_context_pc_addr(context));
 113
 114     orig_sigmask = *os_context_sigmask_addr(context);
 115     sigaddset_blockable(os_context_sigmask_addr(context));
 116
 117     *pc = orig_inst;
 118     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
 119     skipped_break_addr = pc;
 120 }
 121
 122 static void
 123 sigtrap_handler(int signal, siginfo_t *siginfo, os_context_t *context)
 124 {
 125     u32 code;
 126     sigset_t *mask;
 127 #ifdef LISP_FEATURE_LINUX
 128     os_restore_fp_control(context);
 129 #endif
 130     mask=(os_context_sigmask_addr(context));
 131     sigsetmask(mask);
 132     code=*((u32 *)(*os_context_pc_addr(context)));
 133     if (code == ((3 << 26) | (16 << 21) | (reg_ALLOC << 16))) {
 134         /* twlti reg_ALLOC,0 - check for deferred interrupt */
 135         *os_context_register_addr(context,reg_ALLOC)
 136             -= PSEUDO_ATOMIC_INTERRUPTED_BIAS;
 137         arch_skip_instruction(context);
 138         /* interrupt or GC was requested in PA; now we're done with the
 139            PA section we may as well get around to it */
 140         interrupt_handle_pending(context);
 141         return;
 142
 143     }
 144     if ((code >> 16) == ((3 << 10) | (6 << 5))) {
 145         /* twllei reg_ZERO,N will always trap if reg_ZERO = 0 */
 146         int trap = code & 0x1f;
 147
 148         switch (trap) {
 149         case trap_Halt:
 150             fake_foreign_function_call(context);
 151             lose("%%primitive halt called; the party is over.\n");
 152
 153         case trap_Error:
 154         case trap_Cerror:
 155             interrupt_internal_error(signal, code, context, trap == trap_Cerror);
 156             break;
 157
 158         case trap_PendingInterrupt:
 159           /* when do we run this branch instead of the twlti code above? */
 160             arch_skip_instruction(context);
 161             interrupt_handle_pending(context);
 162             break;
 163
 164         case trap_Breakpoint:
 165             handle_breakpoint(signal, code, context);
 166             break;
 167
 168         case trap_FunEndBreakpoint:
 169             *os_context_pc_addr(context)
 170                 =(int)handle_fun_end_breakpoint(signal, code, context);
 171             break;
 172
 173         case trap_AfterBreakpoint:
 174             *skipped_break_addr = trap_Breakpoint;
 175             skipped_break_addr = NULL;
 176             *(unsigned long *)*os_context_pc_addr(context)
 177                 = displaced_after_inst;
 178             *os_context_sigmask_addr(context)= orig_sigmask;
 179
 180             os_flush_icache((os_vm_address_t) *os_context_pc_addr(context),
 181                             sizeof(unsigned long));
 182             break;
 183
 184         default:
 185             interrupt_handle_now(signal, code, context);
 186             break;
 187         }
 188     }
 189     if (((code >> 26) == 3) && (((code >> 21) & 31) == 24)) {
 190         interrupt_internal_error(signal, code, context, 0);
 191     }
 192
 193     interrupt_handle_now(signal, code, context);
 194 }
 195
 196
 197 void arch_install_interrupt_handlers()
 198 {
 199     undoably_install_low_level_interrupt_handler(SIGILL,sigtrap_handler);
 200     undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler);
 201 }
 202
 203
 204 extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
 205
 206 lispobj funcall0(lispobj function)
 207 {
 208     lispobj *args = current_control_stack_pointer;
 209
 210     return call_into_lisp(function, args, 0);
 211 }
 212
 213 lispobj funcall1(lispobj function, lispobj arg0)
 214 {
 215     lispobj *args = current_control_stack_pointer;
 216
 217     current_control_stack_pointer += 1;
 218     args[0] = arg0;
 219
 220     return call_into_lisp(function, args, 1);
 221 }
 222
 223 lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
 224 {
 225     lispobj *args = current_control_stack_pointer;
 226
 227     current_control_stack_pointer += 2;
 228     args[0] = arg0;
 229     args[1] = arg1;
 230
 231     return call_into_lisp(function, args, 2);
 232 }
 233
 234 lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
 235 {
 236     lispobj *args = current_control_stack_pointer;
 237
 238     current_control_stack_pointer += 3;
 239     args[0] = arg0;
 240     args[1] = arg1;
 241     args[2] = arg2;
 242
 243     return call_into_lisp(function, args, 3);
 244 }
 245
 246 void
 247 ppc_flush_icache(os_vm_address_t address, os_vm_size_t length)
 248 {
 249   os_vm_address_t end = (os_vm_address_t) ((int)(address+length+(32-1)) &~(32-1));
 250   extern void ppc_flush_cache_line(os_vm_address_t);
 251
 252   while (address < end) {
 253     ppc_flush_cache_line(address);
 254     address += 32;
 255   }
 256 }