<html lang='en'>
<head>
<meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
<title>
GitLab
</title>
</meta>
</head>
<style>
img {
max-width: 100%;
height: auto;
}
p.details {
font-style:italic;
color:#777
}
.footer p {
font-size:small;
color:#777
}
pre.commit-message {
white-space: pre-wrap;
}
.file-stats a {
text-decoration: none;
}
.file-stats .new-file {
color: #090;
}
.file-stats .deleted-file {
color: #B00;
}
</style>
<body>
<div class='content'>
<h3>
Raymond Toy pushed to branch master
at <a href="https://gitlab.common-lisp.net/cmucl/cmucl">cmucl / cmucl</a>
</h3>
<h4>
Commits:
</h4>
<ul>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/e63bc1e9a8b962dfa8715f7bd6388e36af985e0a">e63bc1e9</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-09T19:00:37Z</i>
</div>
<pre class='commit-message'>Handle FP exceptions better.
Don't restore the fpu state from the context in the interrupt handler
code (interrupt_handle_now) because that just makes the fpu state the
same as the sigcontext that received the exception. I think this was
done to reset the x87 fpu precision to 53-bit so that lisp can
continue with default double-float rounding. This isn't needed
anymore since lisp doesn't use x87 anymore.
In SIGFPE-HANDLER, don't modify the current fp state based on the
state from the sigcontext.
These two items cause the arithmetic-error exception printer to
trigger inexact when printing out the args. We add a few debugging
prints for now so we can see what the FP state is in the handler.
Remove them later.</pre>
</li>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/da2ff74d54707ab52b4b61675ba5211673fbef3c">da2ff74d</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-10T14:13:10Z</i>
</div>
<pre class='commit-message'>Handle FPU exceptions better.
In sigfpe-handler, don't modify the modes; just use whatever they
are. (They should be the default values.)
In with-float-traps-*, actually just restore the floating-point mode
to the exact original mode instead of trying to mask things out.</pre>
</li>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/d9763e9075310cfbbae3f43f0cc7d638a95872ae">d9763e90</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-10T15:42:41Z</i>
</div>
<pre class='commit-message'>In WITH-FLOAT-TRAPS-*, remove the unused junk modifying the state.
We just want to return the original modes, so remove all the old
commented out stuff that was modifying the original modes to some
strange state. This makes a lot more sense to me if
WITH-FLOAT-TRAPS-* actually restored the modes exactly as they were
before running the body.</pre>
</li>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/d7850f57887c6762fcb6c79a51226b1c7a6a9a33">d7850f57</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-12T21:21:40Z</i>
</div>
<pre class='commit-message'>Restore the FPU state before exiting.
Put an unwind-protect around the error calls. The cleanup form
restores the floating-point modes from the sigcontext so that the mode
is restored. This is needed, I think, because we throw so that the
signal handler doesn't return so the sigcontext isn't restored. If we
don't restore the fpu state, it's set to the default processor state.
We want the default state when calling error.
In this way, things like (* 1d300 1d300) signals an overflow, and when
we throw to top-level, the floating-point modes are restored to their
original values they had before.</pre>
</li>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/1fab9bf37ce138dba85e5fb85a10f8b1ad37c390">1fab9bf3</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-13T21:34:39Z</i>
</div>
<pre class='commit-message'>Clean up sigfpe-handler; add comments.</pre>
</li>
<li>
<strong><a href="https://gitlab.common-lisp.net/cmucl/cmucl/commit/94bb2d9df638a6102fc6485b76bb78eb9d4842fc">94bb2d9d</a></strong>
<div>
<span>by Raymond Toy</span>
<i>at 2016-01-16T16:02:25Z</i>
</div>
<pre class='commit-message'>Merge branch 'rtoy-15-handle-fpu-exceptions' into 'master'
Handle FPU exceptions better
Fix #15
Handle FPU exceptions better in sigfpe-handler. Linux now passes all of the tests, including the inexact tests.
We can correctly print out the operands (if available) when we receive an inexact exception.
The floating point modes are preserved as much as possible when we throw from an arithmetic-error.
See merge request !7</pre>
</li>
</ul>
<h4>2 changed files:</h4>
<ul>
<li class='file-stats'>
<a href='#diff-0'>
src/code/float-trap.lisp
</a>
</li>
<li class='file-stats'>
<a href='#diff-1'>
src/lisp/interrupt.c
</a>
</li>
</ul>
<h4>Changes:</h4>
<li id='diff-0'>
<a href='https://gitlab.common-lisp.net/cmucl/cmucl/compare/5c10ab93105fa6e095bbcbb05c2abca473aebecd...94bb2d9df638a6102fc6485b76bb78eb9d4842fc#diff-0'>
<strong>
src/code/float-trap.lisp
</strong>
</a>
<hr>
<pre class="highlight"><code><span style="color: #000000;background-color: #ffdddd">--- a/src/code/float-trap.lisp
</span><span style="color: #000000;background-color: #ddffdd">+++ b/src/code/float-trap.lisp
</span><span style="color: #aaaaaa">@@ -319,102 +319,118 @@
</span> (alien:sap-alien scp (* unix:sigcontext))))
(traps (logand (ldb float-exceptions-byte modes)
(ldb float-traps-byte modes))))
<span style="color: #000000;background-color: #ffdddd">- #+(and darwin ppc)
- (let* ((new-modes modes)
- (new-exceptions (logandc2 (ldb float-exceptions-byte new-modes)
- traps)))
- ;; (format t "sigfpe: modes = #B~32,'0b~%" modes)
- ;; (format t "sigfpe: new-exc = #B~32,'0b~%" new-exceptions)
- (setf (ldb float-exceptions-byte new-modes) new-exceptions)
- ;; Clear out all exceptions and save them to the context.
- ;;
- ;; XXX: Should we just clear out the bits for the traps that are
- ;; enabled? If we did that then the accrued exceptions would be
- ;; correct.
- (setf (ldb float-sticky-bits new-modes) 0)
- ;; Clear out the various sticky invalid operation bits too.
- ;;
- ;; XXX: Should we only do that if the invalid trap is enabled?
- (setf (ldb float-invalid-op-1-byte new-modes) 0)
- (setf (ldb float-invalid-op-2-byte new-modes) 0)
- ;; Clear the FP exception summary bit too.
- (setf (ldb float-exceptions-summary-byte new-modes) 0)
- ;; (format t "sigfpe: new modes = #B~32,'0b~%" new-modes)
- (setf (floating-point-modes) new-modes)
- (setf (sigcontext-floating-point-modes
- (alien:sap-alien scp (* unix:sigcontext)))
- new-modes))
-
- #+sse2
- (let* ((new-modes modes)
- (new-exceptions (logandc2 (ldb float-exceptions-byte new-modes)
- traps)))
- ;; Clear out the status for any enabled traps. With SSE2, if
- ;; the current exception is enabled, the next FP instruction
- ;; will cause the exception to be signaled again. Hence, we
- ;; need to clear out the exceptions that we are handling here.
- (setf (ldb float-exceptions-byte new-modes) new-exceptions)
- ;; XXX: This seems not right. Shouldn't we be setting the modes
- ;; in the sigcontext instead? This however seems to do what we
- ;; want.
- (setf (vm:floating-point-modes) new-modes))
</span><span style="color: #000000;background-color: #ddffdd">+
</span>
(multiple-value-bind (fop operands)
(let ((sym (find-symbol "GET-FP-OPERANDS" "VM")))
(if (fboundp sym)
(funcall sym (alien:sap-alien scp (* unix:sigcontext)) modes)
(values nil nil)))
<span style="color: #000000;background-color: #ffdddd">- (cond ((not (zerop (logand float-divide-by-zero-trap-bit traps)))
- (error 'division-by-zero
- :operation fop
- :operands operands))
- ((not (zerop (logand float-invalid-trap-bit traps)))
- (error 'floating-point-invalid-operation
- :operation fop
- :operands operands))
- ((not (zerop (logand float-overflow-trap-bit traps)))
- (error 'floating-point-overflow
- :operation fop
- :operands operands))
- ((not (zerop (logand float-underflow-trap-bit traps)))
- (error 'floating-point-underflow
- :operation fop
- :operands operands))
- ((not (zerop (logand float-inexact-trap-bit traps)))
- (error 'floating-point-inexact
- :operation fop
- :operands operands))
- #+x86
- ((not (zerop (logand float-denormal-trap-bit traps)))
- (error 'floating-point-denormal-operand
- :operation fop
- :operands operands))
- (t
- ;; It looks like the sigcontext on Solaris/x86 doesn't
- ;; actually save the status word of the FPU. The
- ;; operands also seem to be missing. Signal a general
- ;; arithmetic error.
- #+(and x86 solaris)
- (error _"SIGFPE with no exceptions currently enabled? (si-code = ~D)"
- code)
- ;; For all other x86 ports, we should only get here if
- ;; the SIGFPE was caused by an integer overflow on
- ;; division. For sparc and ppc, I (rtoy) don't think
- ;; there's any other way to get here since integer
- ;; overflows aren't signaled.
- ;;
- ;; In that case, FOP should be /, so we can generate a
- ;; nice arithmetic-error. It's possible to use CODE,
- ;; which is supposed to indicate what caused the
- ;; exception, but each OS is different, so we don't; FOP
- ;; can tell us.
- #-(and x86 solaris)
- (if fop
- (error 'arithmetic-error
- :operation fop
- :operands operands)
- (error _"SIGFPE with no exceptions currently enabled? (si-code = ~D)"
- code)))))))
</span><span style="color: #000000;background-color: #ddffdd">+ ;; Don't let throws get away without resetting the
+ ;; floating-point modes back to the original values which we get
+ ;; from the sigcontext. Because we can throw, we never return
+ ;; from the signal handler so the sigcontext is never restored.
+ ;; This means we need to restore the fpu state ourselves.
+ (unwind-protect
+ (cond ((not (zerop (logand float-divide-by-zero-trap-bit traps)))
+ (error 'division-by-zero
+ :operation fop
+ :operands operands))
+ ((not (zerop (logand float-invalid-trap-bit traps)))
+ (error 'floating-point-invalid-operation
+ :operation fop
+ :operands operands))
+ ((not (zerop (logand float-overflow-trap-bit traps)))
+ (error 'floating-point-overflow
+ :operation fop
+ :operands operands))
+ ((not (zerop (logand float-underflow-trap-bit traps)))
+ (error 'floating-point-underflow
+ :operation fop
+ :operands operands))
+ ((not (zerop (logand float-inexact-trap-bit traps)))
+ (error 'floating-point-inexact
+ :operation fop
+ :operands operands))
+ #+x86
+ ((not (zerop (logand float-denormal-trap-bit traps)))
+ (error 'floating-point-denormal-operand
+ :operation fop
+ :operands operands))
+ (t
+ ;; It looks like the sigcontext on Solaris/x86 doesn't
+ ;; actually save the status word of the FPU. The
+ ;; operands also seem to be missing. Signal a general
+ ;; arithmetic error.
+ #+(and x86 solaris)
+ (error _"SIGFPE with no exceptions currently enabled? (si-code = ~D)"
+ code)
+ ;; For all other x86 ports, we should only get here if
+ ;; the SIGFPE was caused by an integer overflow on
+ ;; division. For sparc and ppc, I (rtoy) don't think
+ ;; there's any other way to get here since integer
+ ;; overflows aren't signaled.
+ ;;
+ ;; In that case, FOP should be /, so we can generate a
+ ;; nice arithmetic-error. It's possible to use CODE,
+ ;; which is supposed to indicate what caused the
+ ;; exception, but each OS is different, so we don't; FOP
+ ;; can tell us.
+ #-(and x86 solaris)
+ (if fop
+ (error 'arithmetic-error
+ :operation fop
+ :operands operands)
+ (error _"SIGFPE with no exceptions currently enabled? (si-code = ~D)"
+ code))))
+ ;; Cleanup
+ (let* ((new-modes modes)
+ (new-exceptions (logandc2 (ldb float-exceptions-byte new-modes)
+ traps)))
+ #+(and darwin ppc)
+ (progn
+ ;; (format t "sigfpe: modes = #B~32,'0b~%" modes)
+ ;; (format t "sigfpe: new-exc = #B~32,'0b~%" new-exceptions)
+ (setf (ldb float-exceptions-byte new-modes) new-exceptions)
+ ;; Clear out all exceptions.
+ ;;
+ ;; XXX: Should we just clear out the bits for the traps that are
+ ;; enabled? If we did that then the accrued exceptions would be
+ ;; correct.
+ (setf (ldb float-sticky-bits new-modes) 0)
+ ;; Clear out the various sticky invalid operation bits too.
+ ;;
+ ;; XXX: Should we only do that if the invalid trap is enabled?
+ (setf (ldb float-invalid-op-1-byte new-modes) 0)
+ (setf (ldb float-invalid-op-2-byte new-modes) 0)
+ ;; Clear the FP exception summary bit too.
+ (setf (ldb float-exceptions-summary-byte new-modes) 0)
+ ;; (format t "sigfpe: new modes = #B~32,'0b~%" new-modes)
+ (setf (floating-point-modes) new-modes))
+
+ #+sse2
+ (progn
+ ;; Clear out the status for any enabled traps. With SSE2, if
+ ;; the current exception is enabled, the next FP instruction
+ ;; will cause the exception to be signaled again. Hence, we
+ ;; need to clear out the exceptions that we are handling here.
+ (setf (ldb float-exceptions-byte new-modes) new-exceptions)
+ #+nil
+ (progn
+ (format *debug-io* "sigcontext modes: #x~4x (~A)~%"
+ modes (decode-floating-point-modes modes))
+ (format *debug-io* "current modes: #x~4x (~A)~%"
+ (vm:floating-point-modes) (get-floating-point-modes))
+ (format *debug-io* "new modes: #x~x (~A)~%"
+ new-modes (decode-floating-point-modes new-modes)))
+ (setf (vm:floating-point-modes) new-modes))
+
+ #-(or sse2 (and darwin ppc))
+ (progn
+ ;; Apparently nothing needed for sparc it seems The FPU
+ ;; state in the signal handler is unchanged and it seems we
+ ;; don't need to reset it any way when we throw out.
+ ))))))
</span>
(macrolet
((with-float-traps (name merge-traps docstring)
<span style="color: #aaaaaa">@@ -440,6 +456,10 @@
</span> ;; representing the invalid operation. Otherwise, if we
;; enable the invalid trap later, these sticky bits will cause
;; an exception.
<span style="color: #000000;background-color: #ddffdd">+ ;;
+ ;; FIXME: Consider removing these for ppc. Since
+ ;; we now restore the original modes exactly, I
+ ;; don't think these are needed anymore.
</span> #+ppc
(invalid-mask (if (member :invalid traps)
(dpb 0
<span style="color: #aaaaaa">@@ -456,14 +476,8 @@
</span> (logand (,',merge-traps ,orig-modes ,trap-mask)
,exception-mask)))
,@body)
<span style="color: #000000;background-color: #ffdddd">- ;; Restore the original traps and exceptions.
- (setf (floating-point-modes)
- (logior (logand ,orig-modes ,(logior traps exceptions))
- (logand (floating-point-modes)
- ,(logand trap-mask exception-mask)
- #+ppc
- ,invalid-mask
- #+mips ,(dpb 0 float-exceptions-byte #xffffffff))))))))))))
</span><span style="color: #000000;background-color: #ddffdd">+ ;; Restore the modes exactly as they were.
+ (setf (floating-point-modes) ,orig-modes)))))))))
</span>
;; WITH-FLOAT-TRAPS-MASKED -- Public
(with-float-traps masked logand
</code></pre>
<br>
</li>
<li id='diff-1'>
<a href='https://gitlab.common-lisp.net/cmucl/cmucl/compare/5c10ab93105fa6e095bbcbb05c2abca473aebecd...94bb2d9df638a6102fc6485b76bb78eb9d4842fc#diff-1'>
<strong>
src/lisp/interrupt.c
</strong>
</a>
<hr>
<pre class="highlight"><code><span style="color: #000000;background-color: #ffdddd">--- a/src/lisp/interrupt.c
</span><span style="color: #000000;background-color: #ddffdd">+++ b/src/lisp/interrupt.c
</span><span style="color: #aaaaaa">@@ -252,7 +252,9 @@ interrupt_handle_now(HANDLER_ARGS)
</span>
handler = interrupt_handlers[signal];
<span style="color: #000000;background-color: #ddffdd">+#if 0
</span> RESTORE_FPU(context);
<span style="color: #000000;background-color: #ddffdd">+#endif
</span>
if (handler.c == (void (*)(HANDLER_ARGS)) SIG_IGN)
return;
<span style="color: #aaaaaa">@@ -333,7 +335,9 @@ maybe_now_maybe_later(HANDLER_ARGS)
</span> setup_pending_signal(signal, code, context);
arch_set_pseudo_atomic_interrupted(context);
} else {
<span style="color: #000000;background-color: #ddffdd">+#if 0
</span> RESTORE_FPU(context);
<span style="color: #000000;background-color: #ddffdd">+#endif
</span> interrupt_handle_now(signal, code, context);
}
</code></pre>
<br>
</li>
</div>
<div class='footer' style='margin-top: 10px;'>
<p>
—
<br>
<a href="https://gitlab.common-lisp.net/cmucl/cmucl/compare/5c10ab93105fa6e095bbcbb05c2abca473aebecd...94bb2d9df638a6102fc6485b76bb78eb9d4842fc">View it on GitLab</a>.
<br>
You're receiving this email because of your account on gitlab.common-lisp.net.
If you'd like to receive fewer emails, you can adjust your notification settings.
</p>
</div>
</body>
</html>