cmucl-cvs

cmucl-cvs@common-lisp.net

2904 discussions

[Git][cmucl/cmucl][issue-97-define-ud2-inst] First cut at using UD1 instead of UD2
by Raymond Toy 09 Apr '21

09 Apr '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 93d7cf02 by Raymond Toy at 2021-04-09T13:45:34-07:00 First cut at using UD1 instead of UD2 Disassembly mostly works, except that for the pending interrupt trap, we print "ud1 ecx, cl" instead of "ud1 ecx, ecx" which is what gdb prints. More work still needed. - - - - - 4 changed files: - src/compiler/x86/insts.lisp - src/compiler/x86/macros.lisp - src/compiler/x86/system.lisp - src/lisp/x86-assem.S Changes: ===================================== src/compiler/x86/insts.lisp ===================================== @@ -2062,12 +2062,13 @@ (code :field (byte 8 8))) -(disassem:define-instruction-format (ud1 24 :default-printer '(:name :tab code)) - (op :fields (list (byte 8 0) (byte 8 8)) :value '(#xb00001111 #b10111001)) - (code :field (byte 8 16))) - -(define-emitter emit-ud1-inst 24 - (byte 8 0) (byte 8 8) (byte 8 16)) +(disassem:define-instruction-format + (ud1 24 :default-printer '(:name :tab reg ", " reg/mem)) + (prefix :field (byte 8 0) :value #b00001111) + (op :field (byte 8 8) :value #b10111001) + (reg/mem :fields (list (byte 2 22) (byte 3 16)) + :type 'reg/mem) + (reg :field (byte 3 19) :type 'word-reg)) (defun snarf-error-junk (sap offset &optional length-only) (let* ((length (system:sap-ref-8 sap offset)) @@ -2099,34 +2100,41 @@ (sc-offsets) (lengths)))))))) -(defun break-control (chunk inst stream dstate) +(defun ud1-control (chunk inst stream dstate) (declare (ignore inst)) (flet ((nt (x) (if stream (disassem:note x dstate)))) - (case (ud1-code chunk dstate) + (case (ldb (byte 6 16) chunk) (#.vm:error-trap - (nt "Error trap") + (nt #.(format nil "Error trap: ~D" vm:error-trap)) (disassem:handle-break-args #'snarf-error-junk stream dstate)) (#.vm:cerror-trap - (nt "Cerror trap") + (nt #.(format nil "Cerror trap: ~D" vm:cerror-trap)) (disassem:handle-break-args #'snarf-error-junk stream dstate)) (#.vm:breakpoint-trap - (nt "Breakpoint trap")) + (nt #.(format nil "Breakpoint trap: ~D" vm:breakpoint-trap))) (#.vm:pending-interrupt-trap - (nt "Pending interrupt trap")) + (nt #.(format nil "Pending interrupt trap: ~D" vm:pending-interrupt-trap))) (#.vm:halt-trap - (nt "Halt trap")) + (nt #.(format nil "Halt trap: ~D" vm:halt-trap))) (#.vm:function-end-breakpoint-trap - (nt "Function end breakpoint trap")) + (nt #.(format nil "Function end breakpoint trap: ~D" vm:function-end-breakpoint-trap))) ))) -;; This is really the int3 instruction. -(define-instruction break (segment code) +;; The ud1 instruction where we smash the code (trap type) into the +;; mod r/m byte. We don't care about what that actually encodes to. +;; We just want the trap code in the third byte of the instruction. +(define-instruction ud1 (segment code) (:declare (type (unsigned-byte 8) code)) - (:printer ud1 ((op '(#b00001111 #b10111001))) - '(:name :tab code) - :control #'break-control) + (:printer ud1 ((op #b10111001)) + :default + :control #'ud1-control) (:emitter - (emit-ud1-inst segment #b00001111 #b10111001 code))) + (emit-byte segment #x0f) + (emit-byte segment #xb9) + (emit-mod-reg-r/m-byte segment + #b11 + (ldb (byte 3 3) code) + (ldb (byte 3 0) code)))) #+nil (define-instruction ud2 (segment) ===================================== src/compiler/x86/macros.lisp ===================================== @@ -246,7 +246,7 @@ `((let ((vop ,vop)) (when vop (note-this-location vop :internal-error))) - (inst break ,kind) ; eg trap_Xyyy + (inst ud1 ,kind) ; eg trap_Xyyy (let ((,vector (make-array 8 :element-type '(unsigned-byte 8) :fill-pointer 0 :adjustable t))) (write-var-integer (error-number-or-lose ',code) ,vector) @@ -340,7 +340,7 @@ (- other-pointer-type))) 0) (inst jmp :eq ,label) - (inst break pending-interrupt-trap) + (inst ud1 pending-interrupt-trap) (emit-label ,label))))) ===================================== src/compiler/x86/system.lisp ===================================== @@ -284,11 +284,11 @@ (:policy :fast-safe) (:translate unix::do-pending-interrupt) (:generator 1 - (inst break pending-interrupt-trap))) + (inst ud1 pending-interrupt-trap))) (define-vop (halt) (:generator 1 - (inst break halt-trap))) + (inst ud1 halt-trap))) (defknown float-wait () (values)) (define-vop (float-wait) ===================================== src/lisp/x86-assem.S ===================================== @@ -18,6 +18,11 @@ #include "internals.h" #include "lispregs.h" +#define TRAP_CODE(code) \ + .byte 0x0f ; \ + .byte 0xb9 ; \ + .byte 0xc0 + code + /* Minimize conditionalization for different OS naming schemes */ #ifdef DARWIN #define GNAME(var) _##var @@ -244,7 +249,9 @@ ENDFUNC(sse_restore) * The undefined-function trampoline. */ FUNCDEF(undefined_tramp) - INT3 + # UD1 + .byte 0x0f + .byte 0xb9 .byte trap_Error /* Number of argument bytes */ .byte 2 @@ -286,8 +293,17 @@ multiple_value_return: .globl GNAME(function_end_breakpoint_trap) GNAME(function_end_breakpoint_trap): - UD2 - .byte trap_FunctionEndBreakpoint + /* + ud1 0(%ecx), %ecx + ud1 %ecx, %edx + .byte 0x0f + .byte 0xb9 + .byte 0xc0 + trap_PendingInterrupt + */ + # UD1 + .byte 0x0f + .byte 0xb9 + .byte 0xc0 + trap_FunctionEndBreakpoint hlt # Should never return here. .globl GNAME(function_end_breakpoint_end) @@ -295,14 +311,18 @@ GNAME(function_end_breakpoint_end): FUNCDEF(do_pending_interrupt) - ud2 + # UD1 + .byte 0x0f + .byte 0xb9 .byte trap_PendingInterrupt ret ENDFUNC(do_pending_interrupt) #ifdef trap_DynamicSpaceOverflowError FUNCDEF(do_dynamic_space_overflow_error) - ud2 + # UD1 + .byte 0x0f + .byte 0xb9 .byte trap_DynamicSpaceOverflowError ret ENDFUNC(do_dynamic_space_overflow_error) @@ -310,7 +330,9 @@ ENDFUNC(do_dynamic_space_overflow_error) #ifdef trap_DynamicSpaceOverflowWarning FUNCDEF(do_dynamic_space_overflow_warning) - ud2 + # UD1 + .byte 0x0f + .byte 0xb9 .byte trap_DynamicSpaceOverflowWarning ret ENDFUNC(do_dynamic_space_overflow_warning) @@ -493,7 +515,9 @@ FUNCDEF(undefined_foreign_symbol_trap) movl 8(%ebp),%eax /* Now trap to Lisp */ - ud2 + # UD1 + .byte 0x0f + .byte 0xb9 .byte trap_Error /* Number of argument bytes */ .byte 2 View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/93d7cf02396314c79a176f1… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/93d7cf02396314c79a176f1… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] Use UD1 instead of UD2
by Raymond Toy 08 Apr '21

08 Apr '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: f8abdf9a by Raymond Toy at 2021-04-07T17:36:51-07:00 Use UD1 instead of UD2 The definition of BTC and friends conflicted with UD1, so fix that. Without this, our UD1 instruction got printed out as BTC. Update x86-arch to look for ud1 instead of ud2. - - - - - 2 changed files: - src/compiler/x86/insts.lisp - src/lisp/x86-arch.c Changes: ===================================== src/compiler/x86/insts.lisp ===================================== @@ -1778,8 +1778,8 @@ (disassem:define-instruction-format (bit-test-reg/mem 24 :default-printer '(:name :tab reg/mem ", " reg)) - (prefix :field (byte 8 0) :value #b0001111) - (op :field (byte 3 11)) + (prefix :field (byte 8 0) :value #b0001111) + (op :field (byte 8 8)) ;;(test :fields (list (byte 2 14) (byte 3 8))) (reg/mem :fields (list (byte 2 22) (byte 3 16)) :type 'reg/mem) @@ -1788,22 +1788,22 @@ (imm)) (define-instruction bt (segment src index) - (:printer bit-test-reg/mem ((op #b100))) + (:printer bit-test-reg/mem ((op #b10100011))) (:emitter (emit-bit-test-and-mumble segment src index #b100))) (define-instruction btc (segment src index) - (:printer bit-test-reg/mem ((op #b111))) + (:printer bit-test-reg/mem ((op #b10111011))) (:emitter (emit-bit-test-and-mumble segment src index #b111))) (define-instruction btr (segment src index) - (:printer bit-test-reg/mem ((op #b110))) + (:printer bit-test-reg/mem ((op #b10110011))) (:emitter (emit-bit-test-and-mumble segment src index #b110))) (define-instruction bts (segment src index) - (:printer bit-test-reg/mem ((op #b101))) + (:printer bit-test-reg/mem ((op #b10101011))) (:emitter (emit-bit-test-and-mumble segment src index #b101))) @@ -2062,11 +2062,11 @@ (code :field (byte 8 8))) -(disassem:define-instruction-format (break 24 :default-printer '(:name :tab code)) - (op :fields (list (byte 8 0) (byte 8 8)) :value '(#xb00001111 #b00001011)) +(disassem:define-instruction-format (ud1 24 :default-printer '(:name :tab code)) + (op :fields (list (byte 8 0) (byte 8 8)) :value '(#xb00001111 #b10111001)) (code :field (byte 8 16))) -(define-emitter emit-break-inst 24 +(define-emitter emit-ud1-inst 24 (byte 8 0) (byte 8 8) (byte 8 16)) (defun snarf-error-junk (sap offset &optional length-only) @@ -2102,7 +2102,7 @@ (defun break-control (chunk inst stream dstate) (declare (ignore inst)) (flet ((nt (x) (if stream (disassem:note x dstate)))) - (case (break-code chunk dstate) + (case (ud1-code chunk dstate) (#.vm:error-trap (nt "Error trap") (disassem:handle-break-args #'snarf-error-junk stream dstate)) @@ -2122,11 +2122,11 @@ ;; This is really the int3 instruction. (define-instruction break (segment code) (:declare (type (unsigned-byte 8) code)) - (:printer break ((op '(#b00001111 #b00001011))) + (:printer ud1 ((op '(#b00001111 #b10111001))) '(:name :tab code) :control #'break-control) (:emitter - (emit-break-inst segment #b00001111 #b00001011 code))) + (emit-ud1-inst segment #b00001111 #b10111001 code))) #+nil (define-instruction ud2 (segment) ===================================== src/lisp/x86-arch.c ===================================== @@ -361,14 +361,14 @@ sigill_handler(HANDLER_ARGS) (stderr, "pc %x\n", *(unsigned short *)SC_PC(context))); /* - * Make sure the trapping instruction is UD2. Abort if not. + * Make sure the trapping instruction is UD1. Abort if not. * * TODO: aborting is probably not the best idea. Could get here * from other illegal instructions in, say, C code? Maybe we * should call interrupt_handle_now, as we do below for an unknown * trap code? */ - if (*(unsigned short *) SC_PC(context) == 0x0b0f) { + if (*(unsigned short *) SC_PC(context) == 0xb90f) { trap = *(((char *)SC_PC(context)) + 2); } else { abort(); View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/f8abdf9a5d35ba0195ed03b… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/f8abdf9a5d35ba0195ed03b… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] 2 commits: Remove debugging prints
by Raymond Toy 28 Mar '21

28 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 07da205f by Raymond Toy at 2021-03-28T08:02:04-07:00 Remove debugging prints - - - - - a99cd825 by Raymond Toy at 2021-03-28T08:02:24-07:00 Clean up and add comments on how things work. - - - - - 4 changed files: - src/code/debug-int.lisp - src/lisp/breakpoint.c - src/lisp/x86-arch.c - src/lisp/x86-arch.h Changes: ===================================== src/code/debug-int.lisp ===================================== @@ -4477,9 +4477,6 @@ The result is a symbol or nil if the routine cannot be found." ;;; (defun handle-breakpoint (offset component signal-context) (let ((data (breakpoint-data component offset nil))) - (format t "(handle-breakpoint ~A ~A ~A)~%" - offset component signal-context) - (format t " data = ~A~%" data) (unless data (error (intl:gettext "Unknown breakpoint in ~S at offset ~S.") (debug-function-name (debug-function-from-pc component offset)) ===================================== src/lisp/breakpoint.c ===================================== @@ -192,8 +192,6 @@ compute_offset(os_context_t * scp, lispobj code, boolean function_end) static int compute_offset(os_context_t * scp, lispobj code, boolean function_end) { - extern unsigned int debug_handlers; - DPRINTF(debug_handlers, (stderr, "compute_offset: code = 0x%lx\n", code)); if (code == NIL) @@ -257,8 +255,6 @@ handle_breakpoint(int signal, int subcode, os_context_t * scp) void handle_breakpoint(int signal, int subcode, os_context_t * scp) { - extern unsigned int debug_handlers; - lispobj code, scp_sap = alloc_sap(scp); fake_foreign_function_call(scp); ===================================== src/lisp/x86-arch.c ===================================== @@ -153,7 +153,8 @@ arch_skip_instruction(os_context_t * context) /* Get and skip the lisp error code. */ char* pc = (char *) SC_PC(context); - pc += 2; /* skip 0x0f and 0x0b */ + /* Skip over the UD2 inst (0x0f, 0x0b) */ + pc += 2; code = *pc++; SC_PC(context) = (unsigned long) pc; @@ -173,6 +174,8 @@ arch_skip_instruction(os_context_t * context) break; case trap_Breakpoint: + lose("Unexpected breakpoint trap in arch_skip_instruction\n"); + break; case trap_FunctionEndBreakpoint: break; @@ -231,6 +234,11 @@ arch_remove_breakpoint(void *pc, unsigned long orig_inst) (stderr, "arch_remove_breakpoint: %p orig %lx\n", pc, orig_inst)); unsigned char *ptr = (unsigned char *) pc; + /* + * Just restore all the bytes from orig_inst. Should we just + * re-install just the one byte that was taken by the int3 + * instruction? + */ ptr[0] = orig_inst & 0xff; ptr[1] = (orig_inst >> 8) & 0xff; ptr[2] = (orig_inst >> 16) & 0xff; @@ -267,8 +275,12 @@ arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst) *((char *) pc) = orig_inst & 0xff; + /* + * If we have the SC_EFLAGS macro, we can enable single-stepping + * by setting the bit. Otherwise, we need a more complicated way + * of enabling single-stepping. + */ #ifdef SC_EFLAGS - /* Enable single-stepping */ SC_EFLAGS(context) |= 0x100; #else @@ -305,6 +317,11 @@ arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst) } +/* + * Handles the break instruction from lisp, which is now UD2 followed + * by the trap code. In particular, this does not handle the + * breakpoint traps. + */ void sigill_handler(HANDLER_ARGS) { @@ -322,9 +339,6 @@ sigill_handler(HANDLER_ARGS) *((unsigned char*)SC_PC(context) + 3), *((unsigned char*)SC_PC(context) + 4))); - if (single_stepping) { - lose("sigill handler with single-stepping enabled?\n"); - } /* This is just for info in case monitor wants to print an approx */ current_control_stack_pointer = (unsigned long *) SC_SP(os_context); @@ -346,6 +360,14 @@ sigill_handler(HANDLER_ARGS) DPRINTF(debug_handlers, (stderr, "pc %x\n", *(unsigned short *)SC_PC(context))); + /* + * Make sure the trapping instruction is UD2. Abort if not. + * + * TODO: aborting is probably not the best idea. Could get here + * from other illegal instructions in, say, C code? Maybe we + * should call interrupt_handle_now, as we do below for an unknown + * trap code? + */ if (*(unsigned short *) SC_PC(context) == 0x0b0f) { trap = *(((char *)SC_PC(context)) + 2); } else { @@ -413,6 +435,9 @@ sigill_handler(HANDLER_ARGS) } } +/* + * Handles the breakpoint trap (int3) and also single-stepping + */ void sigtrap_handler(HANDLER_ARGS) { @@ -464,6 +489,13 @@ sigtrap_handler(HANDLER_ARGS) DPRINTF(debug_handlers, (stderr, "*C break\n")); + /* + * The int3 instruction causes a trap that leaves us just after + * the instruction. Backup one so we're at the beginning. This + * is really important so that when we handle the breakpoint, the + * offset of the instruction matches where Lisp thinks the + * breakpoint was placed. + */ SC_PC(os_context) -= 1; handle_breakpoint(signal, CODE(code), os_context); ===================================== src/lisp/x86-arch.h ===================================== @@ -9,6 +9,13 @@ extern int arch_support_sse2(void); extern boolean os_support_sse2(void); +/* + * Set to non-zero to enable debug prints for debugging the sigill and + * sigtrap handlers and for debugging breakpoints. + */ +extern unsigned int debug_handlers; + + /* * Define macro to allocate a local array of the appropriate size * where the fpu state can be stored. View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d039eb90c6e86457c946c9… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d039eb90c6e86457c946c9… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] 4 commits: Clean up changes.
by Raymond Toy 27 Mar '21

27 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: b43c4c55 by Raymond Toy at 2021-03-27T11:21:18-07:00 Clean up changes. - - - - - 6c9719ab by Raymond Toy at 2021-03-27T12:33:23-07:00 Reinstall breakpoint correctly. Also remove some debugging #ifdefs and change debugging fprintfs to DPRINTF. More work needed. - - - - - fc557845 by Raymond Toy at 2021-03-27T14:44:08-07:00 Removing breakpoint stuff from sigill; more cleanups For now, we get breakpoint trap in sigill, we lose. This shouldn't happen because the lisp code shouldn't be inserting breakpoints this way. Remove some #ifed code. - - - - - d039eb90 by Raymond Toy at 2021-03-27T15:03:12-07:00 Clean up implemenation, updating debugging prints Change debugging prints to use DPRINTF. - - - - - 3 changed files: - src/code/x86-vm.lisp - src/lisp/breakpoint.c - src/lisp/x86-arch.c Changes: ===================================== src/code/x86-vm.lisp ===================================== @@ -247,9 +247,9 @@ (vector (make-array length :element-type '(unsigned-byte 8)))) (declare (type (unsigned-byte 8) length) (type (simple-array (unsigned-byte 8) (*)) vector)) - #+t + #+nil (format t "internal-error-args scp ~A: pc ~X len ~D~%" scp pc length) - ;; Grab the bytes after length byte, which + ;; Grab the length bytes after the length byte. (copy-from-system-area pc (* vm:byte-bits 4) vector (* vm:word-bits vm:vector-data-offset) ===================================== src/lisp/breakpoint.c ===================================== @@ -192,7 +192,9 @@ compute_offset(os_context_t * scp, lispobj code, boolean function_end) static int compute_offset(os_context_t * scp, lispobj code, boolean function_end) { - fprintf(stderr, "compute_offset: code = 0x%lx\n", code); + extern unsigned int debug_handlers; + + DPRINTF(debug_handlers, (stderr, "compute_offset: code = 0x%lx\n", code)); if (code == NIL) return 0; @@ -209,16 +211,18 @@ compute_offset(os_context_t * scp, lispobj code, boolean function_end) code_start = (unsigned long) codeptr + HeaderValue(codeptr->header) * sizeof(lispobj); - fprintf(stderr, "compute_offset: pc = 0x%lx, code_start = 0x%lx\n", - pc, code_start); + DPRINTF(debug_handlers, + (stderr, "compute_offset: pc = 0x%lx, code_start = 0x%lx\n", + pc, code_start)); if (pc < code_start) return 0; else { int offset = pc - code_start; - fprintf(stderr, "compute_offset: offset %d, size = %ld\n", - offset, codeptr->code_size); + DPRINTF(debug_handlers, + (stderr, "compute_offset: offset %d, size = %ld\n", + offset, codeptr->code_size)); if (offset >= codeptr->code_size) { return 0; @@ -253,17 +257,18 @@ handle_breakpoint(int signal, int subcode, os_context_t * scp) void handle_breakpoint(int signal, int subcode, os_context_t * scp) { + extern unsigned int debug_handlers; + lispobj code, scp_sap = alloc_sap(scp); fake_foreign_function_call(scp); code = find_code(scp); -#if 1 - fprintf(stderr, "handle_breakpoint\n"); - fprintf(stderr, " offset = %d\n", compute_offset(scp, code, 0)); -#endif - + DPRINTF(debug_handlers, + (stderr, "handle breakpoint: offset %d\n", + compute_offset(scp, code, 0))); + /* * Don't disallow recursive breakpoint traps. Otherwise, we can't * use debugger breakpoints anywhere in here. ===================================== src/lisp/x86-arch.c ===================================== @@ -25,6 +25,13 @@ unsigned long fast_random_state = 1; +/* + * Set to positive value to enabled debug prints related to the sigill + * and sigtrap handlers. Also enables prints related to handling of + * breakpoints. + */ +unsigned int debug_handlers = 0; + #if defined(SOLARIS) /* * Use the /dev/cpu/self/cpuid interface on Solaris. We could use the @@ -140,7 +147,8 @@ arch_skip_instruction(os_context_t * context) { int vlen, code; - DPRINTF(1, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); + DPRINTF(debug_handlers, + (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); /* Get and skip the lisp error code. */ char* pc = (char *) SC_PC(context); @@ -178,7 +186,8 @@ arch_skip_instruction(os_context_t * context) break; } - DPRINTF(0, (stderr, "[arch_skip_inst resuming at %lx>]\n", SC_PC(context))); + DPRINTF(debug_handlers, + (stderr, "[arch_skip_inst resuming at %lx>]\n", SC_PC(context))); } unsigned char * @@ -207,28 +216,20 @@ arch_install_breakpoint(void *pc) unsigned char* ptr = (unsigned char *) pc; unsigned long result = ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24); - fprintf(stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n", - pc, result); - -#if 1 - *(char *) pc = BREAKPOINT_INST; /* x86 INT3 */ -#if 0 - *((char *) pc + 1) = trap_Breakpoint; /* Lisp trap code */ -#endif -#else - *ptr++ = 0x0f; /* UD2 */ - *ptr++ = 0x0b; - *ptr++ = trap_Breakpoint; /* Lisp trap code */ -#endif + DPRINTF(debug_handlers, + (stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n", + pc, result)); + *(char *) pc = BREAKPOINT_INST; /* x86 INT3 */ return result; } void arch_remove_breakpoint(void *pc, unsigned long orig_inst) { - fprintf(stderr, "arch_remove_breakpoint: %p orig %lx\n", - pc, orig_inst); + DPRINTF(debug_handlers, + (stderr, "arch_remove_breakpoint: %p orig %lx\n", + pc, orig_inst)); unsigned char *ptr = (unsigned char *) pc; ptr[0] = orig_inst & 0xff; ptr[1] = (orig_inst >> 8) & 0xff; @@ -256,23 +257,15 @@ arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst) { unsigned char *pc = (unsigned char *) SC_PC(context); - fprintf(stderr, "arch_do_displaced_inst: pc %p orig_inst %lx\n", - pc, orig_inst); + DPRINTF(debug_handlers, + (stderr, "arch_do_displaced_inst: pc %p orig_inst %lx\n", + pc, orig_inst)); /* * Put the original instruction back. */ -#if 1 *((char *) pc) = orig_inst & 0xff; -#if 0 - *((char *) pc + 1) = (orig_inst & 0xff00) >> 8; -#endif -#else - pc[0] = orig_inst & 0xff; - pc[1] = (orig_inst >> 8) & 0xff; - pc[2] = (orig_inst >> 16) & 0xff; -#endif #ifdef SC_EFLAGS /* Enable single-stepping */ @@ -317,71 +310,25 @@ sigill_handler(HANDLER_ARGS) { unsigned int trap; os_context_t* os_context = (os_context_t *) context; -#if 1 -#if 0 - fprintf(stderr, "x86sigtrap: %8x %x\n", - SC_PC(os_os_context), *(unsigned char *) (SC_PC(os_context) - 1)); -#else - fprintf(stderr,"x86sigill: fp=%lx sp=%lx pc=%lx { %x, %x, %x, %x, %x }\n", - SC_REG(context, reg_FP), - SC_REG(context, reg_SP), - SC_PC(context), - *(unsigned char*)(SC_PC(context) + 0), /* 0x0F */ - *(unsigned char*)(SC_PC(context) + 1), /* 0x0B */ - *(unsigned char*)(SC_PC(context) + 2), - *(unsigned char*)(SC_PC(context) + 3), - *(unsigned char*)(SC_PC(context) + 4)); -#endif - fprintf(stderr, "sigtrap(%d %d %p)\n", signal, CODE(code), os_context); -#endif -#if 0 - if (single_stepping && (signal == SIGTRAP)) { -#if 1 - fprintf(stderr, "* Single step trap %p\n", single_stepping); -#endif - -#ifdef SC_EFLAGS - /* Disable single-stepping */ - SC_EFLAGS(os_context) ^= 0x100; -#else - /* Un-install single step helper instructions. */ - *(single_stepping - 3) = single_step_save1; - *(single_stepping - 2) = single_step_save2; - *(single_stepping - 1) = single_step_save3; - DPRINTF(0, (stderr, "Uninstalling helper instructions\n")); -#endif - - /* - * Re-install the breakpoint if possible. - */ - fprintf(stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", - (void*) SC_PC(os_context), single_stepping); - - if ((int) SC_PC(os_context) < (int) single_stepping + 3) - fprintf(stderr, "* Breakpoint not re-install\n"); - else { - char *ptr = (char *) single_stepping; - -#if 0 - ptr[0] = BREAKPOINT_INST; /* x86 INT3 */ - ptr[1] = trap_Breakpoint; -#else - ptr[0] = 0x0f; - ptr[1] = 0x0b; - ptr[2] = trap_Breakpoint; -#endif - } - - single_stepping = NULL; - return; + DPRINTF(debug_handlers, + (stderr,"sigill: fp=%lx sp=%lx pc=%lx { %x, %x, %x, %x, %x }\n", + SC_REG(context, reg_FP), + SC_REG(context, reg_SP), + SC_PC(context), + *((unsigned char*)SC_PC(context) + 0), /* 0x0F */ + *((unsigned char*)SC_PC(context) + 1), /* 0x0B */ + *((unsigned char*)SC_PC(context) + 2), + *((unsigned char*)SC_PC(context) + 3), + *((unsigned char*)SC_PC(context) + 4))); + + if (single_stepping) { + lose("sigill handler with single-stepping enabled?\n"); } -#endif /* This is just for info in case monitor wants to print an approx */ current_control_stack_pointer = (unsigned long *) SC_SP(os_context); - /* * In many places in the switch below, we eventually throw instead * of returning from the signal handler. So, just in case, set @@ -396,22 +343,20 @@ sigill_handler(HANDLER_ARGS) * arguments to follow. */ -#if 1 - fprintf(stderr, "pc %x\n", *(unsigned short *)SC_PC(context)); -#endif + DPRINTF(debug_handlers, + (stderr, "pc %x\n", *(unsigned short *)SC_PC(context))); + if (*(unsigned short *) SC_PC(context) == 0x0b0f) { trap = *(((char *)SC_PC(context)) + 2); } else { abort(); } -#if 1 - fprintf(stderr, "code = %x\n", trap); -#endif + DPRINTF(debug_handlers, (stderr, "code = %x\n", trap)); switch (trap) { case trap_PendingInterrupt: - DPRINTF(1, (stderr, "<trap Pending Interrupt.>\n")); + DPRINTF(debug_handlers, (stderr, "<trap Pending Interrupt.>\n")); arch_skip_instruction(os_context); interrupt_handle_pending(os_context); break; @@ -432,28 +377,15 @@ sigill_handler(HANDLER_ARGS) case trap_Error: case trap_Cerror: - DPRINTF(1, (stderr, "<trap Error %x>\n", CODE(code))); + DPRINTF(debug_handlers, (stderr, "<trap Error %x>\n", CODE(code))); interrupt_internal_error(signal, code, os_context, CODE(code) == trap_Cerror); break; case trap_Breakpoint: -#if 1 - fprintf(stderr, "*C break\n"); -#endif -#if 0 - SC_PC(os_context) -= 1; -#endif - - handle_breakpoint(signal, CODE(code), os_context); -#if 1 - fprintf(stderr, "*C break return\n"); -#endif + lose("Unexpected breakpoint trap in sigill-hander.\n"); break; case trap_FunctionEndBreakpoint: -#if 0 - SC_PC(os_context) -= 1; -#endif SC_PC(os_context) = (int) handle_function_end_breakpoint(signal, CODE(code), os_context); break; @@ -473,7 +405,7 @@ sigill_handler(HANDLER_ARGS) break; #endif default: - DPRINTF(1, + DPRINTF(debug_handlers, (stderr, "[C--trap default %d %d %p]\n", signal, CODE(code), os_context)); interrupt_handle_now(signal, code, os_context); @@ -486,21 +418,19 @@ sigtrap_handler(HANDLER_ARGS) { os_context_t* os_context = (os_context_t *) context; -#if 1 - fprintf(stderr,"sigtrap: fp=%lx sp=%lx pc=%lx { %x, %x, %x, %x, %x }\n", - SC_REG(context, reg_FP), - SC_REG(context, reg_SP), - SC_PC(context), - *(unsigned char*)(SC_PC(context) + 0), /* 0x0F */ - *(unsigned char*)(SC_PC(context) + 1), /* 0x0B */ - *(unsigned char*)(SC_PC(context) + 2), - *(unsigned char*)(SC_PC(context) + 3), - *(unsigned char*)(SC_PC(context) + 4)); -#endif + DPRINTF(debug_handlers, + (stderr,"sigtrap: fp=%lx sp=%lx pc=%lx { %x, %x, %x, %x, %x }\n", + SC_REG(context, reg_FP), + SC_REG(context, reg_SP), + SC_PC(context), + *((unsigned char*)SC_PC(context) + 0), /* 0x0F */ + *((unsigned char*)SC_PC(context) + 1), /* 0x0B */ + *((unsigned char*)SC_PC(context) + 2), + *((unsigned char*)SC_PC(context) + 3), + *(unsigned char*)(SC_PC(context) + 4))); + if (single_stepping && (signal == SIGTRAP)) { -#if 1 - fprintf(stderr, "* Single step trap %p\n", single_stepping); -#endif + DPRINTF(debug_handlers, (stderr, "* Single step trap %p\n", single_stepping)); #ifdef SC_EFLAGS /* Disable single-stepping */ @@ -516,38 +446,29 @@ sigtrap_handler(HANDLER_ARGS) /* * Re-install the breakpoint if possible. */ - fprintf(stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", - (void*) SC_PC(os_context), single_stepping); + DPRINTF(debug_handlers, + (stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", + (void*) SC_PC(os_context), single_stepping)); if ((unsigned long) SC_PC(os_context) <= (unsigned long) single_stepping) fprintf(stderr, "* Breakpoint not re-install\n"); else { char *ptr = (char *) single_stepping; -#if 0 ptr[0] = BREAKPOINT_INST; /* x86 INT3 */ - ptr[1] = trap_Breakpoint; -#else - ptr[0] = 0x0f; - ptr[1] = 0x0b; - ptr[2] = trap_Breakpoint; -#endif } single_stepping = NULL; return; } -#if 1 - fprintf(stderr, "*C break\n"); -#endif -#if 1 - SC_PC(os_context) -= 1; -#endif - handle_breakpoint(signal, CODE(code), os_context); -#if 1 - fprintf(stderr, "*C break return\n"); -#endif + DPRINTF(debug_handlers, (stderr, "*C break\n")); + + SC_PC(os_context) -= 1; + + handle_breakpoint(signal, CODE(code), os_context); + + DPRINTF(debug_handlers, (stderr, "*C break return\n")); } View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/21dd39ea7b8e5bf144ee67… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/21dd39ea7b8e5bf144ee67… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] Use INT3 for breakpoints instead of UD2
by Raymond Toy 27 Mar '21

27 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 21dd39ea by Raymond Toy at 2021-03-27T11:13:40-07:00 Use INT3 for breakpoints instead of UD2 Since lisp doesn't use INT3 anymore, we know that any INT3 instruction is a breakpoint. Hence, we also don't need to append the breakpoint trap code. Also need to update function_end_breakpoint_trap to use UD2 instead of INT3. This is needed because we need the trap code to tell lisp this is a function end breakpoint. Tested this by adding a start breakpoint for kernel:%sqrt. Breakpoint is hit and you can continue. Also tested a function end breakpoint. When the breakpoint is hit, we correctly see the return value(s), and can continue fine. - - - - - 3 changed files: - src/code/x86-vm.lisp - src/lisp/x86-arch.c - src/lisp/x86-assem.S Changes: ===================================== src/code/x86-vm.lisp ===================================== @@ -247,7 +247,7 @@ (vector (make-array length :element-type '(unsigned-byte 8)))) (declare (type (unsigned-byte 8) length) (type (simple-array (unsigned-byte 8) (*)) vector)) - #+nil + #+t (format t "internal-error-args scp ~A: pc ~X len ~D~%" scp pc length) ;; Grab the bytes after length byte, which (copy-from-system-area pc (* vm:byte-bits 4) ===================================== src/lisp/x86-arch.c ===================================== @@ -21,9 +21,7 @@ #include "interr.h" #include "breakpoint.h" -#if 0 #define BREAKPOINT_INST 0xcc /* INT3 */ -#endif unsigned long fast_random_state = 1; @@ -212,9 +210,11 @@ arch_install_breakpoint(void *pc) fprintf(stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n", pc, result); -#if 0 +#if 1 *(char *) pc = BREAKPOINT_INST; /* x86 INT3 */ +#if 0 *((char *) pc + 1) = trap_Breakpoint; /* Lisp trap code */ +#endif #else *ptr++ = 0x0f; /* UD2 */ *ptr++ = 0x0b; @@ -263,9 +263,11 @@ arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst) * Put the original instruction back. */ -#if 0 +#if 1 *((char *) pc) = orig_inst & 0xff; +#if 0 *((char *) pc + 1) = (orig_inst & 0xff00) >> 8; +#endif #else pc[0] = orig_inst & 0xff; pc[1] = (orig_inst >> 8) & 0xff; @@ -333,7 +335,8 @@ sigill_handler(HANDLER_ARGS) fprintf(stderr, "sigtrap(%d %d %p)\n", signal, CODE(code), os_context); #endif - if (single_stepping && (signal == SIGILL)) { +#if 0 + if (single_stepping && (signal == SIGTRAP)) { #if 1 fprintf(stderr, "* Single step trap %p\n", single_stepping); #endif @@ -352,9 +355,10 @@ sigill_handler(HANDLER_ARGS) /* * Re-install the breakpoint if possible. */ - fprintf(stderr, "* Reinstall breakpoint at single_stepping %p\n", single_stepping); + fprintf(stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", + (void*) SC_PC(os_context), single_stepping); - if ((int) SC_PC(os_context) >= (int) single_stepping + 3) + if ((int) SC_PC(os_context) < (int) single_stepping + 3) fprintf(stderr, "* Breakpoint not re-install\n"); else { char *ptr = (char *) single_stepping; @@ -372,7 +376,8 @@ sigill_handler(HANDLER_ARGS) single_stepping = NULL; return; } - +#endif + /* This is just for info in case monitor wants to print an approx */ current_control_stack_pointer = (unsigned long *) SC_SP(os_context); @@ -406,7 +411,7 @@ sigill_handler(HANDLER_ARGS) switch (trap) { case trap_PendingInterrupt: - DPRINTF(0, (stderr, "<trap Pending Interrupt.>\n")); + DPRINTF(1, (stderr, "<trap Pending Interrupt.>\n")); arch_skip_instruction(os_context); interrupt_handle_pending(os_context); break; @@ -427,7 +432,7 @@ sigill_handler(HANDLER_ARGS) case trap_Error: case trap_Cerror: - DPRINTF(0, (stderr, "<trap Error %x>\n", CODE(code))); + DPRINTF(1, (stderr, "<trap Error %x>\n", CODE(code))); interrupt_internal_error(signal, code, os_context, CODE(code) == trap_Cerror); break; @@ -468,7 +473,7 @@ sigill_handler(HANDLER_ARGS) break; #endif default: - DPRINTF(0, + DPRINTF(1, (stderr, "[C--trap default %d %d %p]\n", signal, CODE(code), os_context)); interrupt_handle_now(signal, code, os_context); @@ -514,7 +519,7 @@ sigtrap_handler(HANDLER_ARGS) fprintf(stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", (void*) SC_PC(os_context), single_stepping); - if ((unsigned long) SC_PC(os_context) <= (unsigned long) single_stepping + 3) + if ((unsigned long) SC_PC(os_context) <= (unsigned long) single_stepping) fprintf(stderr, "* Breakpoint not re-install\n"); else { char *ptr = (char *) single_stepping; @@ -532,6 +537,17 @@ sigtrap_handler(HANDLER_ARGS) single_stepping = NULL; return; } +#if 1 + fprintf(stderr, "*C break\n"); +#endif +#if 1 + SC_PC(os_context) -= 1; +#endif + + handle_breakpoint(signal, CODE(code), os_context); +#if 1 + fprintf(stderr, "*C break return\n"); +#endif } ===================================== src/lisp/x86-assem.S ===================================== @@ -286,7 +286,7 @@ multiple_value_return: .globl GNAME(function_end_breakpoint_trap) GNAME(function_end_breakpoint_trap): - INT3 + UD2 .byte trap_FunctionEndBreakpoint hlt # Should never return here. View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/21dd39ea7b8e5bf144ee67f… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/21dd39ea7b8e5bf144ee67f… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][master] 2 commits: Fix up headings for issue templates
by Raymond Toy 23 Mar '21

23 Mar '21

Raymond Toy pushed to branch master at cmucl / cmucl Commits: 1b27941a by Raymond Toy at 2021-03-22T20:00:49-07:00 Fix up headings for issue templates The headings used to be `**foo**`, but it's better to use `## foo`. The old headings would cause the following paragraph to be appended to the heading. Thus ``` ## foo Text ``` became ``` foo Text ``` with "foo" in bold. With the new markup, this doesn't happen. - - - - - 5c92c14c by Raymond Toy at 2021-03-23T03:34:19+00:00 Merge branch 'fixup-template-headings' into 'master' Fix up headings for issue templates See merge request cmucl/cmucl!73 - - - - - 2 changed files: - .gitlab/issue_templates/Bug.md - .gitlab/issue_templates/Feature.md Changes: ===================================== .gitlab/issue_templates/Bug.md ===================================== @@ -1,24 +1,24 @@ -**Describe the bug** +## Describe the bug A clear and concise description of what the bug is. -**To Reproduce** +## To Reproduce Steps to reproduce the behavior: 1. Go to '...' 2. Click on '....' 3. Scroll down to '....' 4. See error -**Expected behavior** +## Expected behavior A clear and concise description of what you expected to happen. -**Screenshots** +## Screenshots If applicable, add screenshots to help explain your problem. -**Desktop (please complete the following information):** +## Desktop (please complete the following information): - OS: [e.g. Linux] - Version [e.g. 21c] -**Additional context** +## Additional context Add any other context about the problem here. /label ~bug ===================================== .gitlab/issue_templates/Feature.md ===================================== @@ -1,10 +1,10 @@ -**Describe the feature** +## Describe the feature Briefly describe the feature you would like see. -**Is there a prototype?** +## Is there a prototype? If you have a prototype, provide links to illustrate this addition. This is the best way to propose a new feature. -**Describe the feature in more detail** +## Describe the feature in more detail Provide more information to describe the feature. /label ~feature View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/9b1abca53598f03a5b39de… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/9b1abca53598f03a5b39de… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl] Pushed new branch fixup-template-headings
by Raymond Toy 23 Mar '21

23 Mar '21

Raymond Toy pushed new branch fixup-template-headings at cmucl / cmucl -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/tree/fixup-template-headings You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] Add sigtrap handler to handle single-stepping traps
by Raymond Toy 23 Mar '21

23 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 8817798f by Raymond Toy at 2021-03-22T19:57:09-07:00 Add sigtrap handler to handle single-stepping traps Needed to handle single-stepping. There's also a lot of other changes used to debug this. They eventually need to be cleaned up. - - - - - 1 changed file: - src/lisp/x86-arch.c Changes: ===================================== src/lisp/x86-arch.c ===================================== @@ -142,7 +142,7 @@ arch_skip_instruction(os_context_t * context) { int vlen, code; - DPRINTF(0, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); + DPRINTF(1, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); /* Get and skip the lisp error code. */ char* pc = (char *) SC_PC(context); @@ -206,8 +206,8 @@ arch_set_pseudo_atomic_interrupted(os_context_t * context) unsigned long arch_install_breakpoint(void *pc) { - char* ptr = (char *) pc; - unsigned long result = *(unsigned long *) pc; + unsigned char* ptr = (unsigned char *) pc; + unsigned long result = ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24); fprintf(stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n", pc, result); @@ -227,8 +227,13 @@ arch_install_breakpoint(void *pc) void arch_remove_breakpoint(void *pc, unsigned long orig_inst) { - *((char *) pc) = orig_inst & 0xff; - *((char *) pc + 1) = (orig_inst & 0xff00) >> 8; + fprintf(stderr, "arch_remove_breakpoint: %p orig %lx\n", + pc, orig_inst); + unsigned char *ptr = (unsigned char *) pc; + ptr[0] = orig_inst & 0xff; + ptr[1] = (orig_inst >> 8) & 0xff; + ptr[2] = (orig_inst >> 16) & 0xff; + ptr[3] = (orig_inst >> 24) & 0xff; } @@ -249,14 +254,23 @@ unsigned int single_step_save3; void arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst) { - unsigned int *pc = (unsigned int *) SC_PC(context); + unsigned char *pc = (unsigned char *) SC_PC(context); + fprintf(stderr, "arch_do_displaced_inst: pc %p orig_inst %lx\n", + pc, orig_inst); + /* * Put the original instruction back. */ +#if 0 *((char *) pc) = orig_inst & 0xff; *((char *) pc + 1) = (orig_inst & 0xff00) >> 8; +#else + pc[0] = orig_inst & 0xff; + pc[1] = (orig_inst >> 8) & 0xff; + pc[2] = (orig_inst >> 16) & 0xff; +#endif #ifdef SC_EFLAGS /* Enable single-stepping */ @@ -319,8 +333,8 @@ sigill_handler(HANDLER_ARGS) fprintf(stderr, "sigtrap(%d %d %p)\n", signal, CODE(code), os_context); #endif - if (single_stepping && (signal == SIGTRAP)) { -#if 0 + if (single_stepping && (signal == SIGILL)) { +#if 1 fprintf(stderr, "* Single step trap %p\n", single_stepping); #endif @@ -338,7 +352,9 @@ sigill_handler(HANDLER_ARGS) /* * Re-install the breakpoint if possible. */ - if ((int) SC_PC(os_context) == (int) single_stepping + 1) + fprintf(stderr, "* Reinstall breakpoint at single_stepping %p\n", single_stepping); + + if ((int) SC_PC(os_context) >= (int) single_stepping + 3) fprintf(stderr, "* Breakpoint not re-install\n"); else { char *ptr = (char *) single_stepping; @@ -460,10 +476,70 @@ sigill_handler(HANDLER_ARGS) } } +void +sigtrap_handler(HANDLER_ARGS) +{ + os_context_t* os_context = (os_context_t *) context; + +#if 1 + fprintf(stderr,"sigtrap: fp=%lx sp=%lx pc=%lx { %x, %x, %x, %x, %x }\n", + SC_REG(context, reg_FP), + SC_REG(context, reg_SP), + SC_PC(context), + *(unsigned char*)(SC_PC(context) + 0), /* 0x0F */ + *(unsigned char*)(SC_PC(context) + 1), /* 0x0B */ + *(unsigned char*)(SC_PC(context) + 2), + *(unsigned char*)(SC_PC(context) + 3), + *(unsigned char*)(SC_PC(context) + 4)); +#endif + if (single_stepping && (signal == SIGTRAP)) { +#if 1 + fprintf(stderr, "* Single step trap %p\n", single_stepping); +#endif + +#ifdef SC_EFLAGS + /* Disable single-stepping */ + SC_EFLAGS(os_context) ^= 0x100; +#else + /* Un-install single step helper instructions. */ + *(single_stepping - 3) = single_step_save1; + *(single_stepping - 2) = single_step_save2; + *(single_stepping - 1) = single_step_save3; + DPRINTF(0, (stderr, "Uninstalling helper instructions\n")); +#endif + + /* + * Re-install the breakpoint if possible. + */ + fprintf(stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n", + (void*) SC_PC(os_context), single_stepping); + + if ((unsigned long) SC_PC(os_context) <= (unsigned long) single_stepping + 3) + fprintf(stderr, "* Breakpoint not re-install\n"); + else { + char *ptr = (char *) single_stepping; + +#if 0 + ptr[0] = BREAKPOINT_INST; /* x86 INT3 */ + ptr[1] = trap_Breakpoint; +#else + ptr[0] = 0x0f; + ptr[1] = 0x0b; + ptr[2] = trap_Breakpoint; +#endif + } + + single_stepping = NULL; + return; + } +} + + void arch_install_interrupt_handlers(void) { interrupt_install_low_level_handler(SIGILL, sigill_handler); + interrupt_install_low_level_handler(SIGTRAP, sigtrap_handler); } View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/8817798f004ea8e745201c5… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/commit/8817798f004ea8e745201c5… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] 2 commits: Add debugging prints
by Raymond Toy 21 Mar '21

21 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 16043a5b by Raymond Toy at 2021-03-21T14:58:19-07:00 Add debugging prints Add some prints to handle-breakpoints so we can see what lisp thinks is the breakpoint. Add some prints to compute_offset and handle_breakpoint so we can see what C thinks is happening with breakpoints. - - - - - 7a5a1513 by Raymond Toy at 2021-03-21T15:02:05-07:00 Add prints and fix issue with breakpoint offset off by one. When handling the breakpoint in `sigill_handler`, we were decrementing the pc by one. I guess that was for the old INT3 where the pc would be at the next instruction. With UD2, the pc is at the beginning of the UD2 instruction. With this change, setting breakpoints appear to work: ``` (break) bp :start :function #'kernel:%srqt 0 (kernel:%sqrt 2d0) *Breakpoint hit* [Condition of type SIMPLE-CONDITION] Restarts: 0: [CONTINUE] Return from BREAK. 1: [ABORT ] Return to Top-Level. Debug (type H for help) (KERNEL:%SQRT 2.0d0) ``` Add some prints so we can see what's happening. But removing breakpoints isn't working. - - - - - 3 changed files: - src/code/debug-int.lisp - src/lisp/breakpoint.c - src/lisp/x86-arch.c Changes: ===================================== src/code/debug-int.lisp ===================================== @@ -4477,6 +4477,9 @@ The result is a symbol or nil if the routine cannot be found." ;;; (defun handle-breakpoint (offset component signal-context) (let ((data (breakpoint-data component offset nil))) + (format t "(handle-breakpoint ~A ~A ~A)~%" + offset component signal-context) + (format t " data = ~A~%" data) (unless data (error (intl:gettext "Unknown breakpoint in ~S at offset ~S.") (debug-function-name (debug-function-from-pc component offset)) ===================================== src/lisp/breakpoint.c ===================================== @@ -192,6 +192,8 @@ compute_offset(os_context_t * scp, lispobj code, boolean function_end) static int compute_offset(os_context_t * scp, lispobj code, boolean function_end) { + fprintf(stderr, "compute_offset: code = 0x%lx\n", code); + if (code == NIL) return 0; else { @@ -206,11 +208,18 @@ compute_offset(os_context_t * scp, lispobj code, boolean function_end) code_start = (unsigned long) codeptr + HeaderValue(codeptr->header) * sizeof(lispobj); + + fprintf(stderr, "compute_offset: pc = 0x%lx, code_start = 0x%lx\n", + pc, code_start); + if (pc < code_start) return 0; else { int offset = pc - code_start; + fprintf(stderr, "compute_offset: offset %d, size = %ld\n", + offset, codeptr->code_size); + if (offset >= codeptr->code_size) { return 0; } else { @@ -250,6 +259,11 @@ handle_breakpoint(int signal, int subcode, os_context_t * scp) code = find_code(scp); +#if 1 + fprintf(stderr, "handle_breakpoint\n"); + fprintf(stderr, " offset = %d\n", compute_offset(scp, code, 0)); +#endif + /* * Don't disallow recursive breakpoint traps. Otherwise, we can't * use debugger breakpoints anywhere in here. ===================================== src/lisp/x86-arch.c ===================================== @@ -209,6 +209,9 @@ arch_install_breakpoint(void *pc) char* ptr = (char *) pc; unsigned long result = *(unsigned long *) pc; + fprintf(stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n", + pc, result); + #if 0 *(char *) pc = BREAKPOINT_INST; /* x86 INT3 */ *((char *) pc + 1) = trap_Breakpoint; /* Lisp trap code */ @@ -216,8 +219,6 @@ arch_install_breakpoint(void *pc) *ptr++ = 0x0f; /* UD2 */ *ptr++ = 0x0b; *ptr++ = trap_Breakpoint; /* Lisp trap code */ - *ptr++ = 1; /* Vector length */ - *ptr++ = 0; /* Junk data */ #endif return result; @@ -300,7 +301,7 @@ sigill_handler(HANDLER_ARGS) { unsigned int trap; os_context_t* os_context = (os_context_t *) context; -#if 0 +#if 1 #if 0 fprintf(stderr, "x86sigtrap: %8x %x\n", SC_PC(os_os_context), *(unsigned char *) (SC_PC(os_context) - 1)); @@ -374,7 +375,7 @@ sigill_handler(HANDLER_ARGS) * arguments to follow. */ -#if 0 +#if 1 fprintf(stderr, "pc %x\n", *(unsigned short *)SC_PC(context)); #endif if (*(unsigned short *) SC_PC(context) == 0x0b0f) { @@ -383,7 +384,7 @@ sigill_handler(HANDLER_ARGS) abort(); } -#if 0 +#if 1 fprintf(stderr, "code = %x\n", trap); #endif @@ -415,19 +416,23 @@ sigill_handler(HANDLER_ARGS) break; case trap_Breakpoint: -#if 0 +#if 1 fprintf(stderr, "*C break\n"); #endif +#if 0 SC_PC(os_context) -= 1; +#endif handle_breakpoint(signal, CODE(code), os_context); -#if 0 +#if 1 fprintf(stderr, "*C break return\n"); #endif break; case trap_FunctionEndBreakpoint: +#if 0 SC_PC(os_context) -= 1; +#endif SC_PC(os_context) = (int) handle_function_end_breakpoint(signal, CODE(code), os_context); break; View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d9cbe149b97772150b8d03… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/d9cbe149b97772150b8d03… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

[Git][cmucl/cmucl][issue-97-define-ud2-inst] 4 commits: Remove debugging prints and unused macro
by Raymond Toy 20 Mar '21

20 Mar '21

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl Commits: 7a5d8ab5 by Raymond Toy at 2021-03-20T09:12:14-07:00 Remove debugging prints and unused macro - - - - - b972a606 by Raymond Toy at 2021-03-20T09:13:12-07:00 Replace INT3 with UD2 - - - - - ba580ebe by Raymond Toy at 2021-03-20T09:22:24-07:00 Disable debugging prints Turn off the debugging prints and #if out the added prints. At a later time we can remove the added prints, once single-stepping is working. - - - - - d9cbe149 by Raymond Toy at 2021-03-20T09:24:56-07:00 Comment out debugging print - - - - - 4 changed files: - src/code/x86-vm.lisp - src/compiler/x86/insts.lisp - src/lisp/x86-arch.c - src/lisp/x86-assem.S Changes: ===================================== src/code/x86-vm.lisp ===================================== @@ -247,13 +247,13 @@ (vector (make-array length :element-type '(unsigned-byte 8)))) (declare (type (unsigned-byte 8) length) (type (simple-array (unsigned-byte 8) (*)) vector)) + #+nil (format t "internal-error-args scp ~A: pc ~X len ~D~%" scp pc length) ;; Grab the bytes after length byte, which (copy-from-system-area pc (* vm:byte-bits 4) vector (* vm:word-bits vm:vector-data-offset) (* length vm:byte-bits)) - (format t " vector ~A~%" vector) (let* ((index 0) (error-number (c::read-var-integer vector index))) (collect ((sc-offsets)) ===================================== src/compiler/x86/insts.lisp ===================================== @@ -2099,20 +2099,9 @@ (sc-offsets) (lengths)))))))) -#+nil -(defmacro break-cases (breaknum &body cases) - (let ((bn-temp (gensym))) - (collect ((clauses)) - (dolist (case cases) - (clauses `((= ,bn-temp ,(car case)) ,@(cdr case)))) - `(let ((,bn-temp ,breaknum)) - (cond ,@(clauses)))))) - (defun break-control (chunk inst stream dstate) - #+nil(declare (ignore inst)) + (declare (ignore inst)) (flet ((nt (x) (if stream (disassem:note x dstate)))) - (format t "break-control: inst = ~A code = ~A~%" inst (break-code chunk dstate)) - (describe inst) (case (break-code chunk dstate) (#.vm:error-trap (nt "Error trap") ===================================== src/lisp/x86-arch.c ===================================== @@ -142,7 +142,7 @@ arch_skip_instruction(os_context_t * context) { int vlen, code; - DPRINTF(1, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); + DPRINTF(0, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context))); /* Get and skip the lisp error code. */ char* pc = (char *) SC_PC(context); @@ -180,7 +180,7 @@ arch_skip_instruction(os_context_t * context) break; } - DPRINTF(1, (stderr, "[arch_skip_inst resuming at %lx>]\n", SC_PC(context))); + DPRINTF(0, (stderr, "[arch_skip_inst resuming at %lx>]\n", SC_PC(context))); } unsigned char * @@ -300,7 +300,7 @@ sigill_handler(HANDLER_ARGS) { unsigned int trap; os_context_t* os_context = (os_context_t *) context; -#if 1 +#if 0 #if 0 fprintf(stderr, "x86sigtrap: %8x %x\n", SC_PC(os_os_context), *(unsigned char *) (SC_PC(os_context) - 1)); @@ -374,14 +374,18 @@ sigill_handler(HANDLER_ARGS) * arguments to follow. */ +#if 0 fprintf(stderr, "pc %x\n", *(unsigned short *)SC_PC(context)); +#endif if (*(unsigned short *) SC_PC(context) == 0x0b0f) { trap = *(((char *)SC_PC(context)) + 2); } else { abort(); } +#if 0 fprintf(stderr, "code = %x\n", trap); +#endif switch (trap) { case trap_PendingInterrupt: ===================================== src/lisp/x86-assem.S ===================================== @@ -302,7 +302,7 @@ ENDFUNC(do_pending_interrupt) #ifdef trap_DynamicSpaceOverflowError FUNCDEF(do_dynamic_space_overflow_error) - INT3 + ud2 .byte trap_DynamicSpaceOverflowError ret ENDFUNC(do_dynamic_space_overflow_error) @@ -310,7 +310,7 @@ ENDFUNC(do_dynamic_space_overflow_error) #ifdef trap_DynamicSpaceOverflowWarning FUNCDEF(do_dynamic_space_overflow_warning) - INT3 + ud2 .byte trap_DynamicSpaceOverflowWarning ret ENDFUNC(do_dynamic_space_overflow_warning) @@ -493,7 +493,7 @@ FUNCDEF(undefined_foreign_symbol_trap) movl 8(%ebp),%eax /* Now trap to Lisp */ - INT3 + ud2 .byte trap_Error /* Number of argument bytes */ .byte 2 View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/73e864e8ddcef408af202f… -- View it on GitLab: https://gitlab.common-lisp.net/cmucl/cmucl/-/compare/73e864e8ddcef408af202f… You're receiving this email because of your account on gitlab.common-lisp.net.

1 0

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

cmucl-cvs