src/runtime/ppc-arch.c

   1 #include <stdio.h>
   2
   3 #include "sbcl.h"
   4 #include "arch.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** pcptr;
  63     pcptr = (char**) os_context_pc_addr(context);
  64     *pcptr += 4;
  65 }
  66
  67 unsigned char *
  68 arch_internal_error_arguments(os_context_t *context)
  69 {
  70     return (unsigned char *)(*os_context_pc_addr(context)+4);
  71 }
  72
  73
  74 boolean
  75 arch_pseudo_atomic_atomic(os_context_t *context)
  76 {
  77     return ((*os_context_register_addr(context,reg_ALLOC)) & 4);
  78 }
  79
  80 #define PSEUDO_ATOMIC_INTERRUPTED_BIAS 0x7f000000
  81
  82 void
  83 arch_set_pseudo_atomic_interrupted(os_context_t *context)
  84 {
  85     *os_context_register_addr(context,reg_NL3)
  86         += PSEUDO_ATOMIC_INTERRUPTED_BIAS;
  87 }
  88
  89 unsigned long
  90 arch_install_breakpoint(void *pc)
  91 {
  92     unsigned long *ptr = (unsigned long *)pc;
  93     unsigned long result = *ptr;
  94     *ptr = (3<<26) | (5 << 21) | trap_Breakpoint;
  95     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
  96     return result;
  97 }
  98
  99 void
 100 arch_remove_breakpoint(void *pc, unsigned long orig_inst)
 101 {
 102     *(unsigned long *)pc = orig_inst;
 103     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
 104 }
 105
 106 static unsigned long *skipped_break_addr, displaced_after_inst;
 107 static sigset_t orig_sigmask;
 108
 109 void
 110 arch_do_displaced_inst(os_context_t *context,unsigned int orig_inst)
 111 {
 112     /* not sure how we ensure that we get the breakpoint reinstalled
 113      * after doing this -dan */
 114     unsigned long *pc = (unsigned long *)(*os_context_pc_addr(context));
 115
 116     orig_sigmask = *os_context_sigmask_addr(context);
 117     sigaddset_blockable(os_context_sigmask_addr(context));
 118
 119     *pc = orig_inst;
 120     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned long));
 121     skipped_break_addr = pc;
 122 }
 123
 124 static void
 125 sigtrap_handler(int signal, siginfo_t *siginfo, os_context_t *context)
 126 {
 127     u32 code;
 128     sigset_t *mask;
 129 #ifdef LISP_FEATURE_LINUX
 130     os_restore_fp_control(context);
 131 #endif
 132     mask=(os_context_sigmask_addr(context));
 133     sigsetmask(mask);
 134     code=*((u32 *)(*os_context_pc_addr(context)));
 135     if (code == ((3 << 26) | (16 << 21) | (reg_ALLOC << 16))) {
 136         /* twlti reg_ALLOC,0 - check for deferred interrupt */
 137         *os_context_register_addr(context,reg_ALLOC)
 138             -= PSEUDO_ATOMIC_INTERRUPTED_BIAS;
 139         arch_skip_instruction(context);
 140         /* interrupt or GC was requested in PA; now we're done with the
 141            PA section we may as well get around to it */
 142         interrupt_handle_pending(context);
 143         return;
 144
 145     }
 146     if ((code >> 16) == ((3 << 10) | (6 << 5))) {
 147         /* twllei reg_ZERO,N will always trap if reg_ZERO = 0 */
 148         int trap = code & 0x1f;
 149
 150         switch (trap) {
 151         case trap_Halt:
 152             fake_foreign_function_call(context);
 153             lose("%%primitive halt called; the party is over.\n");
 154
 155         case trap_Error:
 156         case trap_Cerror:
 157             interrupt_internal_error(signal, code, context, trap == trap_Cerror);
 158             break;
 159
 160         case trap_PendingInterrupt:
 161           /* when do we run this branch instead of the twlti code above? */
 162             arch_skip_instruction(context);
 163             interrupt_handle_pending(context);
 164             break;
 165
 166         case trap_Breakpoint:
 167             handle_breakpoint(signal, code, context);
 168             break;
 169
 170         case trap_FunEndBreakpoint:
 171             *os_context_pc_addr(context)
 172                 =(int)handle_fun_end_breakpoint(signal, code, context);
 173             break;
 174
 175         case trap_AfterBreakpoint:
 176             *skipped_break_addr = trap_Breakpoint;
 177             skipped_break_addr = NULL;
 178             *(unsigned long *)*os_context_pc_addr(context)
 179                 = displaced_after_inst;
 180             *os_context_sigmask_addr(context)= orig_sigmask;
 181
 182             os_flush_icache((os_vm_address_t) *os_context_pc_addr(context),
 183                             sizeof(unsigned long));
 184             break;
 185
 186         default:
 187             interrupt_handle_now(signal, code, context);
 188             break;
 189         }
 190 #ifdef LISP_FEATURE_DARWIN
 191         DARWIN_FIX_CONTEXT(context);
 192 #endif
 193         return;
 194     }
 195     if (((code >> 26) == 3) && (((code >> 21) & 31) == 24)) {
 196         interrupt_internal_error(signal, code, context, 0);
 197 #ifdef LISP_FEATURE_DARWIN
 198         DARWIN_FIX_CONTEXT(context);
 199 #endif
 200         return;
 201     }
 202
 203     interrupt_handle_now(signal, code, context);
 204 #ifdef LISP_FEATURE_DARWIN
 205     /* Work around G5 bug */
 206     DARWIN_FIX_CONTEXT(context);
 207 #endif
 208 }
 209
 210
 211 void arch_install_interrupt_handlers()
 212 {
 213     undoably_install_low_level_interrupt_handler(SIGILL,sigtrap_handler);
 214     undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler);
 215 }
 216
 217
 218 extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
 219
 220 lispobj funcall0(lispobj function)
 221 {
 222     lispobj *args = current_control_stack_pointer;
 223
 224     return call_into_lisp(function, args, 0);
 225 }
 226
 227 lispobj funcall1(lispobj function, lispobj arg0)
 228 {
 229     lispobj *args = current_control_stack_pointer;
 230
 231     current_control_stack_pointer += 1;
 232     args[0] = arg0;
 233
 234     return call_into_lisp(function, args, 1);
 235 }
 236
 237 lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
 238 {
 239     lispobj *args = current_control_stack_pointer;
 240
 241     current_control_stack_pointer += 2;
 242     args[0] = arg0;
 243     args[1] = arg1;
 244
 245     return call_into_lisp(function, args, 2);
 246 }
 247
 248 lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
 249 {
 250     lispobj *args = current_control_stack_pointer;
 251
 252     current_control_stack_pointer += 3;
 253     args[0] = arg0;
 254     args[1] = arg1;
 255     args[2] = arg2;
 256
 257     return call_into_lisp(function, args, 3);
 258 }
 259
 260 void
 261 ppc_flush_icache(os_vm_address_t address, os_vm_size_t length)
 262 {
 263   os_vm_address_t end = (os_vm_address_t) ((int)(address+length+(32-1)) &~(32-1));
 264   extern void ppc_flush_cache_line(os_vm_address_t);
 265
 266   while (address < end) {
 267     ppc_flush_cache_line(address);
 268     address += 32;
 269   }
 270 }
 271
 272 #ifdef LISP_FEATURE_LINKAGE_TABLE
 273
 274 /* Linkage tables for PowerPC
 275  *
 276  * Linkage entry size is 16, because we need at least 4 instructions to
 277  * implement a jump.
 278  */
 279
 280 /*
 281  * Define the registers to use in the linkage jump table. Can be the
 282  * same. Some care must be exercised when choosing these. It has to be
 283  * a register that is not otherwise being used. reg_NFP is a good
 284  * choice. call_into_c trashes reg_NFP without preserving it, so we can
 285  * trash it in the linkage jump table.
 286  */
 287 #define LINKAGE_TEMP_REG        reg_NFP
 288 #define LINKAGE_ADDR_REG        reg_NFP
 289
 290 /*
 291  * Insert the necessary jump instructions at the given address.
 292  */
 293 void
 294 arch_write_linkage_table_jmp(void* reloc_addr, void *target_addr)
 295 {
 296   /*
 297    * Make JMP to function entry.
 298    *
 299    * The instruction sequence is:
 300    *
 301    *        addis 13, 0, (hi part of addr)
 302    *        ori   13, 13, (low part of addr)
 303    *        mtctr 13
 304    *        bctr
 305    *
 306    */
 307   int* inst_ptr;
 308   unsigned long hi;                   /* Top 16 bits of address */
 309   unsigned long lo;                   /* Low 16 bits of address */
 310   unsigned int inst;
 311
 312   inst_ptr = (int*) reloc_addr;
 313
 314   /*
 315    * Split the target address into hi and lo parts for the sethi
 316    * instruction.  hi is the top 22 bits.  lo is the low 10 bits.
 317    */
 318   hi = (unsigned long) target_addr;
 319   lo = hi & 0xffff;
 320   hi >>= 16;
 321
 322   /*
 323    * addis 13, 0, (hi part)
 324    */
 325
 326   inst = (15 << 26) | (LINKAGE_TEMP_REG << 21) | (0 << 16) | hi;
 327   *inst_ptr++ = inst;
 328
 329   /*
 330    * ori 13, 13, (lo part)
 331    */
 332
 333   inst = (24 << 26) | (LINKAGE_TEMP_REG << 21) | (LINKAGE_TEMP_REG << 16) | lo;
 334   *inst_ptr++ = inst;
 335
 336   /*
 337    * mtctr 13
 338    */
 339
 340   inst = (31 << 26) | (LINKAGE_TEMP_REG << 21) | (9 << 16) | (467 << 1);
 341   *inst_ptr++ = inst;
 342
 343   /*
 344    * bctr
 345    */
 346
 347   inst = (19 << 26) | (20 << 21) | (528 << 1);
 348   *inst_ptr++ = inst;
 349
 350
 351   *inst_ptr++ = inst;
 352
 353   os_flush_icache((os_vm_address_t) reloc_addr, (char*) inst_ptr - (char*) reloc_addr);
 354 }
 355
 356 void
 357 arch_write_linkage_table_ref(void * reloc_addr, void *target_addr)
 358 {
 359     *(unsigned long *)reloc_addr = (unsigned long)target_addr;
 360 }
 361
 362 #endif