From 1440af76f7e4ad4c8f837b9a7c1f9229d57163e6 Mon Sep 17 00:00:00 2001
From: cshapiro <cshapiro>
Date: Wed, 14 Nov 2007 10:04:35 +0000
Subject: [PATCH] * Change the way the x87 precision control is managed.  While
 in Lisp,   the precision control will always be set to double precision.  For
   the duration of calls into C, the precision control will be set to   the
 ABI default.  On Linux and Darwin this is double extended   precision.  On
 all other platforms the precision control is left as   double precision.  The
 specious FLOAT-ACCURACY declaration has been   eliminated.

* Shorten the precision control field to 24-bits by disposing of the
  unexamined high order eight bits of the status word.  This compacts
  the code generated around floating point mode changes and reduces
  consing.

* Eliminate unnecessary uses of FLDENV and FSTENV.  We can substitute a
  use of FSTENV with FSTSW in FLOATING-POINT-MODES.  This reduces the
  number of cycles to access the relevant mode bits by a factor of
  thirty.  We cannot eliminate FLDENV in SET-FLOATING-POINT-MODES, but
  the common case does not require an update to the status word.  A
  fast path has been added to the VOP that improves the execution time
  by at least a factor of fifteen.

* Remove the precision control option to SET-FLOATING-POINT-MODES.  It
  is the responsibility of the compiler to generating code that yields
  correctly rounded results in double and single precision.
---
 bootfiles/19d/boot-2007-11-2.lisp |  8 ++++
 code/env-access.lisp              |  8 ++--
 code/float-trap.lisp              | 35 ++--------------
 code/lispinit.lisp                |  5 +--
 code/unix-glibc2.lisp             | 26 +++++-------
 compiler/macros.lisp              |  4 +-
 compiler/proclaim.lisp            | 20 ++-------
 compiler/x86/c-call.lisp          | 48 +++++-----------------
 compiler/x86/float.lisp           | 67 +++++++++++++------------------
 compiler/x86/parms.lisp           |  8 +---
 10 files changed, 72 insertions(+), 157 deletions(-)
 create mode 100644 bootfiles/19d/boot-2007-11-2.lisp

diff --git a/bootfiles/19d/boot-2007-11-2.lisp b/bootfiles/19d/boot-2007-11-2.lisp
new file mode 100644
index 000000000..8bdae1072
--- /dev/null
+++ b/bootfiles/19d/boot-2007-11-2.lisp
@@ -0,0 +1,8 @@
+(in-package :c)
+(handler-bind ((error (lambda (c)
+			(declare (ignore c))
+			(invoke-restart 'kernel::continue))))
+  (defconstant policy-parameter-slots
+    '((speed . cookie-speed) (space . cookie-space) (safety . cookie-safety)
+      (cspeed . cookie-cspeed) (brevity . cookie-brevity)
+      (debug . cookie-debug))))
diff --git a/code/env-access.lisp b/code/env-access.lisp
index ad9038741..6370fa1d0 100644
--- a/code/env-access.lisp
+++ b/code/env-access.lisp
@@ -6,7 +6,7 @@
 ;;;
 
 (ext:file-comment
- "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/env-access.lisp,v 1.3 2007/08/17 14:09:20 rtoy Exp $")
+ "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/env-access.lisp,v 1.4 2007/11/14 10:04:33 cshapiro Exp $")
 
 ;;;
 ;;; **********************************************************************
@@ -76,8 +76,7 @@ alist of declarations that apply to the apparent binding of VAR."
 	       (list 'compilation-speed (cookie-cspeed cookie))
 	       (list 'space (cookie-space cookie))
 	       (list 'debug (cookie-debug cookie))
-	       (list 'inhibit-warnings (cookie-brevity cookie))
-	       (list 'float-accuracy (cookie-float-accuracy cookie)))
+	       (list 'inhibit-warnings (cookie-brevity cookie)))
          ))
       (ext:optimize-interface
        (let ((cookie (lexenv-interface-cookie lexenv)))
@@ -86,8 +85,7 @@ alist of declarations that apply to the apparent binding of VAR."
 	       (list 'compilation-speed (cookie-cspeed cookie))
 	       (list 'space (cookie-space cookie))
 	       (list 'debug (cookie-debug cookie))
-	       (list 'inhibit-warnings (cookie-brevity cookie))
-	       (list 'float-accuracy (cookie-float-accuracy cookie)))))
+	       (list 'inhibit-warnings (cookie-brevity cookie)))))
       (declaration
        (cond (env
 	      ;; What are we supposed to do if an environment is
diff --git a/code/float-trap.lisp b/code/float-trap.lisp
index a0646e43c..7d1b5117a 100644
--- a/code/float-trap.lisp
+++ b/code/float-trap.lisp
@@ -5,7 +5,7 @@
 ;;; Carnegie Mellon University, and has been placed in the public domain.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/float-trap.lisp,v 1.30 2007/07/06 08:04:39 cshapiro Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/float-trap.lisp,v 1.31 2007/11/14 10:04:33 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -48,12 +48,6 @@
 	(cons :zero float-round-to-zero)
 	(cons :positive-infinity float-round-to-positive)
 	(cons :negative-infinity float-round-to-negative)))
-
-#+x86
-(defconstant precision-control-alist
-  (list (cons :24-bit float-precision-24-bit)
-	(cons :53-bit float-precision-53-bit)
-	(cons :64-bit float-precision-64-bit)))
   
 ); Eval-When (Compile Load Eval)
 
@@ -70,8 +64,7 @@
 				      (rounding-mode nil round-p)
 				      (current-exceptions nil current-x-p)
 				      (accrued-exceptions nil accrued-x-p)
-				      (fast-mode nil fast-mode-p)
-				      (precision-control nil precision-control-p))
+				      (fast-mode nil fast-mode-p))
   "This function sets options controlling the floating-point hardware.  If a
   keyword is not supplied, then the current value is preserved.  Possible
   keywords:
@@ -97,15 +90,8 @@
        conformance or debuggability may be impaired.  Some machines may not
        have this feature, in which case the value is always NIL.
 
-   :PRECISION-CONTROL
-       On the x86 architecture, you can set the precision of the arithmetic
-       to :24-BIT, :53-BIT, or :64-BIT mode, corresponding to IEEE single
-       precision, double precision, and extended double precision.
-
    GET-FLOATING-POINT-MODES may be used to find the floating point modes
    currently in effect."
-  #-x86
-  (declare (ignore precision-control))
   (let ((modes (floating-point-modes)))
     (when traps-p
       (setf (ldb float-traps-byte modes) (float-trap-mask traps)))
@@ -132,15 +118,6 @@
       (if fast-mode
 	  (setq modes (logior float-fast-bit modes))
 	  (setq modes (logand (lognot float-fast-bit) modes))))
-    #+x86
-    (when precision-control-p
-      (setf (ldb float-precision-control modes)
-	    (or (cdr (assoc precision-control precision-control-alist))
-		(error "Unknown precision mode: ~S." precision-control))))
-    #-x86
-    (when precision-control-p
-      (warn "Precision control only available for x86"))
-    
     (setf (floating-point-modes) modes))
     
   (values))
@@ -170,13 +147,7 @@
 				     rounding-mode-alist))
 	:current-exceptions ,(exc-keys (ldb float-exceptions-byte modes))
 	:accrued-exceptions ,(exc-keys (ldb float-sticky-bits modes))
-	:fast-mode ,(logtest float-fast-bit modes)
-	#+x86
-	:precision-control
-	#+x86
-	,(car (rassoc (ldb float-precision-control modes)
-		      precision-control-alist))
-	))))
+	:fast-mode ,(logtest float-fast-bit modes)))))
 
   
 ;;; CURRENT-FLOAT-TRAP  --  Interface
diff --git a/code/lispinit.lisp b/code/lispinit.lisp
index 9c96c0de3..b8f5c5fe3 100644
--- a/code/lispinit.lisp
+++ b/code/lispinit.lisp
@@ -5,7 +5,7 @@
 ;;; Carnegie Mellon University, and has been placed in the public domain.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/lispinit.lisp,v 1.77 2007/10/04 19:58:19 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/lispinit.lisp,v 1.78 2007/11/14 10:04:33 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -400,8 +400,7 @@
   (print-and-call kernel::signal-init)
   (setf (alien:extern-alien "internal_errors_enabled" boolean) t)
 
-  (set-floating-point-modes :traps '(:overflow :invalid :divide-by-zero)
-			    #+x86 :precision-control #+x86 :53-bit)
+  (set-floating-point-modes :traps '(:overflow :invalid :divide-by-zero))
   ;; This is necessary because some of the initial top level forms might
   ;; have changed the compilation policy in strange ways.
   (print-and-call c::proclaim-init)
diff --git a/code/unix-glibc2.lisp b/code/unix-glibc2.lisp
index 539ca9b85..1fc55a86c 100644
--- a/code/unix-glibc2.lisp
+++ b/code/unix-glibc2.lisp
@@ -5,7 +5,7 @@
 ;;; Carnegie Mellon University, and has been placed in the public domain.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/unix-glibc2.lisp,v 1.41 2007/11/09 19:24:36 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/code/unix-glibc2.lisp,v 1.42 2007/11/14 10:04:33 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -350,26 +350,22 @@
       (format nil "Unknown error [~d]" error-number)))
 
 (defmacro syscall ((name &rest arg-types) success-form &rest args)
-  `(locally
-    (declare (optimize (ext::float-accuracy 0)))
-    (let ((result (alien-funcall (extern-alien ,name (function int ,@arg-types))
-				 ,@args)))
-      (if (minusp result)
-	  (values nil (unix-errno))
-	  ,success-form))))
+  `(let ((result (alien-funcall (extern-alien ,name (function int ,@arg-types))
+				,@args)))
+     (if (minusp result)
+	 (values nil (unix-errno))
+	 ,success-form)))
 
 ;;; Like syscall, but if it fails, signal an error instead of returning error
 ;;; codes.  Should only be used for syscalls that will never really get an
 ;;; error.
 ;;;
 (defmacro syscall* ((name &rest arg-types) success-form &rest args)
-  `(locally
-    (declare (optimize (ext::float-accuracy 0)))
-    (let ((result (alien-funcall (extern-alien ,name (function int ,@arg-types))
-				 ,@args)))
-      (if (minusp result)
-	  (error "Syscall ~A failed: ~A" ,name (get-unix-error-msg))
-	  ,success-form))))
+  `(let ((result (alien-funcall (extern-alien ,name (function int ,@arg-types))
+				,@args)))
+     (if (minusp result)
+	 (error "Syscall ~A failed: ~A" ,name (get-unix-error-msg))
+	 ,success-form)))
 
 (defmacro void-syscall ((name &rest arg-types) &rest args)
   `(syscall (,name ,@arg-types) (values t 0) ,@args))
diff --git a/compiler/macros.lisp b/compiler/macros.lisp
index 7e30ef803..9b99006ff 100644
--- a/compiler/macros.lisp
+++ b/compiler/macros.lisp
@@ -5,7 +5,7 @@
 ;;; Carnegie Mellon University, and has been placed in the public domain.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/macros.lisp,v 1.55 2005/08/04 16:00:04 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/macros.lisp,v 1.56 2007/11/14 10:04:34 cshapiro Rel $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -52,7 +52,7 @@
 (defconstant policy-parameter-slots
   '((speed . cookie-speed) (space . cookie-space) (safety . cookie-safety)
     (cspeed . cookie-cspeed) (brevity . cookie-brevity)
-    (debug . cookie-debug) (float-accuracy . cookie-float-accuracy)))
+    (debug . cookie-debug)))
 
 ;;; Find-Used-Parameters  --  Internal
 ;;;
diff --git a/compiler/proclaim.lisp b/compiler/proclaim.lisp
index 6d8746d3a..b32ae70d0 100644
--- a/compiler/proclaim.lisp
+++ b/compiler/proclaim.lisp
@@ -5,7 +5,7 @@
 ;;; Carnegie Mellon University, and has been placed in the public domain.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/proclaim.lisp,v 1.43 2005/10/21 17:56:07 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/proclaim.lisp,v 1.44 2007/11/14 10:04:35 cshapiro Rel $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -18,8 +18,7 @@
 (in-package "C")
 
 (in-package "EXTENSIONS")
-(export '(inhibit-warnings freeze-type optimize-interface constant-function
-	  float-accuracy))
+(export '(inhibit-warnings freeze-type optimize-interface constant-function))
 (in-package "KERNEL")
 (export '(note-name-defined define-function-name undefine-function-name
 	  *type-system-initialized* %note-type-defined))
@@ -42,16 +41,7 @@
   (safety nil :type (or (rational 0 3) null))
   (cspeed nil :type (or (rational 0 3) null))
   (brevity nil :type (or (rational 0 3) null))
-  (debug nil :type (or (rational 0 3) null))
-  ;; float-accuracy is intended for x86 FPU.  It has no effect on
-  ;; other architectures. float-accuracy controls the rounding-mode.
-  ;; A value of 3 means that when calling out to C, we set the x86 FPU
-  ;; rounding mode to 64-bits.  Otherwise the rounding-mode is left
-  ;; unchanged.  By setting the rounding-mode to 53-bit,
-  ;; double-float-epsilon really is double-float-epsilon.  However
-  ;; calling out to C with 53-bit mode affects the accuracy of
-  ;; floating-point functions, which normally want 64-bit.
-  (float-accuracy 3 :type (or (rational 0 3) null)))
+  (debug nil :type (or (rational 0 3) null)))
 
 
 ;;; The *default-cookie* represents the current global compiler policy
@@ -73,8 +63,7 @@
 (defun proclaim-init ()
   (setf *default-cookie*
 	(make-cookie :safety 1 :speed 1 :space 1 :cspeed 1
-		     :brevity 1 :debug 2
-		     :float-accuracy 3))
+		     :brevity 1 :debug 2))
   (setf *default-interface-cookie*
 	(make-cookie)))
 ;;;
@@ -313,7 +302,6 @@
 		(compilation-speed (setf (cookie-cspeed res) value))
 		((inhibit-warnings brevity) (setf (cookie-brevity res) value))
 		((debug-info debug) (setf (cookie-debug res) value))
-		(float-accuracy (setf (cookie-float-accuracy res) value))
 		(t
 		 (compiler-warning "Unknown optimization quality ~S in ~S."
 				   (car quality) spec))))
diff --git a/compiler/x86/c-call.lisp b/compiler/x86/c-call.lisp
index e2338f17a..33ec7d6fa 100644
--- a/compiler/x86/c-call.lisp
+++ b/compiler/x86/c-call.lisp
@@ -7,7 +7,7 @@
 ;;; Scott Fahlman or slisp-group@cs.cmu.edu.
 ;;;
 (ext:file-comment
- "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/c-call.lisp,v 1.18 2007/10/04 19:58:20 rtoy Exp $")
+ "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/c-call.lisp,v 1.19 2007/11/14 10:04:35 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -262,61 +262,33 @@
   (:node-var node)
   (:generator 0
     (assert (location= result esp-tn))
-    ;; Set the rounding precision to 64-bits when calling out to C.
-    (when (policy node (= float-accuracy 3))
+    #+(or darwin linux)
+    (progn
       (inst sub esp-tn 4)
       (inst fnstcw (make-ea :word :base esp-tn))
-      (inst wait)
+      (inst and (make-ea :word :base esp-tn) #xcff)
       (inst or (make-ea :word :base esp-tn) #x300)
       (inst fldcw (make-ea :word :base esp-tn))
-      (inst wait))
+      (inst add esp-tn 4))
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
 	(inst sub esp-tn delta)))
     #+darwin (inst and esp-tn #xfffffff0)
     (move result esp-tn)))
 
-#+nil
-(define-vop (dealloc-number-stack-space)
-  (:info amount)
-  (:node-var node)
-  (:generator 0
-    (unless (zerop amount)
-      (let ((delta (logandc2 (+ amount 3) 3)))
-	(inst add esp-tn delta)))
-    ;; Reset the rounding precision to 53-bits
-    (when (policy node (= float-accuracy 3))
-      (inst fnstcw (make-ea :word :base esp-tn))
-      (inst wait)
-      (inst and (make-ea :word :base esp-tn) #xfeff)
-      (inst fldcw (make-ea :word :base esp-tn))
-      (inst wait)
-      (inst add esp-tn 4))))
-
 (define-vop (dealloc-number-stack-space)
   (:info amount)
   (:node-var node)
-  (:temporary (:sc unsigned-reg) precision)
-  (:temporary (:sc word-reg) cw)
   (:generator 0
     (unless (zerop amount)
       (let ((delta (logandc2 (+ amount 3) 3)))
 	(inst add esp-tn delta)))
-    ;; Reset the rounding precision to 53-bits
-    (when (policy node (= float-accuracy 3))
+    #+(or darwin linux)
+    (progn
+      (inst sub esp-tn 4)
       (inst fnstcw (make-ea :word :base esp-tn))
-      (load-symbol-value precision *fpu-precision*)
-      (inst sar precision 2)		; Remove fixnum tag bits
-      (inst wait)
-      ;; Clear the precision bits so we can fill them in with our
-      ;; desired precision value.
-      (inst mov cw (make-ea :word :base esp-tn))
-      (inst and cw #xfcff)
-      (inst or cw
-	    (make-random-tn :kind :normal
-			    :sc (sc-or-lose 'word-reg *backend*)
-			    :offset (tn-offset precision)))
-      (inst mov (make-ea :word :base esp-tn) cw)
+      (inst and (make-ea :word :base esp-tn) #xcff)
+      (inst or (make-ea :word :base esp-tn) #x200)
       (inst fldcw (make-ea :word :base esp-tn))
       (inst wait)
       (inst add esp-tn 4))))
diff --git a/compiler/x86/float.lisp b/compiler/x86/float.lisp
index 511453b64..f60efca2e 100644
--- a/compiler/x86/float.lisp
+++ b/compiler/x86/float.lisp
@@ -7,7 +7,7 @@
 ;;; Scott Fahlman or slisp-group@cs.cmu.edu.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/float.lisp,v 1.50 2007/10/04 19:58:20 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/float.lisp,v 1.51 2007/11/14 10:04:35 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -2267,37 +2267,27 @@
 
 ;;;; Float mode hackery:
 
-(deftype float-modes () '(unsigned-byte 32)) ; really only 16
+(deftype float-modes () '(unsigned-byte 24))
 (defknown floating-point-modes () float-modes (flushable))
 (defknown ((setf floating-point-modes)) (float-modes)
   float-modes)
 
-(defconstant npx-env-size (* 7 vm:word-bytes))
-(defconstant npx-cw-offset 0)
-(defconstant npx-sw-offset 4)
-
-(defvar *fpu-precision*
-  (dpb float-precision-53-bit float-precision-control 0))
-
 (define-vop (floating-point-modes)
   (:results (res :scs (unsigned-reg)))
   (:result-types unsigned-num)
   (:translate floating-point-modes)
   (:policy :fast-safe)
-  (:temporary (:sc unsigned-reg :offset eax-offset :target res
-		   :to :result) eax)
+  (:temporary (:sc unsigned-stack) cw-stack)
+  (:temporary (:sc unsigned-reg :offset eax-offset) sw-reg)
   (:generator 8
-   (inst sub esp-tn npx-env-size)	; make space on stack
-   (inst wait)                          ; Catch any pending FPE exceptions
-   (inst fstenv (make-ea :dword :base esp-tn)) ; masks all exceptions
-   (inst fldenv (make-ea :dword :base esp-tn)) ; restore previous state
-   ;; Current status to high word
-   (inst mov eax (make-ea :dword :base esp-tn :disp (- npx-sw-offset 2)))
-   ;; Exception mask to low word
-   (inst mov ax-tn (make-ea :word :base esp-tn :disp npx-cw-offset))
-   (inst add esp-tn npx-env-size)	; Pop stack
-   (inst xor eax #x3f)	; Flip exception mask to trap enable bits
-   (move res eax)))
+   (inst fnstsw)
+   (inst fnstcw cw-stack)
+   (inst and sw-reg #xff)  ; mask exception flags
+   (inst shl sw-reg 16)
+   (inst byte #x66)  ; operand size prefix
+   (inst or sw-reg cw-stack)
+   (inst xor sw-reg #x3f)  ; invert exception mask
+   (move res sw-reg)))
 
 (define-vop (set-floating-point-modes)
   (:args (new :scs (unsigned-reg) :to :result :target res))
@@ -2306,25 +2296,24 @@
   (:result-types unsigned-num)
   (:translate (setf floating-point-modes))
   (:policy :fast-safe)
-  (:temporary (:sc unsigned-reg :offset eax-offset
-		   :from :eval :to :result) eax)
-  (:generator 3
-   (inst sub esp-tn npx-env-size)	; make space on stack
-   (inst wait)                          ; Catch any pending FPE exceptions
+  (:temporary (:sc unsigned-stack) cw-stack)
+  (:temporary (:sc byte-reg :offset al-offset) sw-reg)
+  (:temporary (:sc unsigned-reg :offset ecx-offset) old)
+  (:generator 6
+   (inst mov cw-stack new)
+   (inst xor cw-stack #x3f)  ; invert exception mask
+   (inst fnstsw)
+   (inst fldcw cw-stack)  ; always update the control word
+   (inst mov old new)
+   (inst shr old 16)
+   (inst cmp cl-tn sw-reg)  ; compare exception flags
+   (inst jmp :z DONE)  ; skip updating the status word
+   (inst sub esp-tn 28)
    (inst fstenv (make-ea :dword :base esp-tn))
-   (inst mov eax new)
-   ;; Save precision bits so we can restore them properly
-   (inst and eax #x300)
-   (inst shl eax 2)			; Convert to fixnum
-   (store-symbol-value eax *fpu-precision*)
-   ;; Now set the desired mode
-   (inst mov eax new)
-   (inst xor eax #x3f)	    ; turn trap enable bits into exception mask
-   (inst mov (make-ea :word :base esp-tn :disp npx-cw-offset) ax-tn)
-   (inst shr eax 16)			; position status word
-   (inst mov (make-ea :word :base esp-tn :disp npx-sw-offset) ax-tn)
+   (inst mov (make-ea :byte :base esp-tn :disp 4) cl-tn)
    (inst fldenv (make-ea :dword :base esp-tn))
-   (inst add esp-tn npx-env-size)	; Pop stack
+   (inst add esp-tn 28)
+   DONE
    (move res new)))
 
 
diff --git a/compiler/x86/parms.lisp b/compiler/x86/parms.lisp
index 27448d413..a6f63a5ac 100644
--- a/compiler/x86/parms.lisp
+++ b/compiler/x86/parms.lisp
@@ -7,7 +7,7 @@
 ;;; Scott Fahlman or slisp-group@cs.cmu.edu.
 ;;;
 (ext:file-comment
-  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/parms.lisp,v 1.33 2007/10/04 19:58:20 rtoy Exp $")
+  "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/x86/parms.lisp,v 1.34 2007/11/14 10:04:35 cshapiro Exp $")
 ;;;
 ;;; **********************************************************************
 ;;;
@@ -162,15 +162,10 @@
 (defconstant float-round-to-positive 2)
 (defconstant float-round-to-zero     3)
 
-(defconstant float-precision-24-bit  0)
-(defconstant float-precision-53-bit  2)
-(defconstant float-precision-64-bit  3)
-
 (defconstant float-rounding-mode   (byte 2 10))
 (defconstant float-sticky-bits     (byte 6 16))
 (defconstant float-traps-byte      (byte 6  0))
 (defconstant float-exceptions-byte (byte 6 16))
-(defconstant float-precision-control (byte 2 8))
 (defconstant float-fast-bit 0) ; No fast mode on x86
 ); eval-when
 
@@ -333,7 +328,6 @@
       :key-and-value
       :key-or-value
 
-      *fpu-precision*
       ;; Spare symbols.  Rename these when you need to add some static
       ;; symbols and don't want to do a cross-compile.
       spare-8
-- 
GitLab