(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))
+
+\f
+;;;; 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.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)))
+
+\f
+;;; 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)))
+
+;;; 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)))))))
projects / sbcl.git / blobdiff