2 * This software is part of the SBCL system. See the README file for
5 * This software is derived from the CMU CL system, which was
6 * written at Carnegie Mellon University and released into the
7 * public domain. The software is in the public domain and is
8 * provided with absolutely no warranty. See the COPYING and CREDITS
9 * files for more information.
12 /* Note that although superficially it appears that we use
13 * os_context_t like we ought to, we actually just assume its a
14 * ucontext in places. Naughty */
28 #include "interrupt.h"
30 #include "breakpoint.h"
33 extern char call_into_lisp_LRA
[], call_into_lisp_end
[];
35 extern size_t os_vm_page_size
;
36 #define BREAKPOINT_INST 0x80
42 /* This must be called _after_ os_init(), so that we know what the
45 if (mmap((os_vm_address_t
) call_into_lisp_LRA_page
,os_vm_page_size
,
46 OS_VM_PROT_ALL
,MAP_PRIVATE
|MAP_ANONYMOUS
|MAP_FIXED
,-1,0)
47 == (os_vm_address_t
) -1)
50 /* call_into_lisp_LRA is a collection of trampolines written in asm -
51 * see alpha-assem.S. We copy it to call_into_lisp_LRA_page where
52 * VOPs and things can find it. (I don't know why they can't find it
53 * where it was to start with.) */
54 bcopy(call_into_lisp_LRA
,(void *)call_into_lisp_LRA_page
,os_vm_page_size
);
56 os_flush_icache((os_vm_address_t
)call_into_lisp_LRA_page
,
62 arch_get_bad_addr (int sig
, siginfo_t
*code
, os_context_t
*context
)
66 /* Instructions are 32 bit quantities. */
68 /* fprintf(stderr,"arch_get_bad_addr %d %p %p\n",
69 sig, code, context); */
70 pc
= (unsigned int *)(*os_context_pc_addr(context
));
72 if (((unsigned long)pc
) & 3) {
73 return NULL
; /* In what case would pc be unaligned?? */
76 if ( (pc
< READ_ONLY_SPACE_START
||
77 pc
>= READ_ONLY_SPACE_START
+READ_ONLY_SPACE_SIZE
) &&
78 (pc
< current_dynamic_space
||
79 pc
>= current_dynamic_space
+ DYNAMIC_SPACE_SIZE
))
82 return context
->uc_mcontext
.sc_traparg_a0
;
86 arch_skip_instruction(os_context_t
*context
)
88 /* This may be complete rubbish, as (at least for traps) pc points
89 * _after_ the instruction that caused us to be here anyway.
91 ((char*)*os_context_pc_addr(context
)) +=4; }
94 arch_internal_error_arguments(os_context_t
*context
)
96 return (unsigned char *)(*os_context_pc_addr(context
)+4);
100 arch_pseudo_atomic_atomic(os_context_t
*context
)
102 return ((*os_context_register_addr(context
,reg_ALLOC
)) & 1);
105 void arch_set_pseudo_atomic_interrupted(os_context_t
*context
)
107 /* On coming out of an atomic section, we subtract 1 from
108 * reg_Alloc, then try to store something at that address. So,
109 * to signal that it was interrupted and a signal should be handled,
110 * we set bit 63 of reg_ALLOC here so that the end-of-atomic code
111 * will raise SIGSEGV (no ram mapped there). We catch the signal
112 * (see the appropriate *-os.c) and call interrupt_handle_pending()
113 * for the saved signal instead */
115 *os_context_register_addr(context
,reg_ALLOC
) |= (1L<<63);
118 unsigned long arch_install_breakpoint(void *pc
)
120 unsigned int *ptr
= (unsigned int *)pc
;
121 unsigned long result
= (unsigned long) *ptr
;
122 *ptr
= BREAKPOINT_INST
;
124 os_flush_icache((os_vm_address_t
)ptr
, sizeof(unsigned long));
129 void arch_remove_breakpoint(void *pc
, unsigned long orig_inst
)
131 /* was (unsigned int) but gcc complains. Changed to mirror
132 * install_breakpoint() above */
133 unsigned long *ptr
=(unsigned long *)pc
;
135 os_flush_icache((os_vm_address_t
)pc
, sizeof(unsigned long));
138 static unsigned int *skipped_break_addr
, displaced_after_inst
,
142 /* This returns a PC value. Lisp code is all in the 32-bit-addressable
143 * space, so we should be ok with an unsigned int. */
145 emulate_branch(os_context_t
*context
,unsigned long orig_inst
)
147 int op
= orig_inst
>> 26;
148 int reg_a
= (orig_inst
>> 21) & 0x1f;
149 int reg_b
= (orig_inst
>> 16) & 0x1f;
151 (orig_inst
&(1<<20)) ?
152 orig_inst
| (-1 << 21) :
154 int next_pc
= *os_context_pc_addr(context
);
155 int branch
= 0; /* was NULL; */
158 case 0x1a: /* jmp, jsr, jsr_coroutine, ret */
159 *os_context_register_addr(context
,reg_a
) =
160 *os_context_pc_addr(context
);
161 *os_context_pc_addr(context
) =
162 *os_context_register_addr(context
,reg_b
)& ~3;
165 *os_context_register_addr(context
,reg_a
)=*os_context_pc_addr(context
);
168 case 0x31: /* fbeq */
169 if (*(os_context_float_register_addr(context
,reg_a
))==0) branch
= 1;
171 case 0x32: /* fblt */
172 if (*os_context_float_register_addr(context
,reg_a
)<0) branch
= 1;
174 case 0x33: /* fble */
175 if (*os_context_float_register_addr(context
,reg_a
)<=0) branch
= 1;
178 *os_context_register_addr(context
,reg_a
)=*os_context_pc_addr(context
);
181 case 0x35: /* fbne */
182 if (*os_context_register_addr(context
,reg_a
)!=0) branch
= 1;
184 case 0x36: /* fbge */
185 if (*os_context_float_register_addr(context
,reg_a
)>=0) branch
= 1;
187 case 0x37: /* fbgt */
188 if (*os_context_float_register_addr(context
,reg_a
)>0) branch
= 1;
190 case 0x38: /* blbc */
191 if ((*os_context_register_addr(context
,reg_a
)&1) == 0) branch
= 1;
194 if (*os_context_register_addr(context
,reg_a
)==0) branch
= 1;
197 if (*os_context_register_addr(context
,reg_a
)<0) branch
= 1;
200 if (*os_context_register_addr(context
,reg_a
)<=0) branch
= 1;
202 case 0x3c: /* blbs */
203 if ((*os_context_register_addr(context
,reg_a
)&1)!=0) branch
= 1;
206 if (*os_context_register_addr(context
,reg_a
)!=0) branch
= 1;
209 if (*os_context_register_addr(context
,reg_a
)>=0) branch
= 1;
212 if (*os_context_register_addr(context
,reg_a
)>0) branch
= 1;
220 static sigset_t orig_sigmask
;
222 /* Perform the instruction that we overwrote with a breakpoint. As we
223 * don't have a single-step facility, this means we have to:
224 * - put the instruction back
225 * - put a second breakpoint at the following instruction,
226 * set after_breakpoint and continue execution.
228 * When the second breakpoint is hit (very shortly thereafter, we hope)
229 * sigtrap_handler gets called again, but follows the AfterBreakpoint
231 * - puts a bpt back in the first breakpoint place (running across a
232 * breakpoint shouldn't cause it to be uninstalled)
233 * - replaces the second bpt with the instruction it was meant to be
239 void arch_do_displaced_inst(os_context_t
*context
,unsigned int orig_inst
)
241 /* Apparent off-by-one errors ahoy. If you consult the Alpha ARM,
242 * it will tell you that after a BPT, the saved PC is the address
243 * of the instruction _after_ the instruction that caused the trap.
245 * However, we decremented PC by 4 before calling the Lisp-level
246 * handler that calls this routine (see alpha-arch.c line 322 and
247 * friends) so when we get to this point PC is actually pointing
248 * at the BPT instruction itself. This is good, because this is
249 * where we want to restart execution when we do that */
251 unsigned int *pc
=(unsigned int *)(*os_context_pc_addr(context
));
252 unsigned int *next_pc
;
253 int op
= orig_inst
>> 26;;
255 orig_sigmask
= *os_context_sigmask_addr(context
);
256 sigaddset_blockable(os_context_sigmask_addr(context
));
258 /* Put the original instruction back. */
260 os_flush_icache((os_vm_address_t
)pc
, sizeof(unsigned long));
261 skipped_break_addr
= pc
;
263 /* Figure out where we will end up after running the displaced
265 if (op
== 0x1a || (op
&0xf) == 0x30) /* a branch */
266 /* The cast to long is just to shut gcc up. */
267 next_pc
= (unsigned int *)((long)emulate_branch(context
,orig_inst
));
271 /* Set the after breakpoint. */
272 displaced_after_inst
= *next_pc
;
273 *next_pc
= BREAKPOINT_INST
;
275 os_flush_icache((os_vm_address_t
)next_pc
, sizeof(unsigned long));
279 sigtrap_handler(int signal
, siginfo_t
*siginfo
, os_context_t
*context
)
283 #ifdef LISP_FEATURE_LINUX
284 os_restore_fp_control(context
);
287 /* Don't disallow recursive breakpoint traps. Otherwise, we can't */
288 /* use debugger breakpoints anywhere in here. */
289 mask
=(os_context_sigmask_addr(context
));
292 /* this is different from how CMUCL does it. CMUCL used "call_pal
293 * PAL_gentrap", which doesn't do anything on Linux (unless NL0
294 * contains certain specific values). We use "bugchk" instead.
295 * It's (for our purposes) just the same as bpt but has a
296 * different opcode so we can test whether we're dealing with a
297 * breakpoint or a "system service" */
299 if ((*(unsigned int*)(*os_context_pc_addr(context
)-4))==BREAKPOINT_INST
) {
300 if (after_breakpoint
) {
301 /* see comments above arch_do_displaced_inst. This is where
302 * we reinsert the breakpoint that we removed earlier */
304 *os_context_pc_addr(context
) -=4;
305 *skipped_break_addr
= BREAKPOINT_INST
;
306 os_flush_icache((os_vm_address_t
)skipped_break_addr
,
307 sizeof(unsigned long));
308 skipped_break_addr
= NULL
;
309 *(unsigned int *)*os_context_pc_addr(context
) =
310 displaced_after_inst
;
311 os_flush_icache((os_vm_address_t
)*os_context_pc_addr(context
), sizeof(unsigned long));
312 *os_context_sigmask_addr(context
)= orig_sigmask
;
313 after_breakpoint
=0; /* false */
316 code
= trap_Breakpoint
;
318 /* a "system service" */
319 code
=*((u32
*)(*os_context_pc_addr(context
)));
322 case trap_PendingInterrupt
:
323 arch_skip_instruction(context
);
324 interrupt_handle_pending(context
);
328 fake_foreign_function_call(context
);
329 lose("%%primitive halt called; the party is over.\n");
333 interrupt_internal_error(signal
, siginfo
, context
, code
==trap_Cerror
);
336 case trap_Breakpoint
: /* call lisp-level handler */
337 *os_context_pc_addr(context
) -=4;
338 handle_breakpoint(signal
, siginfo
, context
);
341 case trap_FunEndBreakpoint
:
342 *os_context_pc_addr(context
) -=4;
343 *os_context_pc_addr(context
) =
344 (int)handle_fun_end_breakpoint(signal
, siginfo
, context
);
348 fprintf(stderr
, "unidentified breakpoint/trap %d\n",code
);
349 interrupt_handle_now(signal
, siginfo
, context
);
355 arch_get_fp_control()
357 return ieee_get_fp_control();
361 arch_set_fp_control(unsigned long fp
)
363 ieee_set_fp_control(fp
);
367 void arch_install_interrupt_handlers()
369 undoably_install_low_level_interrupt_handler(SIGTRAP
, sigtrap_handler
);
372 extern lispobj
call_into_lisp(lispobj fun
, lispobj
*args
, int nargs
);
374 lispobj
funcall0(lispobj function
)
376 lispobj
*args
= current_control_stack_pointer
;
378 return call_into_lisp(function
, args
, 0);
381 lispobj
funcall1(lispobj function
, lispobj arg0
)
383 lispobj
*args
= current_control_stack_pointer
;
385 current_control_stack_pointer
+= 1;
388 return call_into_lisp(function
, args
, 1);
391 lispobj
funcall2(lispobj function
, lispobj arg0
, lispobj arg1
)
393 lispobj
*args
= current_control_stack_pointer
;
395 current_control_stack_pointer
+= 2;
399 return call_into_lisp(function
, args
, 2);
402 lispobj
funcall3(lispobj function
, lispobj arg0
, lispobj arg1
, lispobj arg2
)
404 lispobj
*args
= current_control_stack_pointer
;
406 current_control_stack_pointer
+= 3;
411 return call_into_lisp(function
, args
, 3);