[Sbcl-commits] CVS: sbcl/src/compiler/x86 call.lisp, 1.32, 1.33 parms.lisp, 1.61, 1.62

[Juho S. <js...@us...>]

Update of /cvsroot/sbcl/sbcl/src/compiler/x86
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv6222/src/compiler/x86

Modified Files:
	call.lisp parms.lisp 
Log Message:
0.9.16.38:
        Rewrite the single-stepper to solve the compilation/run-time
        performance and type-inference inaccuracy problems with the old
        approach. Also make some UI improvements to the stepper.

        * The IR1 stage no longer instruments the code. Instead it
          only detects function call forms which should (according to
          the policy) be steppable, and records a string
          representation of those forms in the matching combination
          nodes (to be stored in the debug-info).
        * Modify the function call vops to emit some instrumentation just
          before the actual call happens. This will check either the
          symbol-value of *STEPPING* (unithreaded) or the new STEPPING
          slot of threads (multithreaded) and trap if it's true. The
          trap handler will replace the closure / fdefn that was about
          to be called with a wrapper, which will signal a stepper
          condition and then call the original function.
        * Emit a similar bit of instrumentation before any call that
          got optimized to a simple VOP. The difference is that the
          only thing that the trap handler will do is to directly
          signal the condition.
        * The necessary VOP / runtime changes have only been done on
          x86, x86-64 and ppc so far. Alpha, Mips and Sparc should
          still compile, but the stepper won't work there.
        * Remove the old single-stepper REPL, and instead integrate the
          stepper into the debugger.
        * Add STEP-OUT functionality (stop stepping temporarily,
          resuming it once the current function returns).


Index: call.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86/call.lisp,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -d -r1.32 -r1.33
--- call.lisp	17 Sep 2006 02:26:41 -0000	1.32
+++ call.lisp	18 Sep 2006 20:09:14 -0000	1.33
@@ -759,7 +759,8 @@
                (:info
                ,@(unless (or variable (eq return :tail)) '(arg-locs))
                ,@(unless variable '(nargs))
-               ,@(when (eq return :fixed) '(nvals)))
+               ,@(when (eq return :fixed) '(nvals))
+               step-instrumenting)
 
                (:ignore
                ,@(unless (or variable (eq return :tail)) '(arg-locs))
@@ -893,6 +894,12 @@
                           (move ebp-tn new-fp) ; NB - now on new stack frame.
                           )))
 
+               (when step-instrumenting
+                 (emit-single-step-test)
+                 (inst jmp :eq DONE)
+                 (inst break single-step-around-trap))
+               DONE
+
                (note-this-location vop :call-site)
 
                (inst ,(if (eq return :tail) 'jmp 'call)
@@ -1436,3 +1443,37 @@
   (def unknown-key-arg-error unknown-key-arg-error
     sb!c::%unknown-key-arg-error key)
   (def nil-fun-returned-error nil-fun-returned-error nil fun))
+
+;;; Single-stepping
+
+(defun emit-single-step-test ()
+  ;; We use different ways of representing whether stepping is on on
+  ;; +SB-THREAD / -SB-THREAD: on +SB-THREAD, we use a slot in the
+  ;; thread structure. On -SB-THREAD we use the value of a static
+  ;; symbol. Things are done this way, since reading a thread-local
+  ;; slot from a symbol would require an extra register on +SB-THREAD,
+  ;; and reading a slot from a thread structure would require an extra
+  ;; register on -SB-THREAD.
+  #!+sb-thread
+  (progn
+    (inst fs-segment-prefix)
+    (inst cmp (make-ea :dword
+                       :disp (* thread-stepping-slot n-word-bytes))
+          nil-value))
+  #!-sb-thread
+  (inst cmp (make-ea :dword
+                     :disp (+ nil-value (static-symbol-offset
+                                         'sb!impl::*stepping*)
+                              (* symbol-value-slot n-word-bytes)
+                              (- other-pointer-lowtag)))
+        nil-value))
+
+(define-vop (step-instrument-before-vop)
+  (:policy :fast-safe)
+  (:vop-var vop)
+  (:generator 3
+     (emit-single-step-test)
+     (inst jmp :eq DONE)
+     (inst break single-step-before-trap)
+     DONE
+     (note-this-location vop :step-before-vop)))

Index: parms.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86/parms.lisp,v
retrieving revision 1.61
retrieving revision 1.62
diff -u -d -r1.61 -r1.62
--- parms.lisp	15 Sep 2006 14:39:45 -0000	1.61
+++ parms.lisp	18 Sep 2006 20:09:14 -0000	1.62
@@ -270,7 +270,8 @@
   cerror
   breakpoint
   fun-end-breakpoint
-  single-step-breakpoint
+  single-step-around
+  single-step-before
   #!+win32 context-restore) ;; HACK: The Win32 exception handling system does wrong things with this.
 ;;; FIXME: It'd be nice to replace all the DEFENUMs with something like
 ;;;   (WITH-DEF-ENUM (:START 8)
@@ -280,7 +281,7 @@
 ;;; for the benefit of anyone doing a lexical search for definitions
 ;;; of these symbols.
 
-(defenum (:prefix object-not- :suffix -trap :start 16)
+(defenum (:prefix object-not- :suffix -trap :start 24)
   list
   instance)