From ffa76538f07d930e72cc85a31641cdcc4c402f82 Mon Sep 17 00:00:00 2001 From: Juho Snellman Date: Fri, 7 Apr 2006 16:33:13 +0000 Subject: [PATCH] 0.9.11.23: Oops. Realize why the single-stepping code deleted in .20 was actually necessary after all. Restore most of it, add a test, and fix the original problem (extra trace traps on Solaris) by munging the processor's single-step flag in a different way. --- src/runtime/bsd-os.h | 5 ++++ src/runtime/x86-64-arch.c | 30 +++++++++++++++++++ src/runtime/x86-arch.c | 72 ++++++++++++++++++++++++++++++++++++++++++++- version.lisp-expr | 2 +- 4 files changed, 107 insertions(+), 2 deletions(-) diff --git a/src/runtime/bsd-os.h b/src/runtime/bsd-os.h index 474f686..4f72a66 100644 --- a/src/runtime/bsd-os.h +++ b/src/runtime/bsd-os.h @@ -49,6 +49,11 @@ typedef struct sigaltstack stack_t; #include typedef ucontext_t os_context_t; +/* As the sbcl-devel message from Raymond Wiker 2000-12-01, FreeBSD + * (unlike Linux and OpenBSD) doesn't let us tweak the CPU's single + * step flag bit by messing with the flags stored in a signal context, + * so we need to implement single stepping in a more roundabout way. */ +#define CANNOT_GET_TO_SINGLE_STEP_FLAG #define SIG_MEMORY_FAULT SIGSEGV /* Sometime in late 2005 FreeBSD was changed to signal SIGSEGV instead * of SIGBUS for memory faults, as required by POSIX. In order to diff --git a/src/runtime/x86-64-arch.c b/src/runtime/x86-64-arch.c index a0d8276..6ee2690 100644 --- a/src/runtime/x86-64-arch.c +++ b/src/runtime/x86-64-arch.c @@ -162,6 +162,9 @@ arch_remove_breakpoint(void *pc, unsigned int orig_inst) *((char *)pc + 1) = (orig_inst & 0xff00) >> 8; } +/* When single stepping, single_stepping holds the original instruction + * PC location. */ +unsigned int *single_stepping = NULL; void arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) @@ -171,7 +174,12 @@ arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) /* Put the original instruction back. */ *((char *)pc) = orig_inst & 0xff; *((char *)pc + 1) = (orig_inst & 0xff00) >> 8; + + *context_eflags_addr(context) |= 0x100; + + single_stepping = pc; } + void sigtrap_handler(int signal, siginfo_t *info, void *void_context) @@ -180,11 +188,33 @@ sigtrap_handler(int signal, siginfo_t *info, void *void_context) os_context_t *context = (os_context_t*)void_context; unsigned int trap; + if (single_stepping && (signal==SIGTRAP)) + { + *context_eflags_addr(context) ^= 0x100; + + /* Re-install the breakpoint if possible. */ + if (*os_context_pc_addr(context) == (int)single_stepping + 1) { + fprintf(stderr, "warning: couldn't reinstall breakpoint\n"); + } else { + *((char *)single_stepping) = BREAKPOINT_INST; /* x86 INT3 */ + *((char *)single_stepping+1) = trap_Breakpoint; + } + + single_stepping = NULL; + return; + } + /* This is just for info in case the monitor wants to print an * approximation. */ current_control_stack_pointer = (lispobj *)*os_context_sp_addr(context); + /* FIXME: CMUCL puts the float control restoration code here. + Thus, it seems to me that single-stepping won't restore the + float control. Since SBCL currently doesn't support + single-stepping (as far as I can tell) this is somewhat moot, + but it might be worth either moving this code up or deleting + the single-stepping code entirely. -- CSR, 2002-07-15 */ #ifdef LISP_FEATURE_LINUX os_restore_fp_control(context); #endif diff --git a/src/runtime/x86-arch.c b/src/runtime/x86-arch.c index 1cb0de3..c3f9268 100644 --- a/src/runtime/x86-arch.c +++ b/src/runtime/x86-arch.c @@ -169,6 +169,14 @@ arch_remove_breakpoint(void *pc, unsigned int orig_inst) *((char *)pc + 1) = (orig_inst & 0xff00) >> 8; } +/* When single stepping, single_stepping holds the original instruction + * PC location. */ +unsigned int *single_stepping = NULL; +#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG +unsigned int single_step_save1; +unsigned int single_step_save2; +unsigned int single_step_save3; +#endif void arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) @@ -178,24 +186,86 @@ arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst) /* Put the original instruction back. */ *((char *)pc) = orig_inst & 0xff; *((char *)pc + 1) = (orig_inst & 0xff00) >> 8; + +#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG + /* Install helper instructions for the single step: + * pushf; or [esp],0x100; popf. */ + single_step_save1 = *(pc-3); + single_step_save2 = *(pc-2); + single_step_save3 = *(pc-1); + *(pc-3) = 0x9c909090; + *(pc-2) = 0x00240c81; + *(pc-1) = 0x9d000001; +#else + *context_eflags_addr(context) |= 0x100; +#endif + + single_stepping = pc; + +#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG + *os_context_pc_addr(context) = (char *)pc - 9; +#endif } - void sigtrap_handler(int signal, siginfo_t *info, void *void_context) { os_context_t *context = (os_context_t*)void_context; unsigned int trap; +#ifndef LISP_FEATURE_WIN32 + if (single_stepping && (signal==SIGTRAP)) + { + /* fprintf(stderr,"* single step trap %x\n", single_stepping); */ + +#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG + /* Un-install single step helper instructions. */ + *(single_stepping-3) = single_step_save1; + *(single_stepping-2) = single_step_save2; + *(single_stepping-1) = single_step_save3; +#else + *context_eflags_addr(context) &= ~0x100; +#endif + /* Re-install the breakpoint if possible. */ + if (*os_context_pc_addr(context) == (int)single_stepping + 1) { + fprintf(stderr, "warning: couldn't reinstall breakpoint\n"); + } else { + *((char *)single_stepping) = BREAKPOINT_INST; /* x86 INT3 */ + *((char *)single_stepping+1) = trap_Breakpoint; + } + + single_stepping = NULL; + return; + } +#endif + /* This is just for info in case the monitor wants to print an * approximation. */ current_control_stack_pointer = (lispobj *)*os_context_sp_addr(context); + /* FIXME: CMUCL puts the float control restoration code here. + Thus, it seems to me that single-stepping won't restore the + float control. Since SBCL currently doesn't support + single-stepping (as far as I can tell) this is somewhat moot, + but it might be worth either moving this code up or deleting + the single-stepping code entirely. -- CSR, 2002-07-15 */ #ifdef LISP_FEATURE_LINUX os_restore_fp_control(context); #endif + +#ifdef LISP_FEATURE_SUNOS + /* For some reason the breakpoints that :ENCAPSULATE NIL tracing sets up + * cause a trace trap (i.e. processor single-stepping trap) on the following + * instruction on Solaris 10/x86. -- JES, 2006-04-07 + */ + if (info->si_code == TRAP_TRACE) { + lose("foo"); + return; + } +#endif + /* On entry %eip points just after the INT3 byte and aims at the * 'kind' value (eg trap_Cerror). For error-trap and Cerror-trap a * number of bytes will follow, the first is the length of the byte diff --git a/version.lisp-expr b/version.lisp-expr index f520e43..65d7f01 100644 --- a/version.lisp-expr +++ b/version.lisp-expr @@ -17,4 +17,4 @@ ;;; checkins which aren't released. (And occasionally for internal ;;; versions, especially for internal versions off the main CVS ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".) -"0.9.11.22" +"0.9.11.23" -- 1.7.10.4