lazy *STACK-TOP-HINT*s

[sbcl.git] / src / code / target-signal.lisp

diff --git a/src/code/target-signal.lisp b/src/code/target-signal.lisp
index 840604e..7394695 100644 (file)
--- a/src/code/target-signal.lisp
+++ b/src/code/target-signal.lisp
@@ -44,23 +44,22 @@
     ;; mechanism there are no extra frames on the stack from a
     ;; previous signal handler when the next signal is delivered
     ;; provided there is no WITH-INTERRUPTS.
-    (let ((*unblock-deferrables-on-enabling-interrupts-p* t))
+    (let ((*unblock-deferrables-on-enabling-interrupts-p* t)
+          (sb!debug:*stack-top-hint* (or sb!debug:*stack-top-hint* 'invoke-interruption)))
       (with-interrupt-bindings
-        (let ((sb!debug:*stack-top-hint*
-                (nth-value 1 (sb!kernel:find-interrupted-name-and-frame))))
-          (sb!thread::without-thread-waiting-for (:already-without-interrupts t)
-              (allow-with-interrupts
-                (nlx-protect (funcall function)
-                             ;; We've been running with deferrables
-                             ;; blocked in Lisp called by a C signal
-                             ;; handler. If we return normally the sigmask
-                             ;; in the interrupted context is restored.
-                             ;; However, if we do an nlx the operating
-                             ;; system will not restore it for us.
-                             (when *unblock-deferrables-on-enabling-interrupts-p*
-                               ;; This means that storms of interrupts
-                               ;; doing an nlx can still run out of stack.
-                               (unblock-deferrable-signals))))))))))
+        (sb!thread::without-thread-waiting-for (:already-without-interrupts t)
+          (allow-with-interrupts
+            (nlx-protect (funcall function)
+                         ;; We've been running with deferrables
+                         ;; blocked in Lisp called by a C signal
+                         ;; handler. If we return normally the sigmask
+                         ;; in the interrupted context is restored.
+                         ;; However, if we do an nlx the operating
+                         ;; system will not restore it for us.
+                         (when *unblock-deferrables-on-enabling-interrupts-p*
+                           ;; This means that storms of interrupts
+                           ;; doing an nlx can still run out of stack.
+                           (unblock-deferrable-signals)))))))))
 
 (defmacro in-interruption ((&key) &body body)
   #!+sb-doc