GitLab

at 2021-04-10T08:42:04-07:00

Change disassembly note for trap codes

Minor tweak to print the trap number first before the description of
the trap.

Add comments

Address review comments and add more comments

Fixed up a few things mentioned in the review.

Add a more comments on how things work, and added a TODO on computing
the instruction length and inserting a int3/ud1 after it, kind of like
how other archs handle it.

 (defun ud1-control (chunk inst stream dstate)

   (declare (ignore inst))

   (flet ((nt (x) (if stream (disassem:note x dstate))))

-    (case (ldb (byte 6 16) chunk)

-      (#.vm:error-trap

-       (nt #.(format nil "Error trap: ~D" vm:error-trap))

-       (disassem:handle-break-args #'snarf-error-junk stream dstate))

-      (#.vm:cerror-trap

-       (nt #.(format nil "Cerror trap: ~D" vm:cerror-trap))

-       (disassem:handle-break-args #'snarf-error-junk stream dstate))

-      (#.vm:breakpoint-trap

-       (nt #.(format nil "Breakpoint trap: ~D" vm:breakpoint-trap)))

-      (#.vm:pending-interrupt-trap

-       (nt #.(format nil "Pending interrupt trap: ~D" vm:pending-interrupt-trap)))

-      (#.vm:halt-trap

-       (nt #.(format nil "Halt trap: ~D" vm:halt-trap)))

-      (#.vm:function-end-breakpoint-trap

-       (nt #.(format nil "Function end breakpoint trap: ~D" vm:function-end-breakpoint-trap)))

-    )))

+    (let ((code (ldb (byte 6 16) chunk)))

+      (case code

+	(#.vm:error-trap

+	 (nt #.(format nil "Trap ~D: Error trap" vm:error-trap))

+	 (disassem:handle-break-args #'snarf-error-junk stream dstate))

+	(#.vm:cerror-trap

+	 (nt #.(format nil "Trap ~D: Cerror trap" vm:cerror-trap))

+	 (disassem:handle-break-args #'snarf-error-junk stream dstate))

+	(#.vm:pending-interrupt-trap

+	 (nt #.(format nil "Trap ~D: Pending interrupt trap" vm:pending-interrupt-trap)))

+	(#.vm:halt-trap

+	 (nt #.(format nil "Trap ~D: Halt trap" vm:halt-trap)))

+	(#.vm:function-end-breakpoint-trap

+	 (nt #.(format nil "Trap ~D: Function end breakpoint trap"

+		       vm:function-end-breakpoint-trap)))

+	(t

+	 (nt #.(format nil "Trap ~D: Unexpected trap type!!!!" )))))))

 ;; 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.

+;; low 6 bits of the mod r/m byte.  The mod bits are set to #b11 to

+;; make sure the reg/mem part is interpreted to be a register and not

+;; memory.

 (define-instruction ud1 (segment code)

   (:declare (type (unsigned-byte 8) code))

   (:printer ud1 ((op #b10111001) (reg nil :type 'word-reg))

 	    :default

 	    :control #'ud1-control)

   (:emitter

+   ;; We should not be using the breakpoint trap with UD1 anymore.

+   ;; Breakpoint traps are handled in C now, using plain int3.

+   (assert (/= code vm:breakpoint-trap))

+

+   ;; Emit the bytes of the instruction.

    (emit-byte segment #x0f)

    (emit-byte segment #xb9)

    (emit-mod-reg-r/m-byte segment

 unsigned int single_step_save3;

 #endif

+/*

+ * This is called when we need to continue after a breakpoint.  This

+ * works by putting the original byte back into the code, and then

+ * enabling single-step mode to step one instruction.  When we return,

+ * the instruction will get run and a sigtrap will get triggered when

+ * the one instruction is done.

+ *

+ * TODO: Be more like other archs where the original inst is put back,

+ * and the next inst is replaced with a afterBreakpoint trap.  When we

+ * run, the afterBreakpoint trap is hit at the next instruction and

+ * then we can put back the original breakpoint and replace the

+ * afterBreakpoint trap with the original inst there too.

+ *

+ * For x86, this means computing how many bytes are used in the

+ * current instruction, and then placing an int3 (or maybe ud1) after

+ * it.

+ */

 void

 arch_do_displaced_inst(os_context_t * context, unsigned long orig_inst)

 {

      * Put the original instruction back.

      */

-    *((char *) pc) = orig_inst & 0xff;

+    *pc = orig_inst & 0xff;

     /*

      * If we have the SC_EFLAGS macro, we can enable single-stepping

 /*

- * Handles the break instruction from lisp, which is now UD2 followed

- * by the trap code.  In particular, this does not handle the

- * breakpoint traps.

+ * Handles the ud1 instruction from lisp that is used to signal

+ * errors.  In particular, this does not handle the breakpoint traps.

  */

 void

 sigill_handler(HANDLER_ARGS)

     RESTORE_FPU(os_context);

     /*

-     * 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

-     * arguments to follow.

+     * On entry %eip points just to the beginning of the UD1

+     * instruction.  For error-trap and cerror-trap a number of bytes

+     * will follow, the first is the length of the byte arguments to

+     * follow.

      */

     DPRINTF(debug_handlers,

              *((unsigned char*)SC_PC(context) + 3),

              *(unsigned char*)(SC_PC(context) + 4)));

-    if (single_stepping && (signal == SIGTRAP)) {

+    if (single_stepping) {

+        /*

+         * We were single-stepping so we now need to disable

+         * single-stepping.  We want to put back the breakpoint (int3)

+         * instruction so that the next time the breakpoint will be

+         * hit again as expected.

+         */

 	DPRINTF(debug_handlers, (stderr, "* Single step trap %p\n", single_stepping));

 #ifdef SC_EFLAGS

 	return;

     }

+    /*

+     * We weren't single-stepping, so this we've just hit the breakpoint (int3).  Handle it.

+     */

     DPRINTF(debug_handlers, (stderr, "*C break\n"));

     /*

Raymond Toy pushed to branch issue-97-define-ud2-inst at cmucl / cmucl

Commits:

2 changed files:

Changes: