X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler.impure-cload.lisp;h=41d052513b935905990dc854308db9c105ac50c7;hb=7c7e6276719b8d40fddec2070cad81064a25c8ed;hp=531f1b652fa178bf4a6dea9915ba55cc8de362c8;hpb=61c18727668ff0c3263a3d363e609d4522d545cc;p=sbcl.git

diff --git a/tests/compiler.impure-cload.lisp b/tests/compiler.impure-cload.lisp
index 531f1b6..41d0525 100644
--- a/tests/compiler.impure-cload.lisp
+++ b/tests/compiler.impure-cload.lisp
@@ -325,5 +325,122 @@
   (dotimes (k n)
     (princ k)))
 
+;;; bug reported by Brian Downing: incorrect detection of MV-LET
+(DEFUN #:failure-testcase (SESSION)
+  (LABELS ((CONTINUATION-1 ()
+             (PROGN
+               (IF (foobar-1 SESSION)
+                   (CONTINUATION-2))
+               (LET ((CONTINUATION-3
+                      #'(LAMBDA ()
+                          (MULTIPLE-VALUE-CALL #'CONTINUATION-2
+                            (CONTINUATION-1)))))
+                 (foobar-2 CONTINUATION-3))))
+           (CONTINUATION-2 (&REST OTHER-1)
+             (DECLARE (IGNORE OTHER-1))))
+    (continuation-1)))
+
+;;; reported by antifuchs/bdowning/etc on #lisp: ITERATE failure on
+;;; (iter (for i in '(1 2 3)) (+ i 50))
+(defun values-producer () (values 1 2 3 4 5 6 7))
+
+(defun values-consumer (fn)
+  (let (a b c d e f g h)
+    (multiple-value-bind (aa bb cc dd ee ff gg hh) (funcall fn)
+      (setq a aa)
+      (setq b bb)
+      (setq c cc)
+      (setq d dd)
+      (setq e ee)
+      (setq f ff)
+      (setq g gg)
+      (setq h hh)
+      (values a b c d e f g h))))
+
+(let ((list (multiple-value-list (values-consumer #'values-producer))))
+  (assert (= (length list) 8))
+  (assert (null (nth 7 list))))
+
+;;; failed on Alpha prior to sbcl-0.8.10.30
+(defun lotso-values ()
+  (values 0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9
+	  0 1 2 3 4 5 6 7 8 9))
+
+;;; bug 313: source transforms were "lisp-1"
+(defun srctran-lisp1-1 (cadr) (if (functionp cadr) (funcall cadr 1) nil))
+(assert (eql (funcall (eval #'srctran-lisp1-1) #'identity) 1))
+(without-package-locks 
+   ;; this be a nasal demon, but test anyways
+   (defvar caar))
+(defun srctran-lisp1-2 (caar) (funcall (sb-ext:truly-the function caar) 1))
+(assert (eql (funcall (eval #'srctran-lisp1-2) #'identity) 1))
+
+;;; partial bug 262: reference of deleted CTRAN (in RETURN-FROM)
+;;; during inline expansion. Bug report by Peter Denno, simplified
+;;; test case by David Wragg.
+(defun bug262-return-from (x &aux (y nil))
+  (labels ((foo-a (z) (return-from bug262-return-from z))
+           (foo-b (z) (foo-a z)))
+    (declare (inline foo-a))
+    (foo-a x)))
+
+;;; broken inference of an upper bound of an iteration variable,
+;;; reported by Rajat Datta.
+(defun isieve (num)
+  (let ((vec (make-array num :initial-element 0))
+        (acc 0))
+    (do ((i 2 (+ i 1)))
+        ((>= i num) 'done)
+      (when (= (svref vec i) 0)
+        (do ((j (* i i) (+ j i)))
+            ((>= j num) 'done)
+          (setf (svref vec j) 1))
+        (incf acc)))
+    acc))
+
+(assert (= (isieve 46349) 4792))
+
+;;; COERCE should not be constant-folded (reported by Nikodemus
+;;; Siivola)
+(let ((f (gensym)))
+  (setf (fdefinition f) (lambda (x) x))
+  (let ((g (compile nil `(lambda () (coerce ',f 'function)))))
+    (setf (fdefinition f) (lambda (x) (1+ x)))
+    (assert (eq (funcall g) (fdefinition f)))))
+
+(let ((x (coerce '(1 11) 'vector)))
+  (incf (aref x 0))
+  (assert (equalp x #(2 11))))
+
+;;; and BIT-* too (reported by Paul F. Dietz)
+(loop with v1 = #*0011
+      and  v2 = #*0101
+      for f in '(bit-and bit-andc1 bit-andc2 bit-eqv
+                 bit-ior bit-nand bit-nor bit-not
+                 bit-orc1 bit-orc2 bit-xor
+                 )
+      for form = `(lambda ()
+                    (let ((v (,f ,v1 ,v2)))
+                      (setf (aref v 0) (- 1 (aref v 0)))
+                      (aref v 0)))
+      for compiled-res = (funcall (compile nil form))
+      for real-res = (- 1 (aref (funcall f v1 v2) 0))
+      do (assert (equal compiled-res real-res)))
+(let* ((v #*0011)
+       (form `(lambda ()
+                (let ((v (bit-not ,v)))
+                  (setf (aref v 0) (- 1 (aref v 0)))
+                  (aref v 0))))
+       (compiled-res (funcall (compile nil form)))
+       (real-res (- 1 (aref (funcall (eval #'bit-not) v) 0))))
+  (assert (equal compiled-res real-res)))
 
 (sb-ext:quit :unix-status 104)