src/runtime/ppc-arch.c

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