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.
24 #include "interrupt.h"
26 #include "breakpoint.h"
28 #include "pseudo-atomic.h"
30 #include "genesis/static-symbols.h"
31 #include "genesis/symbol.h"
33 #define BREAKPOINT_INST 0xcc /* INT3 */
34 #define UD2_INST 0x0b0f /* UD2 */
36 #ifndef LISP_FEATURE_UD2_BREAKPOINTS
37 #define BREAKPOINT_WIDTH 1
39 #define BREAKPOINT_WIDTH 2
42 unsigned long fast_random_state = 1;
49 arch_get_bad_addr(int sig, siginfo_t *code, os_context_t *context)
51 return (os_vm_address_t)code->si_addr;
57 * hacking signal contexts
59 * (This depends both on architecture, which determines what we might
60 * want to get to, and on OS, which determines how we get to it.)
63 os_context_register_t *
64 context_eflags_addr(os_context_t *context)
66 #if defined __linux__ || defined __sun
67 /* KLUDGE: As of kernel 2.2.14 on Red Hat 6.2, there's code in the
68 * <sys/ucontext.h> file to define symbolic names for offsets into
69 * gregs[], but it's conditional on __USE_GNU and not defined, so
70 * we need to do this nasty absolute index magic number thing
72 return &context->uc_mcontext.gregs[17];
73 #elif defined __FreeBSD__
74 return &context->uc_mcontext.mc_rflags;
75 #elif defined LISP_FEATURE_DARWIN
76 return CONTEXT_ADDR_FROM_STEM(rflags);
77 #elif defined __OpenBSD__
78 return &context->sc_rflags;
79 #elif defined __NetBSD__
80 return CONTEXT_ADDR_FROM_STEM(RFLAGS);
82 return (os_context_register_t*)&context->win32_context->EFlags;
88 void arch_skip_instruction(os_context_t *context)
90 /* Assuming we get here via an INT3 xxx instruction, the PC now
91 * points to the interrupt code (a Lisp value) so we just move
92 * past it. Skip the code; after that, if the code is an
93 * error-trap or cerror-trap then skip the data bytes that follow. */
99 /* Get and skip the Lisp interrupt code. */
100 code = *(char*)(*os_context_pc_addr(context))++;
105 /* Lisp error arg vector length */
106 vlen = *(char*)(*os_context_pc_addr(context))++;
107 /* Skip Lisp error arg data bytes. */
109 ++*os_context_pc_addr(context);
113 case trap_Breakpoint: /* not tested */
114 case trap_FunEndBreakpoint: /* not tested */
117 #ifdef LISP_FEATURE_SB_SAFEPOINT
118 case trap_GlobalSafepoint:
119 case trap_CspSafepoint:
121 case trap_PendingInterrupt:
123 case trap_SingleStepAround:
124 case trap_SingleStepBefore:
125 /* only needed to skip the Code */
129 fprintf(stderr,"[arch_skip_inst invalid code %ld\n]\n",code);
134 "/[arch_skip_inst resuming at %x]\n",
135 *os_context_pc_addr(context)));
139 arch_internal_error_arguments(os_context_t *context)
141 return 1 + (unsigned char *)(*os_context_pc_addr(context));
145 arch_pseudo_atomic_atomic(os_context_t *context)
147 return get_pseudo_atomic_atomic(arch_os_get_current_thread());
151 arch_set_pseudo_atomic_interrupted(os_context_t *context)
153 struct thread *thread = arch_os_get_current_thread();
154 set_pseudo_atomic_interrupted(thread);
158 arch_clear_pseudo_atomic_interrupted(os_context_t *context)
160 struct thread *thread = arch_os_get_current_thread();
161 clear_pseudo_atomic_interrupted(thread);
165 * This stuff seems to get called for TRACE and debug activity.
169 arch_install_breakpoint(void *pc)
171 unsigned int result = *(unsigned int*)pc;
173 #ifndef LISP_FEATURE_UD2_BREAKPOINTS
174 *(char*)pc = BREAKPOINT_INST; /* x86 INT3 */
175 *((char*)pc+1) = trap_Breakpoint; /* Lisp trap code */
177 *(char*)pc = UD2_INST & 0xff;
178 *((char*)pc+1) = UD2_INST >> 8;
179 *((char*)pc+2) = trap_Breakpoint;
186 arch_remove_breakpoint(void *pc, unsigned int orig_inst)
188 *((char *)pc) = orig_inst & 0xff;
189 *((char *)pc + 1) = (orig_inst & 0xff00) >> 8;
190 #if BREAKPOINT_WIDTH > 1
191 *((char *)pc + 2) = (orig_inst & 0xff0000) >> 16;
195 /* When single stepping, single_stepping holds the original instruction
197 unsigned int *single_stepping = NULL;
198 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
199 unsigned int single_step_save1;
200 unsigned int single_step_save2;
201 unsigned int single_step_save3;
205 arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst)
207 unsigned int *pc = (unsigned int*)(*os_context_pc_addr(context));
209 /* Put the original instruction back. */
210 arch_remove_breakpoint(pc, orig_inst);
212 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
213 /* Install helper instructions for the single step:
214 * pushf; or [esp],0x100; popf. */
215 single_step_save1 = *(pc-3);
216 single_step_save2 = *(pc-2);
217 single_step_save3 = *(pc-1);
218 *(pc-3) = 0x9c909090;
219 *(pc-2) = 0x00240c81;
220 *(pc-1) = 0x9d000001;
222 *context_eflags_addr(context) |= 0x100;
225 single_stepping = pc;
227 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
228 *os_context_pc_addr(context) = (os_context_register_t)((char *)pc - 9);
233 arch_handle_breakpoint(os_context_t *context)
235 *os_context_pc_addr(context) -= BREAKPOINT_WIDTH;
236 handle_breakpoint(context);
240 arch_handle_fun_end_breakpoint(os_context_t *context)
242 *os_context_pc_addr(context) -= BREAKPOINT_WIDTH;
243 *os_context_pc_addr(context) =
244 (uword_t)handle_fun_end_breakpoint(context);
248 arch_handle_single_step_trap(os_context_t *context, int trap)
250 arch_skip_instruction(context);
251 /* On x86-64 the fdefn / function is always in RAX, so we pass
252 * 0 as the register_offset. */
253 handle_single_step_trap(context, trap, 0);
258 restore_breakpoint_from_single_step(os_context_t * context)
260 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
261 /* Un-install single step helper instructions. */
262 *(single_stepping-3) = single_step_save1;
263 *(single_stepping-2) = single_step_save2;
264 *(single_stepping-1) = single_step_save3;
266 *context_eflags_addr(context) &= ~0x100;
268 /* Re-install the breakpoint if possible. */
269 if (((char *)*os_context_pc_addr(context) >
270 (char *)single_stepping) &&
271 ((char *)*os_context_pc_addr(context) <=
272 (char *)single_stepping + BREAKPOINT_WIDTH)) {
273 fprintf(stderr, "warning: couldn't reinstall breakpoint\n");
275 arch_install_breakpoint(single_stepping);
278 single_stepping = NULL;
283 sigtrap_handler(int signal, siginfo_t *info, os_context_t *context)
287 if (single_stepping) {
288 restore_breakpoint_from_single_step(context);
292 /* This is just for info in case the monitor wants to print an
294 access_control_stack_pointer(arch_os_get_current_thread()) =
295 (lispobj *)*os_context_sp_addr(context);
297 /* On entry %eip points just after the INT3 byte and aims at the
298 * 'kind' value (eg trap_Cerror). For error-trap and Cerror-trap a
299 * number of bytes will follow, the first is the length of the byte
300 * arguments to follow. */
301 trap = *(unsigned char *)(*os_context_pc_addr(context));
303 handle_trap(context, trap);
307 sigill_handler(int signal, siginfo_t *siginfo, os_context_t *context) {
308 /* Triggering SIGTRAP using int3 is unreliable on OS X/x86, so
309 * we need to use illegal instructions for traps.
311 #if defined(LISP_FEATURE_UD2_BREAKPOINTS) && !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER)
312 if (*((unsigned short *)*os_context_pc_addr(context)) == UD2_INST) {
313 *os_context_pc_addr(context) += 2;
314 return sigtrap_handler(signal, siginfo, context);
318 fake_foreign_function_call(context);
319 lose("Unhandled SIGILL.");
322 #ifdef X86_64_SIGFPE_FIXUP
323 #define MXCSR_IE (0x01) /* Invalid Operation */
324 #define MXCSR_DE (0x02) /* Denormal */
325 #define MXCSR_ZE (0x04) /* Devide-by-Zero */
326 #define MXCSR_OE (0x08) /* Overflow */
327 #define MXCSR_UE (0x10) /* Underflow */
328 #define MXCSR_PE (0x20) /* Precision */
331 mxcsr_to_code(unsigned int mxcsr)
333 /* Extract unmasked exception bits. */
334 mxcsr &= ~(mxcsr >> 7) & 0x3F;
336 /* This order is defined at "Intel 64 and IA-32 Architectures
337 * Software Developerfs Manual" Volume 1: "Basic Architecture",
338 * 4.9.2 "Floating-Point Exception Priority". */
339 if (mxcsr & MXCSR_IE)
341 else if (mxcsr & MXCSR_ZE)
343 else if (mxcsr & MXCSR_DE)
345 else if (mxcsr & MXCSR_OE)
347 else if (mxcsr & MXCSR_UE)
349 else if (mxcsr & MXCSR_PE)
356 sigfpe_handler(int signal, siginfo_t *siginfo, os_context_t *context)
358 unsigned int *mxcsr = arch_os_context_mxcsr_addr(context);
360 if (siginfo->si_code == 0) { /* XMM exception */
361 siginfo->si_code = mxcsr_to_code(*mxcsr);
363 /* Clear sticky exception flag. */
367 interrupt_handle_now(signal, siginfo, context);
372 arch_install_interrupt_handlers()
374 SHOW("entering arch_install_interrupt_handlers()");
376 /* Note: The old CMU CL code here used sigtrap_handler() to handle
377 * SIGILL as well as SIGTRAP. I couldn't see any reason to do
378 * things that way. So, I changed to separate handlers when
379 * debugging a problem on OpenBSD, where SBCL wasn't catching
380 * SIGILL properly, but was instead letting the process be
381 * terminated with an "Illegal instruction" output. If this change
382 * turns out to break something (maybe breakpoint handling on some
383 * OS I haven't tested on?) and we have to go back to the old CMU
384 * CL way, I hope there will at least be a comment to explain
385 * why.. -- WHN 2001-06-07 */
386 #if !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER) && !defined(LISP_FEATURE_WIN32)
387 undoably_install_low_level_interrupt_handler(SIGILL , sigill_handler);
388 undoably_install_low_level_interrupt_handler(SIGTRAP, sigtrap_handler);
391 #if defined(X86_64_SIGFPE_FIXUP) && !defined(LISP_FEATURE_WIN32)
392 undoably_install_low_level_interrupt_handler(SIGFPE, sigfpe_handler);
395 SHOW("returning from arch_install_interrupt_handlers()");
398 #ifdef LISP_FEATURE_LINKAGE_TABLE
399 /* FIXME: It might be cleaner to generate these from the lisp side of
404 arch_write_linkage_table_jmp(char * reloc, void * fun)
406 uword_t addr = (uword_t) fun;
409 *reloc++ = 0xFF; /* Opcode for near jump to absolute reg/mem64. */
410 *reloc++ = 0x25; /* ModRM #b00 100 101, i.e. RIP-relative. */
411 *reloc++ = 0x00; /* 32-bit displacement field = 0 */
412 *reloc++ = 0x00; /* ... */
413 *reloc++ = 0x00; /* ... */
414 *reloc++ = 0x00; /* ... */
416 for (i = 0; i < 8; i++) {
417 *reloc++ = addr & 0xff;
421 /* write a nop for good measure. */
426 arch_write_linkage_table_ref(void * reloc, void * data)
428 *(uword_t *)reloc = (uword_t)data;
433 /* These setup and check *both* the sse2 and x87 FPUs. While lisp code
434 only uses the sse2 FPU, other code (such as libc) may use the x87 FPU.
442 /* return the x87 exception flags ored in with the sse2
443 * control+status flags */
444 asm ("fnstsw %0" : "=m" (temp));
447 asm ("stmxcsr %0" : "=m" (temp));
449 /* flip exception mask bits */
450 return result ^ (0x3F << 7);
456 unsigned short unused1;
458 unsigned short unused2;
459 unsigned int other_regs[5];
463 arch_set_fp_modes(unsigned int mxcsr)
468 /* turn trap enable bits into exception mask */
472 asm ("fnstenv %0" : "=m" (f_env));
473 /* set control word: always long double precision
474 * get traps and rounding from mxcsr word */
475 f_env.cw = 0x300 | ((mxcsr >> 7) & 0x3F) | (((mxcsr >> 13) & 0x3) << 10);
476 /* set status word: only override exception flags, from mxcsr */
478 f_env.sw |= (mxcsr & 0x3F);
480 asm ("fldenv %0" : : "m" (f_env));
482 /* now, simply, load up the mxcsr register */
484 asm ("ldmxcsr %0" : : "m" (temp));