0.9.13.4:
[sbcl.git] / 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 #if defined(LISP_FEATURE_GENCGC)
14 #include "gencgc-alloc-region.h"
15 #endif
16
17   /* The header files may not define PT_DAR/PT_DSISR.  This definition
18      is correct for all versions of ppc linux >= 2.0.30
19
20      As of DR2.1u4, MkLinux doesn't pass these registers to signal
21      handlers correctly; a patch is necessary in order to (partially)
22      correct this.
23
24      Even with the patch, the DSISR may not have its 'write' bit set
25      correctly (it tends not to be set if the fault was caused by
26      something other than a protection violation.)
27
28      Caveat callers.  */
29
30 #ifndef PT_DAR
31 #define PT_DAR          41
32 #endif
33
34 #ifndef PT_DSISR
35 #define PT_DSISR        42
36 #endif
37
38 void arch_init() {
39 }
40
41 os_vm_address_t
42 arch_get_bad_addr(int sig, siginfo_t *code, os_context_t *context)
43 {
44     unsigned long pc =  (unsigned long)(*os_context_pc_addr(context));
45     os_vm_address_t addr;
46
47     addr = (os_vm_address_t) (*os_context_register_addr(context,PT_DAR));
48     return addr;
49 }
50
51
52 void
53 arch_skip_instruction(os_context_t *context)
54 {
55     char** pcptr;
56     pcptr = (char**) os_context_pc_addr(context);
57     *pcptr += 4;
58 }
59
60 unsigned char *
61 arch_internal_error_arguments(os_context_t *context)
62 {
63     return (unsigned char *)(*os_context_pc_addr(context)+4);
64 }
65
66
67 boolean
68 arch_pseudo_atomic_atomic(os_context_t *context)
69 {
70     return ((*os_context_register_addr(context,reg_ALLOC)) & 4);
71 }
72
73 void
74 arch_set_pseudo_atomic_interrupted(os_context_t *context)
75 {
76     *os_context_register_addr(context,reg_ALLOC) |= 1;
77 }
78
79 void
80 arch_clear_pseudo_atomic_interrupted(os_context_t *context)
81 {
82     *os_context_register_addr(context,reg_ALLOC) &= ~1;
83 }
84
85 unsigned int
86 arch_install_breakpoint(void *pc)
87 {
88     unsigned int *ptr = (unsigned int *)pc;
89     unsigned int result = *ptr;
90     *ptr = (3<<26) | (5 << 21) | trap_Breakpoint;
91     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned int));
92     return result;
93 }
94
95 void
96 arch_remove_breakpoint(void *pc, unsigned int orig_inst)
97 {
98     *(unsigned int *)pc = orig_inst;
99     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned int));
100 }
101
102 /*
103  * Perform the instruction that we overwrote with a breakpoint.  As we
104  * don't have a single-step facility, this means we have to:
105  * - put the instruction back
106  * - put a second breakpoint at the following instruction,
107  *   set after_breakpoint and continue execution.
108  *
109  * When the second breakpoint is hit (very shortly thereafter, we hope)
110  * sigtrap_handler gets called again, but follows the AfterBreakpoint
111  * arm, which
112  * - puts a bpt back in the first breakpoint place (running across a
113  *   breakpoint shouldn't cause it to be uninstalled)
114  * - replaces the second bpt with the instruction it was meant to be
115  * - carries on
116  *
117  * Clear?
118  */
119 static unsigned int *skipped_break_addr, displaced_after_inst;
120 static sigset_t orig_sigmask;
121
122 void
123 arch_do_displaced_inst(os_context_t *context,unsigned int orig_inst)
124 {
125     /* not sure how we ensure that we get the breakpoint reinstalled
126      * after doing this -dan */
127     unsigned int *pc = (unsigned int *)(*os_context_pc_addr(context));
128
129     orig_sigmask = *os_context_sigmask_addr(context);
130     sigaddset_blockable(os_context_sigmask_addr(context));
131
132     *pc = orig_inst;
133     os_flush_icache((os_vm_address_t) pc, sizeof(unsigned int));
134     skipped_break_addr = pc;
135 }
136
137 #ifdef LISP_FEATURE_GENCGC
138 /*
139  * Return non-zero if the current instruction is an allocation trap
140  */
141 static int
142 allocation_trap_p(os_context_t * context)
143 {
144     int result;
145     unsigned int *pc;
146     unsigned inst;
147     unsigned opcode;
148     unsigned src;
149     unsigned dst;
150
151     result = 0;
152
153     /*
154      * First, the instruction has to be a TWLGE temp, NL3, which has the
155      * format.
156      * | 6| 5| 5 | 5 | 10|1|  width
157      * |31|5 |dst|src|  4|0|  field
158      */
159     pc = (unsigned int *) (*os_context_pc_addr(context));
160     inst = *pc;
161
162 #if 0
163     fprintf(stderr, "allocation_trap_p at %p:  inst = 0x%08x\n", pc, inst);
164 #endif
165
166     opcode = inst >> 26;
167     src = (inst >> 11) & 0x1f;
168     dst = (inst >> 16) & 0x1f;
169     if ((opcode == 31) && (src == reg_NL3) && (5 == ((inst >> 21) & 0x1f))
170         && (4 == ((inst >> 1) & 0x3ff))) {
171         /*
172          * We got the instruction.  Now, look back to make sure it was
173          * proceeded by what we expected.  2 instructions back should be
174          * an ADD or ADDI instruction.
175          */
176         unsigned int add_inst;
177
178         add_inst = pc[-3];
179 #if 0
180         fprintf(stderr, "   add inst at %p:  inst = 0x%08x\n",
181                 pc - 3, add_inst);
182 #endif
183         opcode = add_inst >> 26;
184         if ((opcode == 31) && (266 == ((add_inst >> 1) & 0x1ff))) {
185             return 1;
186         } else if ((opcode == 14)) {
187             return 1;
188         } else {
189             fprintf(stderr,
190                     "Whoa! Got allocation trap but could not find ADD or ADDI instruction: 0x%08x in the proper place\n",
191                     add_inst);
192         }
193     }
194     return 0;
195 }
196
197 extern struct alloc_region boxed_region;
198
199 void
200 handle_allocation_trap(os_context_t * context)
201 {
202     unsigned int *pc;
203     unsigned int inst;
204     unsigned int or_inst;
205     unsigned int target, target_ptr, end_addr;
206     unsigned int opcode;
207     int size;
208     int immed;
209     boolean were_in_lisp;
210     char *memory;
211     sigset_t block;
212
213     target = 0;
214     size = 0;
215
216 #if 0
217     fprintf(stderr, "In handle_allocation_trap\n");
218 #endif
219
220     /*
221      * I don't think it's possible for us NOT to be in lisp when we get
222      * here.  Remove this later?
223      */
224     were_in_lisp = !foreign_function_call_active;
225
226     if (were_in_lisp) {
227         fake_foreign_function_call(context);
228     } else {
229         fprintf(stderr, "**** Whoa! allocation trap and we weren't in lisp!\n");
230     }
231
232     /*
233      * Look at current instruction: TWNE temp, NL3. We're here because
234      * temp > NL3 and temp is the end of the allocation, and NL3 is
235      * current-region-end-addr.
236      *
237      * We need to adjust temp and alloc-tn.
238      */
239
240     pc = (unsigned int *) (*os_context_pc_addr(context));
241     inst = pc[0];
242     end_addr = (inst >> 11) & 0x1f;
243     target = (inst >> 16) & 0x1f;
244
245     target_ptr = *os_context_register_addr(context, target);
246
247 #if 0
248     fprintf(stderr, "handle_allocation_trap at %p:\n", pc);
249     fprintf(stderr, "boxed_region.free_pointer: %p\n", boxed_region.free_pointer);
250     fprintf(stderr, "boxed_region.end_addr: %p\n", boxed_region.end_addr);
251     fprintf(stderr, "target reg: %d, end_addr reg: %d\n", target, end_addr);
252     fprintf(stderr, "target: %x\n", *os_context_register_addr(context, target));
253     fprintf(stderr, "end_addr: %x\n", *os_context_register_addr(context, end_addr));
254 #endif
255
256 #if 0
257     fprintf(stderr, "handle_allocation_trap at %p:\n", pc);
258     fprintf(stderr, "  trap inst = 0x%08x\n", inst);
259     fprintf(stderr, "  target reg = %s\n", lisp_register_names[target]);
260 #endif
261
262     /*
263      * Go back and look at the add/addi instruction.  The second src arg
264      * is the size of the allocation.  Get it and call alloc to allocate
265      * new space.
266      */
267     inst = pc[-3];
268     opcode = inst >> 26;
269 #if 0
270     fprintf(stderr, "  add inst  = 0x%08x, opcode = %d\n", inst, opcode);
271 #endif
272     if (opcode == 14) {
273         /*
274          * ADDI temp-tn, alloc-tn, size
275          *
276          * Extract the size
277          */
278         size = (inst & 0xffff);
279     } else if (opcode == 31) {
280         /*
281          * ADD temp-tn, alloc-tn, size-tn
282          *
283          * Extract the size
284          */
285         int reg;
286
287         reg = (inst >> 11) & 0x1f;
288 #if 0
289         fprintf(stderr, "  add, reg = %s\n", lisp_register_names[reg]);
290 #endif
291         size = *os_context_register_addr(context, reg);
292
293     }
294
295 #if 0
296     fprintf(stderr, "Alloc %d to %s\n", size, lisp_register_names[target]);
297 #endif
298
299 #if INLINE_ALLOC_DEBUG
300     if ((((unsigned long)boxed_region.end_addr + size) / PAGE_SIZE) ==
301         (((unsigned long)boxed_region.end_addr) / PAGE_SIZE)) {
302       fprintf(stderr,"*** possibly bogus trap allocation of %d bytes at %p\n",
303               size, target_ptr);
304       fprintf(stderr, "    dynamic_space_free_pointer: %p, boxed_region.end_addr %p\n",
305               dynamic_space_free_pointer, boxed_region.end_addr);
306     }
307 #endif
308
309 #if 0
310     fprintf(stderr, "Ready to alloc\n");
311     fprintf(stderr, "free_pointer = 0x%08x\n",
312             dynamic_space_free_pointer);
313 #endif
314
315     /*
316      * alloc-tn was incremented by size.  Need to decrement it by size
317      * to restore its original value. This is not true on GENCGC
318      * anymore. d_s_f_p and reg_alloc get out of sync, but the p_a
319      * bits stay intact and we set it to the proper value when it
320      * needs to be. Keep this comment here for the moment in case
321      * somebody tries to figure out what happened here.
322      */
323     /*    dynamic_space_free_pointer =
324         (lispobj *) ((long) dynamic_space_free_pointer - size);
325     */
326 #if 0
327     fprintf(stderr, "free_pointer = 0x%08x new\n",
328             dynamic_space_free_pointer);
329 #endif
330
331     memory = (char *) alloc(size);
332
333 #if 0
334     fprintf(stderr, "alloc returned %p\n", memory);
335     fprintf(stderr, "free_pointer = 0x%08x\n",
336             dynamic_space_free_pointer);
337 #endif
338
339     /*
340      * The allocation macro wants the result to point to the end of the
341      * object!
342      */
343     memory += size;
344
345 #if 0
346     fprintf(stderr, "object end at %p\n", memory);
347 #endif
348
349     *os_context_register_addr(context, target) = (unsigned long) memory;
350     *os_context_register_addr(context, reg_ALLOC) =
351       (unsigned long) dynamic_space_free_pointer
352       | (*os_context_register_addr(context, reg_ALLOC)
353          & LOWTAG_MASK);
354
355     if (were_in_lisp) {
356         undo_fake_foreign_function_call(context);
357     }
358
359
360 }
361 #endif
362
363
364 static void
365 sigtrap_handler(int signal, siginfo_t *siginfo, os_context_t *context)
366 {
367     unsigned int code;
368
369 #ifdef LISP_FEATURE_LINUX
370     os_restore_fp_control(context);
371 #endif
372     code=*((u32 *)(*os_context_pc_addr(context)));
373     if (code == ((3 << 26) | (0x18 << 21) | (reg_NL3 << 16))) {
374         arch_clear_pseudo_atomic_interrupted(context);
375         arch_skip_instruction(context);
376         /* interrupt or GC was requested in PA; now we're done with the
377            PA section we may as well get around to it */
378         interrupt_handle_pending(context);
379         return;
380     }
381
382 #ifdef LISP_FEATURE_GENCGC
383     /* Is this an allocation trap? */
384     if (allocation_trap_p(context)) {
385         handle_allocation_trap(context);
386         arch_skip_instruction(context);
387 #ifdef LISP_FEATURE_DARWIN
388         DARWIN_FIX_CONTEXT(context);
389 #endif
390         return;
391     }
392 #endif
393
394     if ((code >> 16) == ((3 << 10) | (6 << 5))) {
395         /* twllei reg_ZERO,N will always trap if reg_ZERO = 0 */
396         int trap = code & 0x1f;
397
398         switch (trap) {
399         case trap_Halt:
400             fake_foreign_function_call(context);
401             lose("%%primitive halt called; the party is over.\n");
402
403         case trap_Error:
404         case trap_Cerror:
405             interrupt_internal_error(signal, code, context, trap == trap_Cerror);
406             break;
407
408         case trap_PendingInterrupt:
409             /* This is supposed run after WITHOUT-INTERRUPTS if there
410              * were pending signals. */
411             arch_skip_instruction(context);
412             interrupt_handle_pending(context);
413             break;
414
415         case trap_Breakpoint:
416             handle_breakpoint(signal, code, context);
417             break;
418
419         case trap_FunEndBreakpoint:
420             *os_context_pc_addr(context)
421                 =(int)handle_fun_end_breakpoint(signal, code, context);
422             break;
423
424         case trap_AfterBreakpoint:
425             *skipped_break_addr = trap_Breakpoint;
426             skipped_break_addr = NULL;
427             *(unsigned int *)*os_context_pc_addr(context)
428                 = displaced_after_inst;
429             *os_context_sigmask_addr(context)= orig_sigmask;
430
431             os_flush_icache((os_vm_address_t) *os_context_pc_addr(context),
432                             sizeof(unsigned int));
433             break;
434
435         default:
436             interrupt_handle_now(signal, code, context);
437             break;
438         }
439 #ifdef LISP_FEATURE_DARWIN
440         DARWIN_FIX_CONTEXT(context);
441 #endif
442         return;
443     }
444     if (((code >> 26) == 3) && (((code >> 21) & 31) == 24)) {
445         interrupt_internal_error(signal, code, context, 0);
446 #ifdef LISP_FEATURE_DARWIN
447         DARWIN_FIX_CONTEXT(context);
448 #endif
449         return;
450     }
451
452     interrupt_handle_now(signal, code, context);
453 #ifdef LISP_FEATURE_DARWIN
454     /* Work around G5 bug */
455     DARWIN_FIX_CONTEXT(context);
456 #endif
457 }
458
459
460 void arch_install_interrupt_handlers()
461 {
462     undoably_install_low_level_interrupt_handler(SIGILL,sigtrap_handler);
463     undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler);
464 }
465
466
467 extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
468
469 lispobj funcall0(lispobj function)
470 {
471     lispobj *args = current_control_stack_pointer;
472
473     return call_into_lisp(function, args, 0);
474 }
475
476 lispobj funcall1(lispobj function, lispobj arg0)
477 {
478     lispobj *args = current_control_stack_pointer;
479
480     current_control_stack_pointer += 1;
481     args[0] = arg0;
482
483     return call_into_lisp(function, args, 1);
484 }
485
486 lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
487 {
488     lispobj *args = current_control_stack_pointer;
489
490     current_control_stack_pointer += 2;
491     args[0] = arg0;
492     args[1] = arg1;
493
494     return call_into_lisp(function, args, 2);
495 }
496
497 lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
498 {
499     lispobj *args = current_control_stack_pointer;
500
501     current_control_stack_pointer += 3;
502     args[0] = arg0;
503     args[1] = arg1;
504     args[2] = arg2;
505
506     return call_into_lisp(function, args, 3);
507 }
508
509 void
510 ppc_flush_icache(os_vm_address_t address, os_vm_size_t length)
511 {
512   os_vm_address_t end = (os_vm_address_t) ((int)(address+length+(32-1)) &~(32-1));
513   extern void ppc_flush_cache_line(os_vm_address_t);
514
515   while (address < end) {
516     ppc_flush_cache_line(address);
517     address += 32;
518   }
519 }
520
521 #ifdef LISP_FEATURE_LINKAGE_TABLE
522
523 /* Linkage tables for PowerPC
524  *
525  * Linkage entry size is 16, because we need at least 4 instructions to
526  * implement a jump.
527  */
528
529 /*
530  * Define the registers to use in the linkage jump table. Can be the
531  * same. Some care must be exercised when choosing these. It has to be
532  * a register that is not otherwise being used. reg_NFP is a good
533  * choice. call_into_c trashes reg_NFP without preserving it, so we can
534  * trash it in the linkage jump table.
535  */
536 #define LINKAGE_TEMP_REG        reg_NFP
537 #define LINKAGE_ADDR_REG        reg_NFP
538
539 /*
540  * Insert the necessary jump instructions at the given address.
541  */
542 void
543 arch_write_linkage_table_jmp(void* reloc_addr, void *target_addr)
544 {
545   /*
546    * Make JMP to function entry.
547    *
548    * The instruction sequence is:
549    *
550    *        addis 13, 0, (hi part of addr)
551    *        ori   13, 13, (low part of addr)
552    *        mtctr 13
553    *        bctr
554    *
555    */
556   int* inst_ptr;
557   unsigned long hi;                   /* Top 16 bits of address */
558   unsigned long lo;                   /* Low 16 bits of address */
559   unsigned int inst;
560
561   inst_ptr = (int*) reloc_addr;
562
563   /*
564    * Split the target address into hi and lo parts for the sethi
565    * instruction.  hi is the top 22 bits.  lo is the low 10 bits.
566    */
567   hi = (unsigned long) target_addr;
568   lo = hi & 0xffff;
569   hi >>= 16;
570
571   /*
572    * addis 13, 0, (hi part)
573    */
574
575   inst = (15 << 26) | (LINKAGE_TEMP_REG << 21) | (0 << 16) | hi;
576   *inst_ptr++ = inst;
577
578   /*
579    * ori 13, 13, (lo part)
580    */
581
582   inst = (24 << 26) | (LINKAGE_TEMP_REG << 21) | (LINKAGE_TEMP_REG << 16) | lo;
583   *inst_ptr++ = inst;
584
585   /*
586    * mtctr 13
587    */
588
589   inst = (31 << 26) | (LINKAGE_TEMP_REG << 21) | (9 << 16) | (467 << 1);
590   *inst_ptr++ = inst;
591
592   /*
593    * bctr
594    */
595
596   inst = (19 << 26) | (20 << 21) | (528 << 1);
597   *inst_ptr++ = inst;
598
599
600   *inst_ptr++ = inst;
601
602   os_flush_icache((os_vm_address_t) reloc_addr, (char*) inst_ptr - (char*) reloc_addr);
603 }
604
605 void
606 arch_write_linkage_table_ref(void * reloc_addr, void *target_addr)
607 {
608     *(unsigned long *)reloc_addr = (unsigned long)target_addr;
609 }
610
611 #endif