X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler.pure.lisp;h=56811da2e4a79fba6ce7ac87d0d90169cc9b2c94;hb=7b384da95e6a30e1434523213aeeed3a90448c78;hp=96e1c8f86110f41a09472468f363d067eea69c21;hpb=f73c1f391342c797b8daebe4e8c27e5923341b6d;p=sbcl.git diff --git a/tests/compiler.pure.lisp b/tests/compiler.pure.lisp index 96e1c8f..56811da 100644 --- a/tests/compiler.pure.lisp +++ b/tests/compiler.pure.lisp @@ -1019,3 +1019,245 @@ (dotimes (iv4 5 a) (%f9 0 0 b))) 0))) 1 2))) + +;;; MISC.259-264 (aka "CSR screwed up implementing *-MOD32") +(assert + (= (funcall + (compile + nil + '(lambda (a) + (declare (type (integer 177547470 226026978) a)) + (declare (optimize (speed 3) (space 0) (safety 0) (debug 0) + (compilation-speed 1))) + (logand a (* a 438810)))) + 215067723) + 13739018)) + + +;;;; Bugs in stack analysis +;;; bug 299 (reported by PFD) +(assert + (equal (funcall + (compile + nil + '(lambda () + (declare (optimize (debug 1))) + (multiple-value-call #'list + (if (eval t) (eval '(values :a :b :c)) nil) + (catch 'foo (throw 'foo (values :x :y))))))) + '(:a :b :c :x :y))) +;;; bug 298 (= MISC.183) +(assert (zerop (funcall + (compile + nil + '(lambda (a b c) + (declare (type (integer -368154 377964) a)) + (declare (type (integer 5044 14959) b)) + (declare (type (integer -184859815 -8066427) c)) + (declare (ignorable a b c)) + (declare (optimize (speed 3))) + (declare (optimize (safety 1))) + (declare (optimize (debug 1))) + (block b7 + (flet ((%f3 (f3-1 f3-2 f3-3) 0)) + (apply #'%f3 0 (catch 'foo (return-from b7 (%f3 0 b c))) c nil))))) + 0 6000 -9000000))) +(assert (equal (eval '(let () (apply #'list 1 (list (catch 'a (throw 'a (block b 2))))))) + '(1 2))) +(let ((f (compile + nil + '(lambda (x) + (block foo + (multiple-value-call #'list + :a + (block bar + (return-from foo + (multiple-value-call #'list + :b + (block quux + (return-from bar + (catch 'baz + (if x + (return-from quux 1) + (throw 'baz 2)))))))))))))) + (assert (equal (funcall f t) '(:b 1))) + (assert (equal (funcall f nil) '(:a 2)))) + +;;; MISC.185 +(assert (equal + (funcall + (compile + nil + '(lambda (a b c) + (declare (type (integer 5 155656586618) a)) + (declare (type (integer -15492 196529) b)) + (declare (type (integer 7 10) c)) + (declare (optimize (speed 3))) + (declare (optimize (safety 1))) + (declare (optimize (debug 1))) + (flet ((%f3 + (f3-1 f3-2 f3-3 + &optional (f3-4 a) (f3-5 0) + (f3-6 + (labels ((%f10 (f10-1 f10-2 f10-3) + 0)) + (apply #'%f10 + 0 + a + (- (if (equal a b) b (%f10 c a 0)) + (catch 'ct2 (throw 'ct2 c))) + nil)))) + 0)) + (%f3 (%f3 (%f3 b 0 0 0) a 0) a b b b c)))) 5 0 7) + 0)) +;;; MISC.186 +(assert (eq + (eval + '(let* ((form '(labels ((%f3 (f3-1 f3-2) f3-1)) + (apply #'%f3 b (catch 'ct8 (throw 'ct8 (logeqv (%f3 c 0)))) nil))) + (vars '(b c)) + (fn1 `(lambda ,vars + (declare (type (integer -2 19) b) + (type (integer -1520 218978) c) + (optimize (speed 3) (safety 1) (debug 1))) + ,form)) + (fn2 `(lambda ,vars + (declare (notinline logeqv apply) + (optimize (safety 3) (speed 0) (debug 0))) + ,form)) + (cf1 (compile nil fn1)) + (cf2 (compile nil fn2)) + (result1 (multiple-value-list (funcall cf1 2 18886))) + (result2 (multiple-value-list (funcall cf2 2 18886)))) + (if (equal result1 result2) + :good + (values result1 result2)))) + :good)) + +;;; MISC.290 +(assert (zerop + (funcall + (compile + nil + '(lambda () + (declare + (optimize (speed 3) (space 3) (safety 1) + (debug 2) (compilation-speed 0))) + (apply (constantly 0) (catch 'ct2 0) 0 (catch 'ct2 0) nil)))))) + +;;; MISC.292 +(assert (zerop (funcall + (compile + nil + '(lambda (a b) + (declare (optimize (speed 2) (space 0) (safety 3) (debug 1) + (compilation-speed 2))) + (apply (constantly 0) + a + 0 + (catch 'ct6 + (apply (constantly 0) + 0 + 0 + (let* ((v1 + (let ((*s7* 0)) + b))) + 0) + 0 + nil)) + 0 + nil))) + 1 2))) + +;;; misc.295 +(assert (eql + (funcall + (compile + nil + '(lambda () + (declare (optimize (speed 1) (space 0) (safety 0) (debug 0))) + (multiple-value-prog1 + (the integer (catch 'ct8 (catch 'ct7 15867134))) + (catch 'ct1 (throw 'ct1 0)))))) + 15867134)) + + +;;; MISC.275 +(assert + (zerop + (funcall + (compile + nil + '(lambda (b) + (declare (notinline funcall min coerce)) + (declare + (optimize (speed 1) + (space 2) + (safety 2) + (debug 1) + (compilation-speed 1))) + (flet ((%f12 (f12-1) + (coerce + (min + (if f12-1 (multiple-value-prog1 + b (return-from %f12 0)) + 0)) + 'integer))) + (funcall #'%f12 0)))) + -33))) + +;;; Discussion of a CMUCL PCL bug on Sparc with Raymond Toy revealed a +;;; potential problem: optimizers and type derivers for MAX and MIN +;;; were not consistent in treating EQUALP, but not EQL, arguments. +(dolist (f '(min max)) + (loop for complex-arg-args in '((1d0 2d0) (0d0 1d0)) + for complex-arg = `(if x ,@complex-arg-args) + do + (loop for args in `((1 ,complex-arg) + (,complex-arg 1)) + for form = `(,f ,@args) + for f1 = (compile nil `(lambda (x) ,form)) + and f2 = (compile nil `(lambda (x) (declare (notinline min max)) + ,form)) + do + (dolist (x '(nil t)) + (assert (eql (funcall f1 x) (funcall f2 x))))))) + +;;; +(handler-case (compile nil '(lambda (x) + (declare (optimize (speed 3) (safety 0))) + (the double-float (sqrt (the double-float x))))) + (sb-ext:compiler-note () + (error "Compiler does not trust result type assertion."))) + +(let ((f (compile nil '(lambda (x) + (declare (optimize speed (safety 0))) + (block nil + (the double-float + (multiple-value-prog1 + (sqrt (the double-float x)) + (when (< x 0) + (return :minus))))))))) + (assert (eql (funcall f -1d0) :minus)) + (assert (eql (funcall f 4d0) 2d0))) + +;;; bug 304: SBCL produced something similar to (/ (ASH x 4) 8) +(handler-case + (compile nil '(lambda (a i) + (locally + (declare (optimize (speed 3) (safety 0) (space 0) (debug 0) + (inhibit-warnings 0))) + (declare (type (alien (* (unsigned 8))) a) + (type (unsigned-byte 32) i)) + (deref a i)))) + (compiler-note () (error "The code is not optimized."))) + +(handler-case + (compile nil '(lambda (x) + (declare (type (integer -100 100) x)) + (declare (optimize speed)) + (declare (notinline identity)) + (1+ (identity x)))) + (compiler-note () (error "IDENTITY derive-type not applied."))) + +(assert (null (funcall (compile nil '(lambda (x) (funcall #'cddr x))) nil)))