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 */
18 #include <asm/pal.h> /* for PAL_gentrap */
29 #include "interrupt.h"
31 #include "breakpoint.h"
34 extern char call_into_lisp_LRA
[], call_into_lisp_end
[];
35 extern size_t os_vm_page_size
;
36 #define BREAKPOINT_INST 0x80
41 /* This must be called _after_ os_init(), so that we know what the
43 if (mmap((os_vm_address_t
) call_into_lisp_LRA_page
,os_vm_page_size
,
44 OS_VM_PROT_ALL
,MAP_PRIVATE
|MAP_ANONYMOUS
|MAP_FIXED
,-1,0)
45 == (os_vm_address_t
) -1)
48 /* call_into_lisp_LRA is a collection of trampolines written in asm -
49 * see alpha-assem.S. We copy it to call_into_lisp_LRA_page where
50 * VOPs and things can find it. (I don't know why they can't find it
51 * where it was to start with.) */
52 bcopy(call_into_lisp_LRA
,(void *)call_into_lisp_LRA_page
,os_vm_page_size
);
54 os_flush_icache((os_vm_address_t
)call_into_lisp_LRA_page
,
60 arch_get_bad_addr (int sig
, siginfo_t
*code
, os_context_t
*context
)
64 /* Instructions are 32 bit quantities. */
66 /* fprintf(stderr,"arch_get_bad_addr %d %p %p\n",
67 sig, code, context); */
68 pc
= (unsigned int *)(*os_context_pc_addr(context
));
70 if (((unsigned long)pc
) & 3) {
71 return NULL
; /* In what case would pc be unaligned?? */
74 if ( (pc
< READ_ONLY_SPACE_START
||
75 pc
>= READ_ONLY_SPACE_START
+READ_ONLY_SPACE_SIZE
) &&
76 (pc
< current_dynamic_space
||
77 pc
>= current_dynamic_space
+ DYNAMIC_SPACE_SIZE
))
82 if (((badinst
>>27)!=0x16) /* STL or STQ */
83 && ((badinst
>>27)!=0x13)) /* STS or STT */
84 return NULL
; /* Otherwise forget about address. */
86 return (os_vm_address_t
)
87 (*os_context_register_addr(context
,((badinst
>>16)&0x1f))
92 arch_skip_instruction(os_context_t
*context
)
94 /* This may be complete rubbish, as (at least for traps) pc points
95 * _after_ the instruction that caused us to be here anyway.
97 ((char*)*os_context_pc_addr(context
)) +=4; }
100 arch_internal_error_arguments(os_context_t
*context
)
102 return (unsigned char *)(*os_context_pc_addr(context
)+4);
106 arch_pseudo_atomic_atomic(os_context_t
*context
)
108 return ((*os_context_register_addr(context
,reg_ALLOC
)) & 1);
111 void arch_set_pseudo_atomic_interrupted(os_context_t
*context
)
113 /* On coming out of an atomic section, we subtract 1 from
114 * reg_Alloc, then try to store something at that address. On
115 * OSF/1 we add 1 to reg_Alloc here so that the end-of-atomic code
116 * will raise SIGTRAP for "unaligned access". Linux catches
117 * unaligned accesses in the kernel and fixes them up[1], so there
118 * we toggle bit 63 instead. The resulting address is somewhere
119 * out in no-man's land, so we get SIGSEGV when we try to access
120 * it. We catch whichever signal it is (see the appropriate
121 * *-os.c) and call interrupt_handle_pending() from it */
123 /* [1] This behaviour can be changed with osf_setsysinfo, but cmucl
127 *os_context_register_addr(context
,reg_ALLOC
) |= (1L<<63);
129 *os_context_register_addr(context
,reg_ALLOC
) |= 2;
133 /* XXX but is the caller of this storing all 64 bits? */
134 unsigned long arch_install_breakpoint(void *pc
)
136 unsigned int *ptr
= (unsigned int *)pc
;
137 unsigned long result
= (unsigned long) *ptr
;
138 *ptr
= BREAKPOINT_INST
;
140 os_flush_icache((os_vm_address_t
)ptr
, sizeof(unsigned long));
145 void arch_remove_breakpoint(void *pc
, unsigned long orig_inst
)
147 /* was (unsigned int) but gcc complains. Changed to mirror
148 * install_breakpoint() above */
149 unsigned long *ptr
=(unsigned long *)pc
;
151 os_flush_icache((os_vm_address_t
)pc
, sizeof(unsigned long));
154 static unsigned int *skipped_break_addr
, displaced_after_inst
,
158 /* This returns a PC value. Lisp code is all in the 32-bit-addressable
159 * space, so we should be ok with an unsigned int. */
161 emulate_branch(os_context_t
*context
,unsigned long orig_inst
)
163 int op
= orig_inst
>> 26;
164 int reg_a
= (orig_inst
>> 21) & 0x1f;
165 int reg_b
= (orig_inst
>> 16) & 0x1f;
167 (orig_inst
&(1<<20)) ?
168 orig_inst
| (-1 << 21) :
170 int next_pc
= *os_context_pc_addr(context
);
171 int branch
= 0; /* was NULL; */
174 case 0x1a: /* jmp, jsr, jsr_coroutine, ret */
175 *os_context_register_addr(context
,reg_a
) =
176 *os_context_pc_addr(context
);
177 *os_context_pc_addr(context
) =
178 *os_context_register_addr(context
,reg_b
)& ~3;
181 *os_context_register_addr(context
,reg_a
)=*os_context_pc_addr(context
);
184 case 0x31: /* fbeq */
185 if (*(os_context_float_register_addr(context
,reg_a
))==0) branch
= 1;
187 case 0x32: /* fblt */
188 if (*os_context_float_register_addr(context
,reg_a
)<0) branch
= 1;
190 case 0x33: /* fble */
191 if (*os_context_float_register_addr(context
,reg_a
)<=0) branch
= 1;
194 *os_context_register_addr(context
,reg_a
)=*os_context_pc_addr(context
);
197 case 0x35: /* fbne */
198 if (*os_context_register_addr(context
,reg_a
)!=0) branch
= 1;
200 case 0x36: /* fbge */
201 if (*os_context_float_register_addr(context
,reg_a
)>=0) branch
= 1;
203 case 0x37: /* fbgt */
204 if (*os_context_float_register_addr(context
,reg_a
)>0) branch
= 1;
206 case 0x38: /* blbc */
207 if ((*os_context_register_addr(context
,reg_a
)&1) == 0) branch
= 1;
210 if (*os_context_register_addr(context
,reg_a
)==0) branch
= 1;
213 if (*os_context_register_addr(context
,reg_a
)<0) branch
= 1;
216 if (*os_context_register_addr(context
,reg_a
)<=0) branch
= 1;
218 case 0x3c: /* blbs */
219 if ((*os_context_register_addr(context
,reg_a
)&1)!=0) branch
= 1;
222 if (*os_context_register_addr(context
,reg_a
)!=0) branch
= 1;
225 if (*os_context_register_addr(context
,reg_a
)>=0) branch
= 1;
228 if (*os_context_register_addr(context
,reg_a
)>0) branch
= 1;
236 static sigset_t orig_sigmask
;
238 /* Perform the instruction that we overwrote with a breakpoint. As we
239 * don't have a single-step facility, this means we have to:
240 * - put the instruction back
241 * - put a second breakpoint at the following instruction,
242 * set after_breakpoint and continue execution.
244 * When the second breakpoint is hit (very shortly thereafter, we hope)
245 * sigtrap_handler gets called again, but follows the AfterBreakpoint
247 * - puts a bpt back in the first breakpoint place (running across a
248 * breakpoint shouldn't cause it to be uninstalled)
249 * - replaces the second bpt with the instruction it was meant to be
255 void arch_do_displaced_inst(os_context_t
*context
,unsigned int orig_inst
)
257 /* Apparent off-by-one errors ahoy. If you consult the Alpha ARM,
258 * it will tell you that after a BPT, the saved PC is the address
259 * of the instruction _after_ the instruction that caused the trap.
261 * However, we decremented PC by 4 before calling the Lisp-level
262 * handler that calls this routine (see alpha-arch.c line 322 and
263 * friends) so when we get to this point PC is actually pointing
264 * at the BPT instruction itself. This is good, because this is
265 * where we want to restart execution when we do that */
267 unsigned int *pc
=(unsigned int *)(*os_context_pc_addr(context
));
268 unsigned int *next_pc
;
269 int op
= orig_inst
>> 26;;
271 orig_sigmask
= *os_context_sigmask_addr(context
);
272 sigaddset_blockable(os_context_sigmask_addr(context
));
274 /* Put the original instruction back. */
276 os_flush_icache((os_vm_address_t
)pc
, sizeof(unsigned long));
277 skipped_break_addr
= pc
;
279 /* Figure out where we will end up after running the displaced
281 if (op
== 0x1a || (op
&0xf) == 0x30) /* a branch */
282 /* The cast to long is just to shut gcc up. */
283 next_pc
= (unsigned int *)((long)emulate_branch(context
,orig_inst
));
287 /* Set the after breakpoint. */
288 displaced_after_inst
= *next_pc
;
289 *next_pc
= BREAKPOINT_INST
;
291 os_flush_icache((os_vm_address_t
)next_pc
, sizeof(unsigned long));
295 sigtrap_handler(int signal
, siginfo_t
*siginfo
, os_context_t
*context
)
299 /* Don't disallow recursive breakpoint traps. Otherwise, we can't */
300 /* use debugger breakpoints anywhere in here. */
301 sigset_t
*mask
=(os_context_sigmask_addr(context
));
304 /* this is different from how CMUCL does it. CMUCL used "call_pal
305 * PAL_gentrap", which doesn't do anything on Linux (unless NL0
306 * contains certain specific values). We use "bugchk" instead.
307 * It's (for our purposes) just the same as bpt but has a
308 * different opcode so we can test whether we're dealing with a
309 * breakpoint or a "system service" */
311 if ((*(unsigned int*)(*os_context_pc_addr(context
)-4))==BREAKPOINT_INST
) {
312 if (after_breakpoint
) {
313 /* see comments above arch_do_displaced_inst. This is where
314 * we reinsert the breakpoint that we removed earlier */
316 *os_context_pc_addr(context
) -=4;
317 *skipped_break_addr
= BREAKPOINT_INST
;
318 os_flush_icache((os_vm_address_t
)skipped_break_addr
,
319 sizeof(unsigned long));
320 skipped_break_addr
= NULL
;
321 *(unsigned int *)*os_context_pc_addr(context
) =
322 displaced_after_inst
;
323 os_flush_icache((os_vm_address_t
)*os_context_pc_addr(context
), sizeof(unsigned long));
324 *os_context_sigmask_addr(context
)= orig_sigmask
;
325 after_breakpoint
=0; /* false */
328 code
= trap_Breakpoint
;
330 /* a "system service" */
331 code
=*((u32
*)(*os_context_pc_addr(context
)));
334 case trap_PendingInterrupt
:
335 arch_skip_instruction(context
);
336 interrupt_handle_pending(context
);
340 fake_foreign_function_call(context
);
341 lose("%%primitive halt called; the party is over.\n");
345 interrupt_internal_error(signal
, siginfo
, context
, code
==trap_Cerror
);
348 case trap_Breakpoint
: /* call lisp-level handler */
349 *os_context_pc_addr(context
) -=4;
350 handle_breakpoint(signal
, siginfo
, context
);
353 case trap_FunEndBreakpoint
:
354 *os_context_pc_addr(context
) -=4;
355 *os_context_pc_addr(context
) =
356 (int)handle_fun_end_breakpoint(signal
, siginfo
, context
);
360 fprintf(stderr
, "unidetified breakpoint/trap %d\n",code
);
361 interrupt_handle_now(signal
, siginfo
, context
);
367 arch_get_fp_control()
369 return ieee_get_fp_control();
373 arch_set_fp_control(unsigned long fp
)
375 ieee_set_fp_control(fp
);
379 void arch_install_interrupt_handlers()
381 undoably_install_low_level_interrupt_handler(SIGTRAP
, sigtrap_handler
);
384 extern lispobj
call_into_lisp(lispobj fun
, lispobj
*args
, int nargs
);
386 lispobj
funcall0(lispobj function
)
388 lispobj
*args
= current_control_stack_pointer
;
390 return call_into_lisp(function
, args
, 0);
393 lispobj
funcall1(lispobj function
, lispobj arg0
)
395 lispobj
*args
= current_control_stack_pointer
;
397 current_control_stack_pointer
+= 1;
400 return call_into_lisp(function
, args
, 1);
403 lispobj
funcall2(lispobj function
, lispobj arg0
, lispobj arg1
)
405 lispobj
*args
= current_control_stack_pointer
;
407 current_control_stack_pointer
+= 2;
411 return call_into_lisp(function
, args
, 2);
414 lispobj
funcall3(lispobj function
, lispobj arg0
, lispobj arg1
, lispobj arg2
)
416 lispobj
*args
= current_control_stack_pointer
;
418 current_control_stack_pointer
+= 3;
423 return call_into_lisp(function
, args
, 3);