+
+;;; 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)))))))
+
+;;; MISC.110A: CAST optimizer forgot to flush LVAR derived type
+(assert (zerop (funcall
+ (compile
+ nil
+ '(lambda (a c)
+ (declare (type (integer -1294746569 1640996137) a))
+ (declare (type (integer -807801310 3) c))
+ (declare (optimize (speed 3) (space 3) (safety 0) (debug 0) (compilation-speed 3)))
+ (catch 'ct7
+ (if
+ (logbitp 0
+ (if (/= 0 a)
+ c
+ (ignore-errors
+ (progn (if (ldb-test (byte 0 0) (rational (throw 'ct7 0))) 0 0) 0))))
+ 0 0))))
+ 391833530 -32785211)))
+
+;;; efficiency notes for ordinary code
+(macrolet ((frob (arglist &body body)
+ `(progn
+ (handler-case
+ (compile nil '(lambda ,arglist ,@body))
+ (sb-ext:compiler-note (e)
+ (error "bad compiler note for ~S:~% ~A" ',body e)))
+ (catch :got-note
+ (handler-case
+ (compile nil '(lambda ,arglist (declare (optimize speed))
+ ,@body))
+ (sb-ext:compiler-note (e) (throw :got-note nil)))
+ (error "missing compiler note for ~S" ',body)))))
+ (frob (x) (funcall x))
+ (frob (x y) (find x y))
+ (frob (x y) (find-if x y))
+ (frob (x y) (find-if-not x y))
+ (frob (x y) (position x y))
+ (frob (x y) (position-if x y))
+ (frob (x y) (position-if-not x y))
+ (frob (x) (aref x 0)))
+
+(macrolet ((frob (style-warn-p form)
+ (if style-warn-p
+ `(catch :got-style-warning
+ (handler-case
+ (eval ',form)
+ (style-warning (e) (throw :got-style-warning nil)))
+ (error "missing style-warning for ~S" ',form))
+ `(handler-case
+ (eval ',form)
+ (style-warning (e)
+ (error "bad style-warning for ~S: ~A" ',form e))))))
+ (frob t (lambda (x &optional y &key z) (list x y z)))
+ (frob nil (lambda (x &optional y z) (list x y z)))
+ (frob nil (lambda (x &key y z) (list x y z)))
+ (frob t (defgeneric #:foo (x &optional y &key z)))
+ (frob nil (defgeneric #:foo (x &optional y z)))
+ (frob nil (defgeneric #:foo (x &key y z)))
+ (frob t (defun #:foo (x) (flet ((foo (x &optional y &key z) (list x y z))) (foo x x :z x)))))