Avoid some exceptions in WAIT-UNTIL-FD-USABLE on Windows
[sbcl.git] / src / code / float-trap.lisp
1 ;;;; This file contains stuff for controlling floating point traps. It
2 ;;;; is IEEE float specific, but should work for pretty much any FPU
3 ;;;; where the state fits in one word and exceptions are represented
4 ;;;; by bits being set.
5
6 ;;;; This software is part of the SBCL system. See the README file for
7 ;;;; more information.
8 ;;;;
9 ;;;; This software is derived from the CMU CL system, which was
10 ;;;; written at Carnegie Mellon University and released into the
11 ;;;; public domain. The software is in the public domain and is
12 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
13 ;;;; files for more information.
14
15 (in-package "SB!VM")
16
17 (eval-when (:compile-toplevel :load-toplevel :execute)
18
19 (defparameter *float-trap-alist*
20   (list (cons :underflow float-underflow-trap-bit)
21         (cons :overflow float-overflow-trap-bit)
22         (cons :inexact float-inexact-trap-bit)
23         (cons :invalid float-invalid-trap-bit)
24         (cons :divide-by-zero float-divide-by-zero-trap-bit)
25         #!+x86 (cons :denormalized-operand float-denormal-trap-bit)))
26
27 (defparameter *rounding-mode-alist*
28   (list (cons :nearest float-round-to-nearest)
29         (cons :zero float-round-to-zero)
30         (cons :positive-infinity float-round-to-positive)
31         (cons :negative-infinity float-round-to-negative)))
32
33 #!+x86
34 (defparameter *precision-mode-alist*
35   (list (cons :24-bit float-precision-24-bit)
36         (cons :53-bit float-precision-53-bit)
37         (cons :64-bit float-precision-64-bit)))
38
39 ;;; Return a mask with all the specified float trap bits set.
40 (defun float-trap-mask (names)
41   (reduce #'logior
42           (mapcar (lambda (x)
43                     (or (cdr (assoc x *float-trap-alist*))
44                         (error "unknown float trap kind: ~S" x)))
45                   names)))
46 ) ; EVAL-WHEN
47
48 ;;; interpreter stubs for floating point modes get/setters for the
49 ;;; alpha have been removed to alpha-vm.lisp, as they are implemented
50 ;;; in C rather than as VOPs. Likewise for x86-64 and mips.
51 #!-(or alpha x86-64 mips)
52 (progn
53   (defun floating-point-modes ()
54     (floating-point-modes))
55   (defun (setf floating-point-modes) (new)
56     (setf (floating-point-modes) new)))
57
58 (defun set-floating-point-modes (&key
59                                  (traps nil traps-p)
60                                  (rounding-mode nil round-p)
61                                  (current-exceptions nil current-x-p)
62                                  (accrued-exceptions nil accrued-x-p)
63                                  (fast-mode nil fast-mode-p)
64                                  #!+x86 (precision nil precisionp))
65   #!+sb-doc
66   "This function sets options controlling the floating-point
67 hardware. If a keyword is not supplied, then the current value is
68 preserved. Possible keywords:
69
70  :TRAPS
71    A list of the exception conditions that should cause traps.
72    Possible exceptions are :UNDERFLOW, :OVERFLOW, :INEXACT, :INVALID,
73   :DIVIDE-BY-ZERO, and on the X86 :DENORMALIZED-OPERAND.
74
75 :ROUNDING-MODE
76    The rounding mode to use when the result is not exact. Possible
77    values are :NEAREST, :POSITIVE-INFINITY, :NEGATIVE-INFINITY and
78    :ZERO.  Setting this away from :NEAREST is liable to upset SBCL's
79    maths routines which depend on it.
80
81 :CURRENT-EXCEPTIONS
82 :ACCRUED-EXCEPTIONS
83    These arguments allow setting of the exception flags. The main
84    use is setting the accrued exceptions to NIL to clear them.
85
86 :FAST-MODE
87    Set the hardware's \"fast mode\" flag, if any. When set, IEEE
88    conformance or debuggability may be impaired. Some machines don't
89    have this feature, and some SBCL ports don't implement it anyway
90    -- in such cases the value is always NIL.
91
92 :PRECISION (x86 only)
93   :24-bit, :53-bit and :64-bit, for the internal precision of the mantissa.
94
95 GET-FLOATING-POINT-MODES may be used to find the floating point modes
96 currently in effect. SAVE-LISP-AND-DIE preserves the floating point modes
97 in effect."
98   (let ((modes (floating-point-modes)))
99     (when traps-p
100       (setf (ldb float-traps-byte modes) (float-trap-mask traps)))
101     (when round-p
102       (setf (ldb float-rounding-mode modes)
103             (or (cdr (assoc rounding-mode *rounding-mode-alist*))
104                 (error "unknown rounding mode: ~S" rounding-mode))))
105     (when current-x-p
106       (setf (ldb float-exceptions-byte modes)
107             (float-trap-mask current-exceptions)))
108     (when accrued-x-p
109       (setf (ldb float-sticky-bits modes)
110             (float-trap-mask accrued-exceptions)))
111     (when fast-mode-p
112       (if fast-mode
113           (setq modes (logior float-fast-bit modes))
114           (setq modes (logand (lognot float-fast-bit) modes))))
115     #!+x86
116     (when precisionp
117       (setf (ldb float-precision-control modes)
118             (or (cdr (assoc precision *precision-mode-alist*))
119                 (error "unknown precision mode: ~S" precision))))
120     ;; FIXME: This apparently doesn't work on Darwin
121     #!-darwin (setf (floating-point-modes) modes))
122   (values))
123
124 (defun get-floating-point-modes ()
125   #!+sb-doc
126   "This function returns a list representing the state of the floating
127 point modes. The list is in the same format as the &KEY arguments to
128 SET-FLOATING-POINT-MODES, i.e.
129
130   (apply #'set-floating-point-modes (get-floating-point-modes))
131
132 sets the floating point modes to their current values (and thus is a no-op)."
133   (flet ((exc-keys (bits)
134            (macrolet ((frob ()
135                         `(collect ((res))
136                            ,@(mapcar (lambda (x)
137                                        `(when (logtest bits ,(cdr x))
138                                           (res ',(car x))))
139                                      *float-trap-alist*)
140                            (res))))
141              (frob))))
142     (let ((modes (floating-point-modes)))
143       `(:traps ,(exc-keys (ldb float-traps-byte modes))
144         :rounding-mode ,(car (rassoc (ldb float-rounding-mode modes)
145                                      *rounding-mode-alist*))
146         :current-exceptions ,(exc-keys (ldb float-exceptions-byte modes))
147         :accrued-exceptions ,(exc-keys (ldb float-sticky-bits modes))
148         :fast-mode ,(logtest float-fast-bit modes)
149         #!+x86 :precision
150         #!+x86 ,(car (rassoc (ldb float-precision-control modes)
151                              *precision-mode-alist*))))))
152
153 ;;; FIXME: For some unknown reason, NetBSD/x86 won't run with the
154 ;;; :INVALID trap enabled. That should be fixed, but not today...
155 ;;;
156 ;;; PRINT seems not to like x86 NPX denormal floats like
157 ;;; LEAST-NEGATIVE-SINGLE-FLOAT, so the :UNDERFLOW exceptions are
158 ;;; disabled by default. Joe User can explicitly enable them if
159 ;;; desired.
160 (defvar *saved-floating-point-modes*
161   '(:traps (:overflow #!-(or netbsd ppc) :invalid :divide-by-zero)
162     :rounding-mode :nearest :current-exceptions nil
163     :accrued-exceptions nil :fast-mode nil
164     #!+x86 :precision #!+x86 :53-bit))
165
166 (defun float-cold-init-or-reinit ()
167   (apply #'set-floating-point-modes *saved-floating-point-modes*))
168
169 (defun float-deinit ()
170   (setf *saved-floating-point-modes* (get-floating-point-modes)))
171
172 ;;; Return true if any of the named traps are currently trapped, false
173 ;;; otherwise.
174 (defmacro current-float-trap (&rest traps)
175   `(not (zerop (logand ,(dpb (float-trap-mask traps) float-traps-byte 0)
176                        (floating-point-modes)))))
177
178 ;;; SIGFPE code to floating-point error
179 #!-win32
180 (defparameter *sigfpe-code-error-alist*
181   (list (cons sb!unix::fpe-intovf 'floating-point-overflow)
182         (cons sb!unix::fpe-intdiv 'division-by-zero)
183         (cons sb!unix::fpe-fltdiv 'division-by-zero)
184         (cons sb!unix::fpe-fltovf 'floating-point-overflow)
185         (cons sb!unix::fpe-fltund 'floating-point-underflow)
186         (cons sb!unix::fpe-fltres 'floating-point-inexact)
187         (cons sb!unix::fpe-fltinv 'floating-point-invalid-operation)
188         (cons sb!unix::fpe-fltsub 'floating-point-exception)))
189
190 ;;; Signal the appropriate condition when we get a floating-point error.
191 #!-win32
192 (defun sigfpe-handler (signal info context)
193   (declare (ignore signal context))
194   (declare (type system-area-pointer info))
195   (let ((code (sb!unix::siginfo-code info)))
196     (with-interrupts
197         (error (or (cdr (assoc code *sigfpe-code-error-alist*))
198                    'floating-point-exception)))))
199
200 ;;; Execute BODY with the floating point exceptions listed in TRAPS
201 ;;; masked (disabled). TRAPS should be a list of possible exceptions
202 ;;; which includes :UNDERFLOW, :OVERFLOW, :INEXACT, :INVALID and
203 ;;; :DIVIDE-BY-ZERO and on the X86 :DENORMALIZED-OPERAND. The
204 ;;; respective accrued exceptions are cleared at the start of the body
205 ;;; to support their testing within, and restored on exit.
206 (defmacro with-float-traps-masked (traps &body body)
207   (let ((traps (dpb (float-trap-mask traps) float-traps-byte 0))
208         (exceptions (dpb (float-trap-mask traps) float-sticky-bits 0))
209         (trap-mask (dpb (lognot (float-trap-mask traps))
210                         float-traps-byte #xffffffff))
211         (exception-mask (dpb (lognot (float-trap-mask traps))
212                              float-sticky-bits #xffffffff))
213         (orig-modes (gensym)))
214     `(let ((,orig-modes (floating-point-modes)))
215       (unwind-protect
216            (progn
217              (setf (floating-point-modes)
218                    (logand ,orig-modes ,(logand trap-mask exception-mask)))
219              ,@body)
220         ;; Restore the original traps and exceptions.
221         (setf (floating-point-modes)
222               (logior (logand ,orig-modes ,(logior traps exceptions))
223                       (logand (floating-point-modes)
224                               ,(logand trap-mask exception-mask))))))))