0.7.5.18:
[sbcl.git] / 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 #ifdef LISP_FEATURE_LINUX
141     os_restore_fp_control(context);
142 #endif
143     mask=(os_context_sigmask_addr(context));
144     sigsetmask(mask); 
145     code=*((u32 *)(*os_context_pc_addr(context)));
146     if (code == ((3 << 26) | (16 << 21) | (reg_ALLOC << 16))) {
147         /* twlti reg_ALLOC,0 - check for deferred interrupt */
148         *os_context_register_addr(context,reg_ALLOC) 
149             -= PSEUDO_ATOMIC_INTERRUPTED_BIAS;
150         arch_skip_instruction(context);
151         /* interrupt or GC was requested in PA; now we're done with the
152            PA section we may as well get around to it */
153         interrupt_handle_pending(context);
154         return;
155         
156     }
157     if ((code >> 16) == ((3 << 10) | (6 << 5))) {
158         /* twllei reg_ZERO,N will always trap if reg_ZERO = 0 */
159         int trap = code & 0x1f, extra = (code >> 5) & 0x1f;
160         
161         switch (trap) {
162         case trap_Halt:
163             fake_foreign_function_call(context);
164             lose("%%primitive halt called; the party is over.\n");
165             
166         case trap_Error:
167         case trap_Cerror:
168             interrupt_internal_error(signal, code, context, trap == trap_Cerror);
169             break;
170             
171         case trap_PendingInterrupt:
172           /* when do we run this branch instead of the twlti code above? */
173             arch_skip_instruction(context);
174             interrupt_handle_pending(context);
175             break;
176             
177         case trap_Breakpoint:
178             handle_breakpoint(signal, code, context);
179             break;
180             
181         case trap_FunEndBreakpoint:
182             *os_context_pc_addr(context)
183                 =(int)handle_fun_end_breakpoint(signal, code, context);
184             break;
185             
186         case trap_AfterBreakpoint:
187             *skipped_break_addr = trap_Breakpoint;
188             skipped_break_addr = NULL;
189             *(unsigned long *)*os_context_pc_addr(context) 
190                 = displaced_after_inst;
191             *os_context_sigmask_addr(context)= orig_sigmask;
192  
193             os_flush_icache((os_vm_address_t) *os_context_pc_addr(context),
194                             sizeof(unsigned long));
195             break;
196             
197         default:
198             interrupt_handle_now(signal, code, context);
199             break;
200         }
201     }
202     if (((code >> 26) == 3) && (((code >> 21) & 31) == 24)) {
203         interrupt_internal_error(signal, code, context, 0);
204     }
205     
206     interrupt_handle_now(signal, code, context);
207 }
208
209
210 void arch_install_interrupt_handlers()
211 {
212     undoably_install_low_level_interrupt_handler(SIGILL,sigtrap_handler);
213     undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler);
214 }
215
216
217 extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
218
219 lispobj funcall0(lispobj function)
220 {
221     lispobj *args = current_control_stack_pointer;
222
223     return call_into_lisp(function, args, 0);
224 }
225
226 lispobj funcall1(lispobj function, lispobj arg0)
227 {
228     lispobj *args = current_control_stack_pointer;
229
230     current_control_stack_pointer += 1;
231     args[0] = arg0;
232
233     return call_into_lisp(function, args, 1);
234 }
235
236 lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
237 {
238     lispobj *args = current_control_stack_pointer;
239
240     current_control_stack_pointer += 2;
241     args[0] = arg0;
242     args[1] = arg1;
243
244     return call_into_lisp(function, args, 2);
245 }
246
247 lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
248 {
249     lispobj *args = current_control_stack_pointer;
250
251     current_control_stack_pointer += 3;
252     args[0] = arg0;
253     args[1] = arg1;
254     args[2] = arg2;
255
256     return call_into_lisp(function, args, 3);
257 }
258
259 void
260 ppc_flush_icache(os_vm_address_t address, os_vm_size_t length)
261 {
262   os_vm_address_t end = (os_vm_address_t) ((int)(address+length+(32-1)) &~(32-1));
263   extern void ppc_flush_cache_line(os_vm_address_t);
264
265   while (address < end) {
266     ppc_flush_cache_line(address);
267     address += 32;
268   }
269 }