0.8.16.2: TYPE-ERROR for ERROR
[sbcl.git] / tests / compiler.pure.lisp
index dcf5fb5..cd528ed 100644 (file)
 (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.362: environment of UNWIND-PROTECTor is different from that
+;;; if ENTRY.
+(assert (equal (multiple-value-list (funcall
+   (compile
+    nil
+    '(lambda (b g h)
+       (declare (optimize (speed 3) (space 3) (safety 2)
+                         (debug 2) (compilation-speed 3)))
+       (catch 'ct5
+        (unwind-protect
+            (labels ((%f15 (f15-1 f15-2 f15-3)
+                            (rational (throw 'ct5 0))))
+              (%f15 0
+                    (apply #'%f15
+                           0
+                           h
+                           (progn
+                             (progv '(*s2* *s5*) (list 0 (%f15 0 g 0)) b)
+                             0)
+                           nil)
+                    0))
+          (common-lisp:handler-case 0)))))
+   1 2 3))
+ '(0)))
+
 \f
 ;;; MISC.275
 (assert
                        (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)))))
+
+;;; this was a bug in the LOGXOR type deriver.  The top form gave a
+;;; note, because the system failed to derive the fact that the return
+;;; from LOGXOR was small and negative, though the bottom one worked.
+(handler-bind ((sb-ext:compiler-note #'error))
+  (compile nil '(lambda ()
+                (declare (optimize speed (safety 0)))
+                (lambda (x y)
+                  (declare (type (integer 3 6) x)
+                           (type (integer -6 -3) y))
+                  (+ (logxor x y) most-positive-fixnum)))))
+(handler-bind ((sb-ext:compiler-note #'error))
+  (compile nil '(lambda ()
+                (declare (optimize speed (safety 0)))
+                (lambda (x y)
+                  (declare (type (integer 3 6) y)
+                           (type (integer -6 -3) x))
+                  (+ (logxor x y) most-positive-fixnum)))))
+
+;;; check that modular ash gives the right answer, to protect against
+;;; possible misunderstandings about the hardware shift instruction.
+(assert (zerop (funcall
+               (compile nil '(lambda (x y)
+                              (declare (optimize speed)
+                                       (type (unsigned-byte 32) x y))
+                              (logand #xffffffff (ash x y))))
+               1 257)))
+
+;;; code instrumenting problems
+(compile nil
+  '(lambda ()
+    (declare (optimize (debug 3)))
+    (list (the integer (if nil 14 t)))))
+
+(compile nil
+  '(LAMBDA (A B C D)
+    (DECLARE (NOTINLINE LOGORC1 BYTE MASK-FIELD))
+    (DECLARE
+     (OPTIMIZE (SPEED 1)
+      (SPACE 1)
+      (SAFETY 1)
+      (DEBUG 3)
+      (COMPILATION-SPEED 0)))
+    (MASK-FIELD (BYTE 7 26)
+     (PROGN
+       (TAGBODY (THE INTEGER (CATCH 'CT4 (LOGORC1 C -15950))) 1)
+       B))))
+
+(compile nil
+  '(lambda (buffer i end)
+    (declare (optimize (debug 3)))
+    (loop (when (not (eql 0 end)) (return)))
+    (let ((s (make-string end)))
+      (setf (schar s i) (schar buffer i))
+      s)))
+
+;;; check that constant string prefix and suffix don't cause the
+;;; compiler to emit code deletion notes.
+(handler-bind ((sb-ext:code-deletion-note #'error))
+  (compile nil '(lambda (s x)
+                 (pprint-logical-block (s x :prefix "(")
+                   (print x s))))
+  (compile nil '(lambda (s x)
+                 (pprint-logical-block (s x :per-line-prefix ";")
+                   (print x s))))
+  (compile nil '(lambda (s x)
+                 (pprint-logical-block (s x :suffix ">")
+                   (print x s)))))
+
+;;; MISC.427: loop analysis requires complete DFO structure
+(assert (eql 17 (funcall
+  (compile
+   nil
+   '(lambda (a)
+     (declare (notinline list reduce logior))
+     (declare (optimize (safety 2) (compilation-speed 1)
+               (speed 3) (space 2) (debug 2)))
+     (logior
+      (let* ((v5 (reduce #'+ (list 0 a))))
+        (declare (dynamic-extent v5))
+        v5))))
+    17)))