(declare (ignore x)
(ignorable y))
(list u v)))))))
+
+;;; bug reported by Paul Dietz: wrong optimizer for (EXPT ... 0)
+(loop for (x type) in
+ '((14 integer)
+ (14 rational)
+ (-14/3 (rational -8 11))
+ (3s0 short-float)
+ (4f0 single-float)
+ (5d0 double-float)
+ (6l0 long-float)
+ (14 real)
+ (13/2 real)
+ (2s0 real)
+ (2d0 real)
+ (#c(-3 4) (complex fixnum))
+ (#c(-3 4) (complex rational))
+ (#c(-3/7 4) (complex rational))
+ (#c(2s0 3s0) (complex short-float))
+ (#c(2f0 3f0) (complex single-float))
+ (#c(2d0 3d0) (complex double-float))
+ (#c(2l0 3l0) (complex long-float))
+ (#c(2d0 3s0) (complex float))
+ (#c(2 3f0) (complex real))
+ (#c(2 3d0) (complex real))
+ (#c(-3/7 4) (complex real))
+ (#c(-3/7 4) complex)
+ (#c(2 3l0) complex))
+ do (dolist (zero '(0 0s0 0f0 0d0 0l0))
+ (dolist (real-zero (list zero (- zero)))
+ (let* ((src `(lambda (x) (expt (the ,type x) ,real-zero)))
+ (fun (compile nil src))
+ (result (1+ (funcall (eval #'*) x real-zero))))
+ (assert (eql result (funcall fun x)))))))
+
+;;; (SIGNED-BYTE 1) [ returned from the logxor derive-type optimizer ]
+;;; wasn't recognized as a good type specifier.
+(let ((fun (lambda (x y)
+ (declare (type (integer -1 0) x y) (optimize speed))
+ (logxor x y))))
+ (assert (= (funcall fun 0 0) 0))
+ (assert (= (funcall fun 0 -1) -1))
+ (assert (= (funcall fun -1 -1) 0)))
+
+;;; from PFD's torture test, triggering a bug in our effective address
+;;; treatment.
+(compile
+ nil
+ `(lambda (a b)
+ (declare (type (integer 8 22337) b))
+ (logandc2
+ (logandc2
+ (* (logandc1 (max -29303 b) 4) b)
+ (abs (logorc1 (+ (logandc1 -11 b) 2607688420) -31153924)))
+ (logeqv (max a 0) b))))
+
+;;; Alpha floating point modes weren't being reset after an exception,
+;;; leading to an exception on the second compile, below.
+(compile nil '(lambda (x y) (declare (type (double-float 0.0d0) x y)) (/ x y)))
+(handler-case (/ 1.0 0.0)
+ ;; provoke an exception
+ (arithmetic-error ()))
+(compile nil '(lambda (x y) (declare (type (double-float 0.0d0) x y)) (/ x y)))
+
+;;; bug reported by Paul Dietz: component last block does not have
+;;; start ctran
+(compile nil
+ '(lambda ()
+ (declare (notinline + logand)
+ (optimize (speed 0)))
+ (LOGAND
+ (BLOCK B5
+ (FLET ((%F1 ()
+ (RETURN-FROM B5 -220)))
+ (LET ((V7 (%F1)))
+ (+ 359749 35728422))))
+ -24076)))
+
+;;; bug 294 reported by Paul Dietz: miscompilation of REM and MOD
+(assert (= (funcall (compile nil `(lambda (b)
+ (declare (optimize (speed 3))
+ (type (integer 2 152044363) b))
+ (rem b (min -16 0))))
+ 108251912)
+ 8))
+
+(assert (= (funcall (compile nil `(lambda (c)
+ (declare (optimize (speed 3))
+ (type (integer 23062188 149459656) c))
+ (mod c (min -2 0))))
+ 95019853)
+ -1))
+
+;;; bug reported by Paul Dietz: block splitting inside FLUSH-DEAD-CODE
+(compile nil
+ '(LAMBDA (A B C)
+ (BLOCK B6
+ (LOGEQV (REM C -6758)
+ (REM B (MAX 44 (RETURN-FROM B6 A)))))))
+
+(compile nil '(lambda ()
+ (block nil
+ (flet ((foo (x y) (if (> x y) (print x) (print y))))
+ (foo 1 2)
+ (bar)
+ (foo (return 14) 2)))))
+
+;;; bug in Alpha backend: not enough sanity checking of arguments to
+;;; instructions
+(assert (= (funcall (compile nil
+ '(lambda (x)
+ (declare (fixnum x))
+ (ash x -257)))
+ 1024)
+ 0))
+
+;;; bug found by WHN and pfdietz: compiler failure while referencing
+;;; an entry point inside a deleted lambda
+(compile nil '(lambda ()
+ (let (r3533)
+ (flet ((bbfn ()
+ (setf r3533
+ (progn
+ (flet ((truly (fn bbd)
+ (let (r3534)
+ (let ((p3537 nil))
+ (unwind-protect
+ (multiple-value-prog1
+ (progn
+ (setf r3534
+ (progn
+ (bubf bbd t)
+ (flet ((c-3536 ()
+ (funcall fn)))
+ (cdec #'c-3536
+ (vector bbd))))))
+ (setf p3537 t))
+ (unless p3537
+ (error "j"))))
+ r3534))
+ (c (pd) (pdc pd)))
+ (let ((a (smock a))
+ (b (smock b))
+ (b (smock c)))))))))
+ (wum #'bbfn "hc3" (list)))
+ r3533)))
+(compile nil '(lambda () (flet ((%f () (unwind-protect nil))) nil)))
+
+;;; the strength reduction of constant multiplication used (before
+;;; sbcl-0.8.4.x) to lie to the compiler. This meant that, under
+;;; certain circumstances, the compiler would derive that a perfectly
+;;; reasonable multiplication never returned, causing chaos. Fixed by
+;;; explicitly doing modular arithmetic, and relying on the backends
+;;; being smart.
+(assert (= (funcall
+ (compile nil
+ '(lambda (x)
+ (declare (type (integer 178956970 178956970) x)
+ (optimize speed))
+ (* x 24)))
+ 178956970)
+ 4294967280))
+
+;;; bug in modular arithmetic and type specifiers
+(assert (= (funcall (compile nil (lambda (x) (logand x x 0)))
+ -1)
+ 0))
+
+;;; MISC.99 from Paul Dietz' random tester: FAST-ASH-MOD32-C VOP
+;;; produced wrong result for shift >=32 on X86
+(assert (= 0 (funcall
+ (compile nil
+ '(lambda (a)
+ (declare (type (integer 4303063 101130078) a))
+ (mask-field (byte 18 2) (ash a 77))))
+ 57132532)))
+
+;;; MISC.101 and MISC.103: FLUSH-DEST did not mark the USE's block for
+;;; type check regeneration
+(assert (eql (funcall
+ (compile nil '(lambda (a c)
+ (declare (type (integer 185501219873 303014665162) a))
+ (declare (type (integer -160758 255724) c))
+ (declare (optimize (speed 3)))
+ (let ((v8
+ (- -554046873252388011622614991634432
+ (ignore-errors c)
+ (unwind-protect 2791485))))
+ (max (ignore-errors a)
+ (let ((v6 (- v8 (restart-case 980))))
+ (min v8 v6))))))
+ 259448422916 173715)
+ 259448422916))
+(assert (eql (funcall
+ (compile nil '(lambda (a b)
+ (min -80
+ (abs
+ (ignore-errors
+ (+
+ (logeqv b
+ (block b6
+ (return-from b6
+ (load-time-value -6876935))))
+ (if (logbitp 1 a) b (setq a -1522022182249))))))))
+ -1802767029877 -12374959963)
+ -80))
+
+;;; various MISC.*, related to NODEs/LVARs with derived type NIL
+(assert (eql (funcall (compile nil '(lambda (c)
+ (declare (type (integer -3924 1001809828) c))
+ (declare (optimize (speed 3)))
+ (min 47 (if (ldb-test (byte 2 14) c)
+ -570344431
+ (ignore-errors -732893970)))))
+ 705347625)
+ -570344431))
+(assert (eql (funcall
+ (compile nil '(lambda (b)
+ (declare (type (integer -1598566306 2941) b))
+ (declare (optimize (speed 3)))
+ (max -148949 (ignore-errors b))))
+ 0)
+ 0))
+(assert (eql (funcall
+ (compile nil '(lambda (b c)
+ (declare (type (integer -4 -3) c))
+ (block b7
+ (flet ((%f1 (f1-1 f1-2 f1-3)
+ (if (logbitp 0 (return-from b7
+ (- -815145138 f1-2)))
+ (return-from b7 -2611670)
+ 99345)))
+ (let ((v2 (%f1 -2464 (%f1 -1146 c c) -2)))
+ b)))))
+ 2950453607 -4)
+ -815145134))
+(assert (eql (funcall
+ (compile nil
+ '(lambda (b c)
+ (declare (type (integer -29742055786 23602182204) b))
+ (declare (type (integer -7409 -2075) c))
+ (declare (optimize (speed 3)))
+ (floor
+ (labels ((%f2 ()
+ (block b6
+ (ignore-errors (return-from b6
+ (if (= c 8) b 82674))))))
+ (%f2)))))
+ 22992834060 -5833)
+ 82674))
+(assert (equal (multiple-value-list
+ (funcall
+ (compile nil '(lambda (a)
+ (declare (type (integer -944 -472) a))
+ (declare (optimize (speed 3)))
+ (round
+ (block b3
+ (return-from b3
+ (if (= 55957 a) -117 (ignore-errors
+ (return-from b3 a))))))))
+ -589))
+ '(-589 0)))