X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir1opt.lisp;h=34117f5c42ed44b92fcd1fe53eaca96d93bf787a;hb=e67cc0f952040723f7d0f37ddb88fe895f4b1464;hp=4bf7285bebb92ebbe3286d57a9b1caa521d5c664;hpb=5ecef987f3847ed5de8c03f66ef9d8ab468af993;p=sbcl.git

diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp
index 4bf7285..34117f5 100644
--- a/src/compiler/ir1opt.lisp
+++ b/src/compiler/ir1opt.lisp
@@ -1126,7 +1126,15 @@
 		      ;; COMPILER-WARNING (and thus return FAILURE-P=T
 		      ;; from COMPILE-FILE) for legal code, so we we
 		      ;; use a wimpier COMPILE-STYLE-WARNING instead.
-		      #'compiler-style-warn
+		      #-sb-xc-host #'compiler-style-warn
+		      ;; On the other hand, for code we control, we
+		      ;; should be able to work around any bug
+		      ;; 173-related problems, and in particular we
+		      ;; want to be alerted to calls to our own
+		      ;; functions which aren't being folded away; a
+		      ;; COMPILER-WARNING is butch enough to stop the
+		      ;; SBCL build itself in its tracks.
+		      #+sb-xc-host #'compiler-warn
 		      "constant folding")
       (cond ((not win)
              (setf (combination-kind call) :error))
@@ -1202,33 +1210,42 @@
     (when (and (numeric-type-p initial-type)
                (numeric-type-p step-type)
                (numeric-type-equal initial-type step-type))
-      (multiple-value-bind (low high)
-          (cond ((csubtypep step-type (specifier-type '(real 0 *)))
-                 (values (numeric-type-low initial-type)
-                         (when (and (numeric-type-p set-type)
-                                    (numeric-type-equal set-type initial-type))
-                           (flet ((max* (i j)
-                                    (cond ((eq i nil) nil)
-                                          ((eq j nil) nil)
-                                          (t (max i j)))))
+      (labels ((leftmost (x y cmp cmp=)
+                 (cond ((eq x nil) nil)
+                       ((eq y nil) nil)
+                       ((listp x)
+                        (let ((x1 (first x)))
+                          (cond ((listp y)
+                                 (let ((y1 (first y)))
+                                   (if (funcall cmp x1 y1) x y)))
+                                (t
+                                 (if (funcall cmp x1 y) x y)))))
+                       ((listp y)
+                        (let ((y1 (first y)))
+                          (if (funcall cmp= x y1) x y)))
+                       (t (if (funcall cmp x y) x y))))
+               (max* (x y) (leftmost x y #'> #'>=))
+               (min* (x y) (leftmost x y #'< #'<=)))
+        (declare (inline compare))
+        (multiple-value-bind (low high)
+            (cond ((csubtypep step-type (specifier-type '(real 0 *)))
+                   (values (numeric-type-low initial-type)
+                           (when (and (numeric-type-p set-type)
+                                      (numeric-type-equal set-type initial-type))
                              (max* (numeric-type-high initial-type)
-                                   (numeric-type-high set-type))))))
-                ((csubtypep step-type (specifier-type '(real * 0)))
-                 (values (when (and (numeric-type-p set-type)
-                                    (numeric-type-equal set-type initial-type))
-                           (flet ((min* (i j)
-                                    (cond ((eq i nil) nil)
-                                          ((eq j nil) nil)
-                                          (t (min i j)))))
-                           (min* (numeric-type-low initial-type)
-                                 (numeric-type-low set-type))))
-                         (numeric-type-high initial-type)))
-                (t
-                 (values nil nil)))
-        (modified-numeric-type initial-type
-                               :low low
-                               :high high
-                               :enumerable nil)))))
+                                   (numeric-type-high set-type)))))
+                  ((csubtypep step-type (specifier-type '(real * 0)))
+                   (values (when (and (numeric-type-p set-type)
+                                      (numeric-type-equal set-type initial-type))
+                             (min* (numeric-type-low initial-type)
+                                   (numeric-type-low set-type)))
+                           (numeric-type-high initial-type)))
+                  (t
+                   (values nil nil)))
+          (modified-numeric-type initial-type
+                                 :low low
+                                 :high high
+                                 :enumerable nil))))))
 (deftransform + ((x y) * * :result result)
   "check for iteration variable reoptimization"
   (let ((dest (principal-lvar-end result))