X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fsrctran.lisp;h=1fcfe78b96fab202cbc405c2a4c294d31b81b170;hb=f8893c7c658bf9d9e0757c63e47af2fdea810f04;hp=a5ea013510158b1d6c76a99c6eca3e069672dc80;hpb=3d8b0be4f66dcaf0ed8e0ef703f5ce04da5e44d1;p=sbcl.git

diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index a5ea013..1fcfe78 100644
--- a/src/compiler/srctran.lisp
+++ b/src/compiler/srctran.lisp
@@ -750,7 +750,7 @@
 ;;; a utility for defining derive-type methods of integer operations. If
 ;;; the types of both X and Y are integer types, then we compute a new
 ;;; integer type with bounds determined Fun when applied to X and Y.
-;;; Otherwise, we use Numeric-Contagion.
+;;; Otherwise, we use NUMERIC-CONTAGION.
 (defun derive-integer-type-aux (x y fun)
   (declare (type function fun))
   (if (and (numeric-type-p x) (numeric-type-p y)
@@ -773,13 +773,12 @@
 
 ;;; simple utility to flatten a list
 (defun flatten-list (x)
-  (labels ((flatten-helper (x r);; 'r' is the stuff to the 'right'.
-	     (cond ((null x) r)
-		   ((atom x)
-		    (cons x r))
-		   (t (flatten-helper (car x)
-				      (flatten-helper (cdr x) r))))))
-    (flatten-helper x nil)))
+  (labels ((flatten-and-append (tree list)
+	     (cond ((null tree) list)
+		   ((atom tree) (cons tree list))
+		   (t (flatten-and-append
+                       (car tree) (flatten-and-append (cdr tree) list))))))
+    (flatten-and-append x nil)))
 
 ;;; Take some type of lvar and massage it so that we get a list of the
 ;;; constituent types. If ARG is *EMPTY-TYPE*, return NIL to indicate
@@ -1023,10 +1022,9 @@
 		  (if member-fun
 		      (with-float-traps-masked
 			  (:underflow :overflow :divide-by-zero)
-			(make-member-type
-			 :members (list
-				   (funcall member-fun
-					    (first (member-type-members x))))))
+			(specifier-type
+			 `(eql ,(funcall member-fun
+					 (first (member-type-members x))))))
 		      ;; Otherwise convert to a numeric type.
 		      (let ((result-type-list
 			     (funcall derive-fun (convert-member-type x))))
@@ -1065,17 +1063,18 @@
 	   (cond ((and (member-type-p x) (member-type-p y))
 		  (let* ((x (first (member-type-members x)))
 			 (y (first (member-type-members y)))
-			 (result (with-float-traps-masked
-				     (:underflow :overflow :divide-by-zero
-				      :invalid)
-				   (funcall fun x y))))
-		    (cond ((null result))
+			 (result (ignore-errors
+                                   (with-float-traps-masked
+                                       (:underflow :overflow :divide-by-zero
+                                                   :invalid)
+                                     (funcall fun x y)))))
+		    (cond ((null result) *empty-type*)
 			  ((and (floatp result) (float-nan-p result))
 			   (make-numeric-type :class 'float
 					      :format (type-of result)
 					      :complexp :real))
 			  (t
-			   (make-member-type :members (list result))))))
+			   (specifier-type `(eql ,result))))))
 		 ((and (member-type-p x) (numeric-type-p y))
 		  (let* ((x (convert-member-type x))
 			 (y (if convert-type (convert-numeric-type y) y))
@@ -2301,6 +2300,45 @@
 
 (defoptimizer (values derive-type) ((&rest values))
   (make-values-type :required (mapcar #'lvar-type values)))
+
+(defun signum-derive-type-aux (type)
+  (if (eq (numeric-type-complexp type) :complex)
+      (let* ((format (case (numeric-type-class type)
+			  ((integer rational) 'single-float)
+			  (t (numeric-type-format type))))
+		(bound-format (or format 'float)))
+	   (make-numeric-type :class 'float
+			      :format format
+			      :complexp :complex
+			      :low (coerce -1 bound-format)
+			      :high (coerce 1 bound-format)))
+      (let* ((interval (numeric-type->interval type))
+	     (range-info (interval-range-info interval))
+	     (contains-0-p (interval-contains-p 0 interval))
+	     (class (numeric-type-class type))
+	     (format (numeric-type-format type))
+	     (one (coerce 1 (or format class 'real)))
+	     (zero (coerce 0 (or format class 'real)))
+	     (minus-one (coerce -1 (or format class 'real)))
+	     (plus (make-numeric-type :class class :format format
+				      :low one :high one))
+	     (minus (make-numeric-type :class class :format format
+				       :low minus-one :high minus-one))
+	     ;; KLUDGE: here we have a fairly horrible hack to deal
+	     ;; with the schizophrenia in the type derivation engine.
+	     ;; The problem is that the type derivers reinterpret
+	     ;; numeric types as being exact; so (DOUBLE-FLOAT 0d0
+	     ;; 0d0) within the derivation mechanism doesn't include
+	     ;; -0d0.  Ugh.  So force it in here, instead.
+	     (zero (make-numeric-type :class class :format format
+				      :low (- zero) :high zero)))
+	(case range-info
+	  (+ (if contains-0-p (type-union plus zero) plus))
+	  (- (if contains-0-p (type-union minus zero) minus))
+	  (t (type-union minus zero plus))))))
+
+(defoptimizer (signum derive-type) ((num))
+  (one-arg-derive-type num #'signum-derive-type-aux nil))
 
 ;;;; byte operations
 ;;;;
@@ -2480,8 +2518,12 @@
 ;;; "goodness" means that the result will not increase (in the
 ;;; (unsigned-byte +infinity) sense). An ordinary modular function is
 ;;; replaced with the version, cutting its result to WIDTH or more
-;;; bits. If we have changed anything, we need to flush old derived
-;;; types, because they have nothing in common with the new code.
+;;; bits. For most functions (e.g. for +) we cut all arguments; for
+;;; others (e.g. for ASH) we have "optimizers", cutting only necessary
+;;; arguments (maybe to a different width) and returning the name of a
+;;; modular version, if it exists, or NIL. If we have changed
+;;; anything, we need to flush old derived types, because they have
+;;; nothing in common with the new code.
 (defun cut-to-width (lvar width)
   (declare (type lvar lvar) (type (integer 0) width))
   (labels ((reoptimize-node (node name)
@@ -2493,30 +2535,37 @@
              (setf (block-reoptimize (node-block node)) t)
              (setf (component-reoptimize (node-component node)) t))
            (cut-node (node &aux did-something)
-             (when (and (combination-p node)
+             (when (and (not (block-delete-p (node-block node)))
+                        (combination-p node)
                         (fun-info-p (basic-combination-kind node)))
                (let* ((fun-ref (lvar-use (combination-fun node)))
                       (fun-name (leaf-source-name (ref-leaf fun-ref)))
-                      (modular-fun (find-modular-version fun-name width))
-                      (name (and (modular-fun-info-p modular-fun)
-                                 (modular-fun-info-name modular-fun))))
+                      (modular-fun (find-modular-version fun-name width)))
                  (when (and modular-fun
-                            (not (and (eq name 'logand)
+                            (not (and (eq fun-name 'logand)
                                       (csubtypep
                                        (single-value-type (node-derived-type node))
                                        (specifier-type `(unsigned-byte ,width))))))
-                   (unless (eq modular-fun :good)
-                     (setq did-something t)
-                     (change-ref-leaf
+                   (binding* ((name (etypecase modular-fun
+                                      ((eql :good) fun-name)
+                                      (modular-fun-info
+                                       (modular-fun-info-name modular-fun))
+                                      (function
+                                       (funcall modular-fun node width)))
+                                :exit-if-null))
+                     (unless (eql modular-fun :good)
+                       (setq did-something t)
+                       (change-ref-leaf
                         fun-ref
                         (find-free-fun name "in a strange place"))
                        (setf (combination-kind node) :full))
-                   (dolist (arg (basic-combination-args node))
-                     (when (cut-lvar arg)
-                       (setq did-something t)))
-                   (when did-something
-                     (reoptimize-node node fun-name))
-                   did-something))))
+                     (unless (functionp modular-fun)
+                       (dolist (arg (basic-combination-args node))
+                         (when (cut-lvar arg)
+                           (setq did-something t))))
+                     (when did-something
+                       (reoptimize-node node name))
+                     did-something)))))
            (cut-lvar (lvar &aux did-something)
              (do-uses (node lvar)
                (when (cut-node node)
@@ -2563,22 +2612,22 @@
     (give-up-ir1-transform "BOOLE code is not a constant."))
   (let ((control (lvar-value op)))
     (case control
-      (#.boole-clr 0)
-      (#.boole-set -1)
-      (#.boole-1 'x)
-      (#.boole-2 'y)
-      (#.boole-c1 '(lognot x))
-      (#.boole-c2 '(lognot y))
-      (#.boole-and '(logand x y))
-      (#.boole-ior '(logior x y))
-      (#.boole-xor '(logxor x y))
-      (#.boole-eqv '(logeqv x y))
-      (#.boole-nand '(lognand x y))
-      (#.boole-nor '(lognor x y))
-      (#.boole-andc1 '(logandc1 x y))
-      (#.boole-andc2 '(logandc2 x y))
-      (#.boole-orc1 '(logorc1 x y))
-      (#.boole-orc2 '(logorc2 x y))
+      (#.sb!xc:boole-clr 0)
+      (#.sb!xc:boole-set -1)
+      (#.sb!xc:boole-1 'x)
+      (#.sb!xc:boole-2 'y)
+      (#.sb!xc:boole-c1 '(lognot x))
+      (#.sb!xc:boole-c2 '(lognot y))
+      (#.sb!xc:boole-and '(logand x y))
+      (#.sb!xc:boole-ior '(logior x y))
+      (#.sb!xc:boole-xor '(logxor x y))
+      (#.sb!xc:boole-eqv '(logeqv x y))
+      (#.sb!xc:boole-nand '(lognand x y))
+      (#.sb!xc:boole-nor '(lognor x y))
+      (#.sb!xc:boole-andc1 '(logandc1 x y))
+      (#.sb!xc:boole-andc2 '(logandc2 x y))
+      (#.sb!xc:boole-orc1 '(logorc1 x y))
+      (#.sb!xc:boole-orc2 '(logorc2 x y))
       (t
        (abort-ir1-transform "~S is an illegal control arg to BOOLE."
 			    control)))))
@@ -2659,7 +2708,7 @@
 			`(- (ash (- x) ,shift)))
 		   (- (logand (- x) ,mask)))
 	   (values ,(if (minusp y)
-			`(- (ash (- x) ,shift))
+			`(ash (- ,mask x) ,shift)
 			`(ash x ,shift))
 		   (logand x ,mask))))))