X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler.pure.lisp;h=a0715b7d3e7b57ecff71a5ab9a0e64628ffa49e1;hb=602c9b1f15e2d96e4b79a3341a734b5eb8e02093;hp=eefc810dc474fb8ee7f9ca6803d710527ff01dae;hpb=c0595e94aab165f59454a3a97f06a8bdc22f5bd3;p=sbcl.git diff --git a/tests/compiler.pure.lisp b/tests/compiler.pure.lisp index eefc810..a0715b7 100644 --- a/tests/compiler.pure.lisp +++ b/tests/compiler.pure.lisp @@ -1033,6 +1033,8 @@ 215067723) 13739018)) + +;;;; Bugs in stack analysis ;;; bug 299 (reported by PFD) (assert (equal (funcall @@ -1044,6 +1046,43 @@ (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 @@ -1094,6 +1133,108 @@ :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.361: replacing CAST with (m-v-call #'%compile-time-type-error) +;;; could transform known-values LVAR to UVL +(assert (zerop (funcall + (compile + nil + '(lambda (a b c) + (declare (notinline boole values denominator list)) + (declare + (optimize (speed 2) + (space 0) + (safety 1) + (debug 0) + (compilation-speed 2))) + (catch 'ct6 + (progv + '(*s8*) + (list 0) + (let ((v9 (ignore-errors (throw 'ct6 0)))) + (denominator + (progv nil nil (values (boole boole-and 0 v9))))))))) + 1 2 3))) + +;;; non-continuous dead UVL blocks +(defun non-continuous-stack-test (x) + (multiple-value-call #'list + (eval '(values 11 12)) + (eval '(values 13 14)) + (block ext + (return-from non-continuous-stack-test + (multiple-value-call #'list + (eval '(values :b1 :b2)) + (eval '(values :b3 :b4)) + (block int + (return-from ext + (multiple-value-call (eval #'values) + (eval '(values 1 2)) + (eval '(values 3 4)) + (block ext + (return-from int + (multiple-value-call (eval #'values) + (eval '(values :a1 :a2)) + (eval '(values :a3 :a4)) + (block int + (return-from ext + (multiple-value-call (eval #'values) + (eval '(values 5 6)) + (eval '(values 7 8)) + (if x + :ext + (return-from int :int)))))))))))))))) +(assert (equal (non-continuous-stack-test t) '(11 12 13 14 1 2 3 4 5 6 7 8 :ext))) +(assert (equal (non-continuous-stack-test nil) '(:b1 :b2 :b3 :b4 :a1 :a2 :a3 :a4 :int))) + + ;;; MISC.275 (assert (zerop @@ -1117,3 +1258,74 @@ '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))) + +;;; MISC.293 = easy variant of bug 303: repeated write to the same +;;; LVAR; here the first write may be cleared before the second is +;;; made. +(assert + (zerop + (funcall + (compile + nil + '(lambda () + (declare (notinline complex)) + (declare (optimize (speed 1) (space 0) (safety 1) + (debug 3) (compilation-speed 3))) + (flet ((%f () (multiple-value-prog1 0 (return-from %f 0)))) + (complex (%f) 0)))))))