X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler.pure.lisp;h=1305c5c323d54355e6b0bbd44d98e8e86f91dc7a;hb=1e9a538c32223df9132c1e7fb2b67a2129c40a8d;hp=9525ccaa9669c9fcf2c0b7acc117a7e5ef20be10;hpb=11f02398a1a9ccbde847c82fd233e8378e45c29c;p=sbcl.git

diff --git a/tests/compiler.pure.lisp b/tests/compiler.pure.lisp
index 9525cca..1305c5c 100644
--- a/tests/compiler.pure.lisp
+++ b/tests/compiler.pure.lisp
@@ -675,3 +675,118 @@
                    (wum #'bbfn "hc3" (list)))
                  r3533)))
 (compile nil '(lambda () (flet ((%f () (unwind-protect nil))) nil)))
+
+;;; the strength reduction of constant multiplication used (before
+;;; sbcl-0.8.4.x) to lie to the compiler.  This meant that, under
+;;; certain circumstances, the compiler would derive that a perfectly
+;;; reasonable multiplication never returned, causing chaos.  Fixed by
+;;; explicitly doing modular arithmetic, and relying on the backends
+;;; being smart.
+(assert (= (funcall 
+	    (compile nil 
+		     '(lambda (x)
+			(declare (type (integer 178956970 178956970) x)
+				 (optimize speed)) 
+			(* x 24)))
+	    178956970)
+	   4294967280))
+
+;;; bug in modular arithmetic and type specifiers
+(assert (= (funcall (compile nil (lambda (x) (logand x x 0)))
+		    -1)
+	   0))
+
+;;; MISC.99 from Paul Dietz' random tester: FAST-ASH-MOD32-C VOP
+;;; produced wrong result for shift >=32 on X86
+(assert (= 0 (funcall
+              (compile nil
+                       '(lambda (a)
+                         (declare (type (integer 4303063 101130078) a))
+                         (mask-field (byte 18 2) (ash a 77))))
+              57132532)))
+
+;;; MISC.101 and MISC.103: FLUSH-DEST did not mark the USE's block for
+;;; type check regeneration
+(assert (eql (funcall
+              (compile nil '(lambda (a c)
+                             (declare (type (integer 185501219873 303014665162) a))
+                             (declare (type (integer -160758 255724) c))
+                             (declare (optimize (speed 3)))
+                             (let ((v8
+                                    (- -554046873252388011622614991634432
+                                       (ignore-errors c)
+                                       (unwind-protect 2791485))))
+                               (max (ignore-errors a)
+                                    (let ((v6 (- v8 (restart-case 980))))
+                                      (min v8 v6))))))
+              259448422916 173715)
+             259448422916))
+(assert (eql (funcall
+              (compile nil '(lambda (a b)
+                             (min -80
+                              (abs
+                               (ignore-errors
+                                 (+
+                                  (logeqv b
+                                          (block b6
+                                            (return-from b6
+                                              (load-time-value -6876935))))
+                                  (if (logbitp 1 a) b (setq a -1522022182249))))))))
+              -1802767029877 -12374959963)
+             -80))
+
+;;; various MISC.*, related to NODEs/LVARs with derived type NIL
+(assert (eql (funcall (compile nil '(lambda (c)
+                                     (declare (type (integer -3924 1001809828) c))
+                                     (declare (optimize (speed 3)))
+                                     (min 47 (if (ldb-test (byte 2 14) c)
+                                                 -570344431
+                                                 (ignore-errors -732893970)))))
+                      705347625)
+             -570344431))
+(assert (eql (funcall
+              (compile nil '(lambda (b)
+                             (declare (type (integer -1598566306 2941) b))
+                             (declare (optimize (speed 3)))
+                             (max -148949 (ignore-errors b))))
+              0)
+             0))
+(assert (eql (funcall
+              (compile nil '(lambda (b c)
+                             (declare (type (integer -4 -3) c))
+                             (block b7
+                               (flet ((%f1 (f1-1 f1-2 f1-3)
+                                        (if (logbitp 0 (return-from b7
+                                                         (- -815145138 f1-2)))
+                                            (return-from b7 -2611670)
+                                            99345)))
+                                 (let ((v2 (%f1 -2464 (%f1 -1146 c c) -2)))
+                                   b)))))
+              2950453607 -4)
+             -815145134))
+(assert (eql (funcall
+              (compile nil
+                       '(lambda (b c)
+                         (declare (type (integer -29742055786 23602182204) b))
+                         (declare (type (integer -7409 -2075) c))
+                         (declare (optimize (speed 3)))
+                         (floor
+                          (labels ((%f2 ()
+                                     (block b6
+                                       (ignore-errors (return-from b6
+                                                        (if (= c 8) b 82674))))))
+                            (%f2)))))
+              22992834060 -5833)
+             82674))
+(assert (equal (multiple-value-list
+                (funcall
+                 (compile nil '(lambda (a)
+                                (declare (type (integer -944 -472) a))
+                                (declare (optimize (speed 3)))
+                                (round
+                                 (block b3
+                                   (return-from b3
+                                     (if (= 55957 a) -117 (ignore-errors
+                                                            (return-from b3 a))))))))
+                 -589))
+               '(-589 0)))