GitLab

at 2021-05-31T17:13:13+00:00

Fix #97: Use UD1 instruction instead of INT3

Merge branch 'issue-97-define-ud2-inst' into 'master'

Fix #97: Use UD1 instruction instead of INT3

Closes #97

See merge request cmucl/cmucl!72
   (with-alien ((scp (* unix:sigcontext) scp))

     (let ((pc (sigcontext-program-counter scp)))

       (declare (type system-area-pointer pc))

-      ;; using INT3 the pc is .. INT3 <here> code length bytes...

-      (let* ((length (sap-ref-8 pc 1))

+      ;; The pc should point to the start of the UD1 instruction.  So

+      ;; we have something like:

+      ;;

+      ;;   offset  contents

+      ;;   0       UD1 (contains the trap code)

+      ;;   3       length

+      ;;   4...    bytes

+      (let* ((length (sap-ref-8 pc 3))

 	     (vector (make-array length :element-type '(unsigned-byte 8))))

 	(declare (type (unsigned-byte 8) length)

 		 (type (simple-array (unsigned-byte 8) (*)) vector))

-	(copy-from-system-area pc (* vm:byte-bits 2)

+	;; Grab bytes after the length byte where the number of bytes is

+	;; given by value of the length byte.

+	(copy-from-system-area pc (* vm:byte-bits 4)

 			       vector (* vm:word-bits

 					 vm:vector-data-offset)

 			       (* length vm:byte-bits))

     (bit-test-reg/mem 24

 		      :default-printer '(:name :tab reg/mem ", " reg))

   (prefix	:field (byte 8 0)	:value #b0001111)

-  (op		:field (byte 3 11))

+  (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)

   (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)))

  (op :field (byte 8 0))

  (code :field (byte 8 8)))

+

+;; The UD1 instruction.  The mod bits of the mod r/m byte MUST be #b11

+;; so that the reg/mem field is actually a register.  This is a hack

+;; to allow us to print out the reg/mem reg as a 32-bit reg.

+;;

+;; While the instruction looks like an ext-reg-reg/mem format with

+;; fixed width value of 1, it isn't because we need to disassemble the

+;; reg/mem field as a 32-bit reg. ext-reg-reg/mem needs a width prefix

+;; byte to specify that, and we definitely don't want that.  Hence,

+;; use a special instruction format for the UD1 instruction.

+(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)

+  ;; The mod bits ensure that the reg/mem field is interpreted as a

+  ;; register, not memory.

+  (reg/mem   :field (byte 3 16) :type 'word-reg)

+  (reg	     :field (byte 3 19) :type 'word-reg)

+  (mod       :field (byte 2 22) :value #b11))

+

 (defun snarf-error-junk (sap offset &optional length-only)

   (let* ((length (system:sap-ref-8 sap offset))

          (vector (make-array length :element-type '(unsigned-byte 8))))

                        (sc-offsets)

                        (lengths))))))))

-(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)

+(defun ud1-control (chunk inst stream dstate)

   (declare (ignore inst))

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

-    (case (byte-imm-code chunk dstate)

-      (#.vm:error-trap

-       (nt "Error trap")

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

-      (#.vm:cerror-trap

-       (nt "Cerror trap")

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

-      (#.vm:breakpoint-trap

-       (nt "Breakpoint trap"))

-      (#.vm:pending-interrupt-trap

-       (nt "Pending interrupt trap"))

-      (#.vm:halt-trap

-       (nt "Halt trap"))

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

-       (nt "Function end breakpoint trap"))

-    )))

-

-;; This is really the int3 instruction.

-(define-instruction break (segment code)

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

+      (ecase 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)))))))

+

+;; The ud1 instruction where we smash the code (trap type) into the

+;; 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 byte-imm ((op #b11001100)) '(:name :tab code)

-	    :control #'break-control)

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

+	    :default

+	    :control #'ud1-control)

   (:emitter

-   (emit-byte segment #b11001100)

-   (emit-byte segment code)))

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

+			  #b11

+			  (ldb (byte 3 3) code)

+			  (ldb (byte 3 0) code))))

+

+;; Handles both int and int3.  To get int3 you have to say (inst int

+;; 3).  But int3 should not be used in Lisp code.  This is mainly so

+;; that int3 gets disassembled correctly if a breakpoint has been set

+;; in Lisp code.  (But in general the disassembly will be messed up

+;; because the following byte will in general be the second byte of

+;; some instruction, and not the first byte of an instruction.)

 (define-instruction int (segment number)

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

   (:printer byte-imm ((op #b11001101)))

   (:emitter

-   (etypecase number

-     ((member 3)

-      (emit-byte segment #b11001100))

-     ((unsigned-byte 8)

-      (emit-byte segment #b11001101)

-      (emit-byte segment number)))))

+   (emit-byte segment #b11001101)

+   (emit-byte segment number)))

+

+(define-instruction int3 (segment)

+  (:printer byte ((op #b11001100)))

+  (:emitter

+   (emit-byte segment #b11001100)))

 (define-instruction into (segment)

   (:printer byte ((op #b11001110)))

   (defun emit-error-break (vop kind code values)

     (let ((vector (gensym))

 	  (length (gensym)))

-      `((inst int 3)				; i386 breakpoint instruction

-	;; The return PC points here; note the location for the debugger.

-	(let ((vop ,vop))

+      `((let ((vop ,vop))

   	  (when vop

-		(note-this-location vop :internal-error)))

-	(inst byte ,kind)			; eg trap_Xyyy

+	    (note-this-location vop :internal-error)))

+	(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)

 				    (- other-pointer-type)))

 	      0)

 	(inst jmp :eq ,label)

-	(inst break pending-interrupt-trap)

+	(inst ud1 pending-interrupt-trap)

 	(emit-label ,label)))))

   (: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)

 extern char *arch_init(fpu_mode_t);

+/*

+ * Skip over the trap instructions for an error trap and also skip

+ * over anly following bytes used to encode information for an

+ * error-trap or cerror-trap.  The PC in the context is set to address

+ * just past the trap instruction and data bytes (if any).

+ */

 extern void arch_skip_instruction(os_context_t * scp);

+

 extern boolean arch_pseudo_atomic_atomic(os_context_t * scp);

 extern void arch_set_pseudo_atomic_interrupted(os_context_t * scp);

 extern os_vm_address_t arch_get_bad_addr(HANDLER_ARGS);

 extern unsigned char *arch_internal_error_arguments(os_context_t * scp);

+

+/*

+ * Install an architecture-dependent breakpoint instruction at the

+ * given PC address.  This also returns the bytes that were

+ * overwritten by the breakpoint instruction so that the original

+ * instruction can be restored once the breakpoint has been handled.

+ */

 extern unsigned long arch_install_breakpoint(void *pc);

+

 extern void arch_remove_breakpoint(void *pc, unsigned long orig_inst);

 extern void arch_install_interrupt_handlers(void);

+

+/*

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

+ * original instruction in |orig_inst| is put back.  Then things are

+ * set up so that we can run again and after this instruction is run,

+ * we trap again so that the original breakpoint can be replaced.  How

+ * this is done is architecture-dependent.

+ */

 extern void arch_do_displaced_inst(os_context_t * scp, unsigned long orig_inst);

+

 extern lispobj funcall0(lispobj function);

 extern lispobj funcall1(lispobj function, lispobj arg0);

 extern lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1);

 static int

 compute_offset(os_context_t * scp, lispobj code, boolean function_end)

 {

+    DPRINTF(debug_handlers, (stderr, "compute_offset: code = 0x%lx\n", code));

+    

     if (code == NIL)

 	return 0;

     else {

 	code_start = (unsigned long) codeptr

 	    + HeaderValue(codeptr->header) * sizeof(lispobj);

+

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

+            DPRINTF(debug_handlers,

+                    (stderr, "compute_offset: offset %d, size = %ld\n",

+                     offset, codeptr->code_size));

+            

 	    if (offset >= codeptr->code_size) {

                 return 0;

 	    } else {

     code = find_code(scp);

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

 #define BREAKPOINT_INST 0xcc	/* INT3 */

-unsigned long fast_random_state = 1;

+/*

+ * The first two bytes of the UD1 instruction.  The mod r/m byte isn't

+ * included here.

+ */

+static const unsigned char ud1[] = {0x0f, 0xb9};

+      

+

+/*

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

 /*

 /*

- * Assuming we get here via an INT3 xxx instruction, the PC now

- * points to the interrupt code (lisp value) so we just move past

- * it. Skip the code, then if the code is an error-trap or

- * Cerror-trap then skip the data bytes that follow.

+ * Skip the UD1 instruction, and any data bytes associated with the

+ * trap.

  */

-

 void

 arch_skip_instruction(os_context_t * context)

 {

     int vlen, code;

-    DPRINTF(0, (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context)));

+    DPRINTF(debug_handlers,

+            (stderr, "[arch_skip_inst at %lx>]\n", SC_PC(context)));

+

+    /* Get the address of the beginning of the UD1 instruction */

+    char* pc = (char *) SC_PC(context);

+    

+    /*

+     * Skip over the part of the UD1 inst (0x0f, 0xb9) so we can get to the mod r/m byte

+     */

+    pc += sizeof(ud1);

+

+    code = *pc++;

+    SC_PC(context) = (unsigned long) pc;

-    /* Get and skip the lisp error code. */

-    code = *(char *) SC_PC(context)++;

     switch (code) {

       case trap_Error:

       case trap_Cerror:

 	  /* Lisp error arg vector length */

-	  vlen = *(char *) SC_PC(context)++;

+          vlen = *pc++;

+          SC_PC(context) = (unsigned long) pc;

+          

 	  /* Skip lisp error arg data bytes */

-	  while (vlen-- > 0)

-	      SC_PC(context)++;

+          SC_PC(context) = (unsigned long) (pc + vlen);

 	  break;

       case trap_Breakpoint:

+          lose("Unexpected breakpoint trap in arch_skip_instruction\n");

+          break;

       case trap_FunctionEndBreakpoint:

 	  break;

 	  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 *

+/*

+ * Installs a breakpoint (INT3) at |pc|.  We return the byte that was

+ * replaced by the int3 instruction.

+ */

 unsigned long

 arch_install_breakpoint(void *pc)

 {

-    unsigned long result = *(unsigned long *) pc;

+    unsigned long result = *(unsigned char *) pc;

+    *(unsigned char *) pc = BREAKPOINT_INST;

-    *(char *) pc = BREAKPOINT_INST;	/* x86 INT3       */

-    *((char *) pc + 1) = trap_Breakpoint;	/* Lisp trap code */

+    DPRINTF(debug_handlers,

+            (stderr, "arch_install_breakpoint at %p, old code = 0x%lx\n",

+             pc, result));

     return result;

 }

 void

 arch_remove_breakpoint(void *pc, unsigned long orig_inst)

 {

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

-    *((char *) pc + 1) = (orig_inst & 0xff00) >> 8;

+    DPRINTF(debug_handlers,

+            (stderr, "arch_remove_breakpoint: %p orig %lx\n",

+             pc, orig_inst));

+

+    /*

+     * Just restore the byte from orig_inst.

+     */

+    *(unsigned char *) pc = orig_inst & 0xff;

 }

 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)

 {

-    unsigned int *pc = (unsigned int *) SC_PC(context);

+    unsigned char *pc = (unsigned char *) SC_PC(context);

+    DPRINTF(debug_handlers,

+            (stderr, "arch_do_displaced_inst: pc %p orig_inst %lx\n",

+             pc, orig_inst));

+    

     /*

      * Put the original instruction back.

      */

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

-    *((char *) pc + 1) = (orig_inst & 0xff00) >> 8;

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

 }

+/*

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

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

+ */

 void

-sigtrap_handler(HANDLER_ARGS)

+sigill_handler(HANDLER_ARGS)

 {

     unsigned int trap;

     os_context_t* os_context = (os_context_t *) context;

-#if 0

-    fprintf(stderr, "x86sigtrap: %8x %x\n",

-            SC_PC(os_os_context), *(unsigned char *) (SC_PC(os_context) - 1));

-    fprintf(stderr, "sigtrap(%d %d %x)\n", signal, CODE(code), os_context);

-#endif

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

-#if 0

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

-	 */

-	if ((int) SC_PC(os_context) == (int) single_stepping + 1)

-	    fprintf(stderr, "* Breakpoint not re-install\n");

-	else {

-	    char *ptr = (char *) single_stepping;

-

-	    ptr[0] = BREAKPOINT_INST;	/* x86 INT3 */

-	    ptr[1] = trap_Breakpoint;

-	}

-

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

+    

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

     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.

      */

-    trap = *(unsigned char *) SC_PC(os_context);

+    DPRINTF(debug_handlers,

+            (stderr, "pc %x\n",  *(unsigned short *)SC_PC(context)));

-    switch (trap) {

+    /*

+     * If the trapping instruction is UD1, assume it's a Lisp trap

+     * that we handle here.  Otherwise, just call interrupt_handle_now

+     * for other cases.

+     */

+    if (memcmp((void *)SC_PC(context), ud1, sizeof(ud1)) == 0) {

+      /*

+       * This must match what the lisp code is doing.  The trap

+       * number is placed in the low 6-bits of the 3rd byte of the

+       * instruction.

+       */

+      trap = *(((char *)SC_PC(context)) + 2) & 0x3f;

+

+      DPRINTF(debug_handlers, (stderr, "code = %x\n", trap));

+

+      switch (trap) {

       case trap_PendingInterrupt:

-	  DPRINTF(0, (stderr, "<trap Pending Interrupt.>\n"));

-	  arch_skip_instruction(os_context);

-	  interrupt_handle_pending(os_context);

-	  break;

+        DPRINTF(debug_handlers, (stderr, "<trap Pending Interrupt.>\n"));

+        arch_skip_instruction(os_context);

+        interrupt_handle_pending(os_context);

+        break;

       case trap_Halt:

-	  {

-              FPU_STATE(fpu_state);

-              save_fpu_state(fpu_state);

+        {

+          FPU_STATE(fpu_state);

+          save_fpu_state(fpu_state);

-	      fake_foreign_function_call(os_context);

-	      lose("%%primitive halt called; the party is over.\n");

-	      undo_fake_foreign_function_call(os_context);

+          fake_foreign_function_call(os_context);

+          lose("%%primitive halt called; the party is over.\n");

+          undo_fake_foreign_function_call(os_context);

-              restore_fpu_state(fpu_state);

-	      arch_skip_instruction(os_context);

-	      break;

-	  }

+          restore_fpu_state(fpu_state);

+          arch_skip_instruction(os_context);

+          break;

+        }

       case trap_Error:

       case trap_Cerror:

-	  DPRINTF(0, (stderr, "<trap Error %x>\n", CODE(code)));

-	  interrupt_internal_error(signal, code, os_context, CODE(code) == trap_Cerror);

-	  break;

+        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 0

-	  fprintf(stderr, "*C break\n");

-#endif

-	  SC_PC(os_context) -= 1;

-

-	  handle_breakpoint(signal, CODE(code), os_context);

-#if 0

-	  fprintf(stderr, "*C break return\n");

-#endif

-	  break;

+        lose("Unexpected breakpoint trap in sigill-hander.\n");

+        break;

       case trap_FunctionEndBreakpoint:

-	  SC_PC(os_context) -= 1;

-	  SC_PC(os_context) =

-	      (int) handle_function_end_breakpoint(signal, CODE(code), os_context);

-	  break;

+        SC_PC(os_context) =

+          (int) handle_function_end_breakpoint(signal, CODE(code), os_context);

+        break;

 #ifdef trap_DynamicSpaceOverflowWarning

       case trap_DynamicSpaceOverflowWarning:

-	  interrupt_handle_space_overflow(SymbolFunction

-					  (DYNAMIC_SPACE_OVERFLOW_WARNING_HIT),

-					  os_context);

-	  break;

+        interrupt_handle_space_overflow(SymbolFunction

+                                        (DYNAMIC_SPACE_OVERFLOW_WARNING_HIT),

+                                        os_context);

+        break;

 #endif

 #ifdef trap_DynamicSpaceOverflowError

       case trap_DynamicSpaceOverflowError:

-	  interrupt_handle_space_overflow(SymbolFunction

-					  (DYNAMIC_SPACE_OVERFLOW_ERROR_HIT),

-					  os_context);

-	  break;

+        interrupt_handle_space_overflow(SymbolFunction

+                                        (DYNAMIC_SPACE_OVERFLOW_ERROR_HIT),

+                                        os_context);

+        break;

 #endif

       default:

-	  DPRINTF(0,

-		  (stderr, "[C--trap default %d %d %p]\n", signal, CODE(code),

-		   os_context));

-	  interrupt_handle_now(signal, code, os_context);

-	  break;

+        DPRINTF(debug_handlers,

+                (stderr, "[C--trap default %d %d %p]\n", signal, CODE(code),

+                 os_context));

+        interrupt_handle_now(signal, code, os_context);

+        break;

+      }

+    } else {

+      interrupt_handle_now(signal, code, os_context);

+    }

+}

+

+/*

+ * Handles the breakpoint trap (int3) and also single-stepping

+ */

+void

+sigtrap_handler(HANDLER_ARGS) 

+{

+    os_context_t* os_context = (os_context_t *) context;

+

+    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) {

+        /*

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

+	/* 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.

+	 */

+        DPRINTF(debug_handlers,

+                (stderr, "* Maybe reinstall breakpoint for pc %p with single_stepping %p\n",

+                 (void*) SC_PC(os_context), single_stepping));

+        

+        /*

+         * Lose if single-stepping didn't move us past where the

+         * breakpoint instruction was inserted.

+         */

+        if ((unsigned long) SC_PC(os_context) <= (unsigned long) single_stepping) {

+            lose("Single-stepping did not advance past the breakpoint at %p\n",

+                 single_stepping);

+        }

+

+        /*

+         * Put back the breakpoint since we skipped over it.

+         */

+        char *ptr = (char *) single_stepping;

+        ptr[0] = BREAKPOINT_INST;	/* x86 INT3 */

+

+	single_stepping = NULL;

+	return;

     }

+

+    /*

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

+     */

+    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);

+

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

 }

+

 void

 arch_install_interrupt_handlers(void)

 {

-    interrupt_install_low_level_handler(SIGILL, sigtrap_handler);

+    interrupt_install_low_level_handler(SIGILL, sigill_handler);

     interrupt_install_low_level_handler(SIGTRAP, sigtrap_handler);

 }

 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.

 #include "internals.h"

 #include "lispregs.h"

+/*

+ * Emit the appropriate instruction used for implementing traps.

+ * Currently, this is the UD1 instruction.  However, it make it

+ * easy to add the trap code, use a sequence of bytes.  The code

+ * is smashed into the mod r/m byte with the mod bits set to

+ * #b11.  This MUST be coordinated with the Lisp code and the C

+ * code.

+ *

+ * Also, clang doesn't recognize the ud1 instruction.

+ */

+#define UD1(code) \

+	.byte 0x0f		; \

+	.byte 0xb9		; \

+	.byte 0xc0 + code

+

 /* Minimize conditionalization for different OS naming schemes */

 #ifdef DARWIN	

 #define GNAME(var) _##var

  * The undefined-function trampoline.

  */

 FUNCDEF(undefined_tramp)

-	INT3

-	.byte	trap_Error

+	UD1(trap_Error)

         /* Number of argument bytes */

         .byte   2

 	.byte	UNDEFINED_SYMBOL_ERROR

 	.globl GNAME(function_end_breakpoint_trap)

 GNAME(function_end_breakpoint_trap):

-	INT3

-	.byte 	trap_FunctionEndBreakpoint

+	UD1(trap_FunctionEndBreakpoint)

 	hlt			# Should never return here.

+ENDFUNC(function_end_breakpoint_trap)

 	.globl GNAME(function_end_breakpoint_end)

 GNAME(function_end_breakpoint_end):

-

 FUNCDEF(do_pending_interrupt)

-	INT3

-	.byte 	trap_PendingInterrupt

+	UD1(trap_PendingInterrupt)

 	ret

 ENDFUNC(do_pending_interrupt)

 #ifdef trap_DynamicSpaceOverflowError

 FUNCDEF(do_dynamic_space_overflow_error)

-	INT3

-	.byte 	trap_DynamicSpaceOverflowError

+	UD1(trap_DynamicSpaceOverflowError)

 	ret

 ENDFUNC(do_dynamic_space_overflow_error)

 #endif				

 #ifdef trap_DynamicSpaceOverflowWarning

 FUNCDEF(do_dynamic_space_overflow_warning)

-	INT3

-	.byte 	trap_DynamicSpaceOverflowWarning

+	UD1(trap_DynamicSpaceOverflowWarning)

 	ret

 ENDFUNC(do_dynamic_space_overflow_warning)

 #endif				

         movl 8(%ebp),%eax

 	/* Now trap to Lisp */

-	INT3

-	.byte	trap_Error

+	UD1(trap_Error)

         /* Number of argument bytes */

         .byte   2

 	.byte	UNDEFINED_FOREIGN_SYMBOL_ERROR

Raymond Toy pushed to branch master at cmucl / cmucl

Commits:

9 changed files:

Changes: