[Sbcl-commits] CVS: sbcl/src/compiler srctran.lisp,1.146,1.147

[Nathan F. <nf...@us...>]

Update of /cvsroot/sbcl/sbcl/src/compiler
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv4494/src/compiler

Modified Files:
	srctran.lisp 
Log Message:
1.0.4.32: De-pessimize >= and <= transforms

	Wait until we've computed type information for all the code we've
	  introduced in this optimization pass before making the transform.
	  We once again produce decent code for:

	(defun foo (x y)
	  (declare (simple-vector x y))
	  (do ((i 0 (1+ i))
	       (end (length x)))
	      ((>= i end) y)
	    (setf (aref y i) (aref x i))))


Index: srctran.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/srctran.lisp,v
retrieving revision 1.146
retrieving revision 1.147
diff -u -d -r1.146 -r1.147
--- srctran.lisp	5 Mar 2007 16:58:27 -0000	1.146
+++ srctran.lisp	6 Apr 2007 12:55:58 -0000	1.147
@@ -3414,17 +3414,20 @@
   (neq *empty-type* (type-intersection (specifier-type 'float)
                                        (lvar-type lvar))))
 
-(flet ((maybe-invert (op inverted x y)
+(flet ((maybe-invert (node op inverted x y)
          ;; Don't invert if either argument can be a float (NaNs)
-         (if (or (maybe-float-lvar-p x) (maybe-float-lvar-p y))
-             `(or (,op x y) (= x y))
-             `(if (,inverted x y) nil t))))
-  (deftransform >= ((x y) (number number) *)
+         (cond
+           ((or (maybe-float-lvar-p x) (maybe-float-lvar-p y))
+            (delay-ir1-transform node :constraint)
+            `(or (,op x y) (= x y)))
+           (t
+            `(if (,inverted x y) nil t)))))
+  (deftransform >= ((x y) (number number) * :node node)
     "invert or open code"
-    (maybe-invert '> '< x y))
-  (deftransform <= ((x y) (number number) *)
+    (maybe-invert node '> '< x y))
+  (deftransform <= ((x y) (number number) * :node node)
     "invert or open code"
-    (maybe-invert '< '> x y)))
+    (maybe-invert node '< '> x y)))
 
 ;;; See whether we can statically determine (< X Y) using type
 ;;; information. If X's high bound is < Y's low, then X < Y.