0.8.15.17
[sbcl.git] / src / runtime / mips-arch.c
1 /*
2
3  This code was written as part of the CMU Common Lisp project at
4  Carnegie Mellon University, and has been placed in the public domain.
5
6 */
7
8 #include <stdio.h>
9
10 #include "sbcl.h"
11 #include "runtime.h"
12 #include "arch.h"
13 #include "globals.h"
14 #include "validate.h"
15 #include "os.h"
16 #include "lispregs.h"
17 #include "signal.h"
18 #include "alloc.h"
19 #include "interrupt.h"
20 #include "interr.h"
21 #include "breakpoint.h"
22 #include "monitor.h"
23
24 void arch_init()
25 {
26     return;
27 }
28
29 os_vm_address_t arch_get_bad_addr(int signam, siginfo_t *siginfo, os_context_t *context)
30 {
31     /* Classic CMUCL comment:
32
33        Finding the bad address on the mips is easy. */
34     return (os_vm_address_t) siginfo->si_addr;
35 }
36
37 unsigned long 
38 emulate_branch(os_context_t *context, unsigned long inst)
39 {
40     long opcode = inst >> 26;
41     long r1 = (inst >> 21) & 0x1f;
42     long r2 = (inst >> 16) & 0x1f;
43     long bdisp = (inst&(1<<15)) ? inst | (-1 << 16) : inst&0xffff;
44     long jdisp = (inst&(1<<25)) ? inst | (-1 << 26) : inst&0xffff;
45     long disp = 0;
46
47     switch(opcode) {
48     case 0x1: /* bltz, bgez, bltzal, bgezal */
49         switch((inst >> 16) & 0x1f) {
50         case 0x00: /* bltz */
51             if(*os_context_register_addr(context, r1) < 0)
52                 disp = bdisp;
53             break;
54         case 0x01: /* bgez */
55             if(*os_context_register_addr(context, r1) >= 0)
56                 disp = bdisp;
57             break;
58         case 0x10: /* bltzal */
59             if(*os_context_register_addr(context, r1) < 0)
60                 disp = bdisp;
61             *os_context_register_addr(context, 31) = *os_context_pc_addr(context) + 4;
62             break;
63         case 0x11: /* bgezal */
64             if(*os_context_register_addr(context, r1) >= 0)
65                 disp = bdisp;
66             *os_context_register_addr(context, 31) = *os_context_pc_addr(context) + 4;
67             break;
68         }
69         break;
70     case 0x4: /* beq */
71         if(*os_context_register_addr(context, r1)
72            == *os_context_register_addr(context, r2))
73             disp = bdisp;
74         break;
75     case 0x5: /* bne */
76         if(*os_context_register_addr(context, r1) 
77            != *os_context_register_addr(context, r2))
78             disp = bdisp;
79         break;
80     case 0x6: /* ble */
81         if(*os_context_register_addr(context, r1)
82            /* FIXME: One has to assume that the CMUCL gods of old have
83               got the sign issues right... but it might be worth
84               checking, someday */
85            <= *os_context_register_addr(context, r2))
86             disp = bdisp;
87         break;
88     case 0x7: /* bgtz */
89         if(*os_context_register_addr(context, r1)
90            >= *os_context_register_addr(context, r2))
91             disp = bdisp;
92         break;
93     case 0x2: /* j */
94         disp = jdisp;
95         break;
96     case 0x3: /* jal */
97         disp = jdisp;
98         *os_context_register_addr(context, 31) = *os_context_pc_addr(context) + 4;
99         break;
100     }
101     return (*os_context_pc_addr(context) + disp * 4);
102 }
103
104 void arch_skip_instruction(os_context_t *context)
105 {
106     /* Skip the offending instruction */
107     if (os_context_bd_cause(context)) {
108         /* Currently, we never get here, because Linux' support for
109            bd_cause seems not terribly solid (c.f os_context_bd_cause
110            in mips-linux-os.c).  If a port to Irix comes along, this
111            code will be executed, because presumably Irix' support is
112            better (it can hardly be worse).  We lose() to remind the
113            porter to review this code.  -- CSR, 2002-09-06 */
114         lose("bd_cause branch taken; review code for new OS?\n");
115         *os_context_pc_addr(context) = 
116             emulate_branch(context, 
117                            *(unsigned long *) *os_context_pc_addr(context));
118     }
119     else
120         *os_context_pc_addr(context) += 4;
121
122     os_flush_icache((os_vm_address_t) *os_context_pc_addr(context), sizeof(unsigned long));
123 }
124
125 unsigned char *arch_internal_error_arguments(os_context_t *context)
126 {
127     if (os_context_bd_cause(context))
128         return (unsigned char *)(*os_context_pc_addr(context) + 8);
129     else
130         return (unsigned char *)(*os_context_pc_addr(context) + 4);
131 }
132
133 boolean arch_pseudo_atomic_atomic(os_context_t *context)
134 {
135     return *os_context_register_addr(context, reg_ALLOC) & 1;
136 }
137
138 #define PSEUDO_ATOMIC_INTERRUPTED_BIAS 0x7f000000
139
140 void arch_set_pseudo_atomic_interrupted(os_context_t *context)
141 {
142     *os_context_register_addr(context, reg_NL4) |= 1<<31;
143 }
144
145 unsigned long arch_install_breakpoint(void *pc)
146 {
147     unsigned long *ptr = (unsigned long *)pc;
148     unsigned long result = *ptr;
149     *ptr = (trap_Breakpoint << 16) | 0xd;
150
151     os_flush_icache((os_vm_address_t)ptr, sizeof(unsigned long));
152
153     return result;
154 }
155
156 void arch_remove_breakpoint(void *pc, unsigned long orig_inst)
157 {
158     *(unsigned long *)pc = orig_inst;
159
160     os_flush_icache((os_vm_address_t)pc, sizeof(unsigned long));
161 }
162
163 static unsigned long *skipped_break_addr, displaced_after_inst;
164 static sigset_t orig_sigmask;
165
166 void arch_do_displaced_inst(os_context_t *context,
167                             unsigned int orig_inst)
168 {
169     unsigned long *pc = (unsigned long *)*os_context_pc_addr(context);
170     unsigned long *break_pc, *next_pc;
171     unsigned long next_inst;
172     int opcode;
173
174     orig_sigmask = *os_context_sigmask_addr(context);
175     sigaddset_blockable(os_context_sigmask_addr(context));
176
177     /* Figure out where the breakpoint is, and what happens next. */
178     if (os_context_bd_cause(context)) {
179         break_pc = pc+1;
180         next_inst = *pc;
181     }
182     else {
183         break_pc = pc;
184         next_inst = orig_inst;
185     }
186
187     /* Put the original instruction back. */
188     *break_pc = orig_inst;
189     os_flush_icache((os_vm_address_t)break_pc, sizeof(unsigned long));
190     skipped_break_addr = break_pc;
191
192     /* Figure out where it goes. */
193     opcode = next_inst >> 26;
194     if (opcode == 1 || ((opcode & 0x3c) == 0x4) || ((next_inst & 0xf00e0000) == 0x80000000)) {
195         
196         next_pc = emulate_branch(context, next_inst);
197     }
198     else
199         next_pc = pc+1;
200
201     displaced_after_inst = *next_pc;
202     *next_pc = (trap_AfterBreakpoint << 16) | 0xd;
203     os_flush_icache((os_vm_address_t)next_pc, sizeof(unsigned long));
204 }
205
206 static void sigtrap_handler(int signal, siginfo_t *info, void *void_context)
207 {
208     os_context_t *context = arch_os_get_context(&void_context);
209     sigset_t *mask;
210     int code;
211     /* Don't disallow recursive breakpoint traps.  Otherwise, we can't */
212     /* use debugger breakpoints anywhere in here. */
213     mask = os_context_sigmask_addr(context);
214     sigsetmask(mask);
215     code = ((*(int *) (*os_context_pc_addr(context))) >> 16) & 0x1f;
216
217     switch (code) {
218     case trap_PendingInterrupt:
219         arch_skip_instruction(context);
220         interrupt_handle_pending(context);
221         break;
222         
223     case trap_Halt:
224         fake_foreign_function_call(context);
225         lose("%%primitive halt called; the party is over.\n");
226         
227     case trap_Error:
228     case trap_Cerror:
229         interrupt_internal_error(signal, info, context, code==trap_Cerror);
230         break;
231         
232     case trap_Breakpoint:
233         handle_breakpoint(signal, info, context);
234         break;
235         
236     case trap_FunEndBreakpoint:
237         *os_context_pc_addr(context) = (int)handle_fun_end_breakpoint(signal, info, context);
238         break;
239         
240     case trap_AfterBreakpoint:
241         *skipped_break_addr = (trap_Breakpoint << 16) | 0xd;
242         os_flush_icache((os_vm_address_t)skipped_break_addr,
243                         sizeof(unsigned long));
244         skipped_break_addr = NULL;
245         *(unsigned long *)(*os_context_pc_addr(context)) = displaced_after_inst;
246         os_flush_icache((os_vm_address_t) *os_context_pc_addr(context), sizeof(unsigned long));
247         *os_context_sigmask_addr(context) = orig_sigmask;
248         break;
249
250     case 0x10:
251         /* Clear the flag */
252         *os_context_register_addr(context, reg_NL4) &= 0x7fffffff;
253         arch_skip_instruction(context);
254         interrupt_handle_pending(context);
255         return;
256         
257     default:
258         interrupt_handle_now(signal, info, context);
259         break;
260     }
261 }
262
263 /* FIXME: We must have one of these somewhere. Also, export
264    N-FIXNUM-TAG-BITS from Lispland and use it rather than 2 here. */
265 #define FIXNUM_VALUE(lispobj) (((int)lispobj)>>2)
266
267 void sigfpe_handler(int signal, siginfo_t *info, void *void_context)
268 {
269     unsigned long bad_inst;
270     unsigned int op, rs, rt, rd, funct, dest;
271     int immed;
272     long result;
273     os_context_t *context = arch_os_get_context(&void_context);
274
275     if (os_context_bd_cause(context))
276         bad_inst = *(unsigned long *)(*os_context_pc_addr(context) + 4);
277     else
278         bad_inst = *(unsigned long *)(*os_context_pc_addr(context));
279
280     op = (bad_inst >> 26) & 0x3f;
281     rs = (bad_inst >> 21) & 0x1f;
282     rt = (bad_inst >> 16) & 0x1f;
283     rd = (bad_inst >> 11) & 0x1f;
284     funct = bad_inst & 0x3f;
285     immed = (((int)(bad_inst & 0xffff)) << 16) >> 16;
286
287     switch (op) {
288     case 0x0: /* SPECIAL */
289         switch (funct) {
290         case 0x20: /* ADD */
291             /* FIXME: Hopefully, this whole section can just go away,
292                with the rewrite of pseudo-atomic and the deletion of
293                overflow VOPs */
294             /* Check to see if this is really a pa_interrupted hit */
295             if (rs == reg_ALLOC && rt == reg_NL4) {
296                 *os_context_register_addr(context, reg_ALLOC)
297                     += (*os_context_register_addr(context, reg_NL4)
298                         - PSEUDO_ATOMIC_INTERRUPTED_BIAS);
299                 arch_skip_instruction(context);
300                 interrupt_handle_pending(context);
301                 return;
302             }
303             result = FIXNUM_VALUE(*os_context_register_addr(context, rs))
304                 + FIXNUM_VALUE(*os_context_register_addr(context, rt));
305             dest = rd;
306             break;
307             
308         case 0x22: /* SUB */
309             result = FIXNUM_VALUE(*os_context_register_addr(context, rs))
310                 - FIXNUM_VALUE(*os_context_register_addr(context, rt));
311             dest = rd;
312             break;
313             
314         default:
315             dest = 32;
316             break;
317         }
318         break;
319         
320     case 0x8: /* ADDI */
321         result = FIXNUM_VALUE(*os_context_register_addr(context,rs)) + (immed>>2);
322         dest = rt;
323         break;
324         
325     default:
326         dest = 32;
327         break;
328     }
329     
330     if (dest < 32) {
331         dynamic_space_free_pointer =
332             (lispobj *) *os_context_register_addr(context,reg_ALLOC);
333
334         *os_context_register_addr(context,dest) = alloc_number(result);
335
336         *os_context_register_addr(context, reg_ALLOC) =
337             (unsigned long) dynamic_space_free_pointer;
338         
339         arch_skip_instruction(context);
340         
341     }
342     else
343         interrupt_handle_now(signal, info, context);
344 }
345
346 void arch_install_interrupt_handlers()
347 {    
348     undoably_install_low_level_interrupt_handler(SIGTRAP,sigtrap_handler);
349     undoably_install_low_level_interrupt_handler(SIGFPE,sigfpe_handler);
350 }
351
352 extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
353
354 lispobj funcall0(lispobj function)
355 {
356     lispobj *args = current_control_stack_pointer;
357
358     return call_into_lisp(function, args, 0);
359 }
360
361 lispobj funcall1(lispobj function, lispobj arg0)
362 {
363     lispobj *args = current_control_stack_pointer;
364
365     current_control_stack_pointer += 1;
366     args[0] = arg0;
367
368     return call_into_lisp(function, args, 1);
369 }
370
371 lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
372 {
373     lispobj *args = current_control_stack_pointer;
374
375     current_control_stack_pointer += 2;
376     args[0] = arg0;
377     args[1] = arg1;
378
379     return call_into_lisp(function, args, 2);
380 }
381
382 lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
383 {
384     lispobj *args = current_control_stack_pointer;
385
386     current_control_stack_pointer += 3;
387     args[0] = arg0;
388     args[1] = arg1;
389     args[2] = arg2;
390
391     return call_into_lisp(function, args, 3);
392 }
393