1.0.46.11: faster slot-accesses in the presence of SLOT-VALUE-USING-CLASS &co
[sbcl.git] / tests / debug.impure.lisp
index b64e172..54bea98 100644 (file)
         (handler-bind
             ((error (lambda (condition)
                       ;; find the part of the backtrace we're interested in
-                      (let ((backtrace (progn
-                                         ;; (backtrace 13)
-                                         (member (caar frame-specs)
-                                                 (sb-debug:backtrace-as-list)
-                                                 :key #'car
-                                                 :test #'equal))))
+                      (let* ((full-backtrace (sb-debug:backtrace-as-list))
+                             (backtrace (member (caar frame-specs) full-backtrace
+                                                :key #'car
+                                                :test #'equal)))
 
                         (setf result condition)
 
                         (unless backtrace
-                          (print :missing-backtrace)
+                          (format t "~&//~S not in backtrace:~%   ~S~%"
+                                  (caar frame-specs)
+                                  full-backtrace)
                           (setf result nil))
 
                         ;; check that we have all the frames we wanted
          (funcall fun)))
 
   (with-test (:name (:undefined-function :bug-346)
-              :fails-on '(or :alpha))   ; bug 346
+              :fails-on '(or :alpha :ppc :sparc :mips
+                          (and :x86-64 :freebsd)))
     (assert (verify-backtrace
              (lambda () (test #'optimized))
              (list *undefined-function-frame*
               ;; the presence of the IR1 stepper instrumentation (and
               ;; is thus again failing now that the instrumentation is
               ;; no more).
-              :fails-on '(or :x86 :x86-64 :alpha))
+              :fails-on '(or :alpha :mips :ppc))
     (assert (verify-backtrace
              (lambda () (test #'not-optimized))
              (list *undefined-function-frame*
          (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
          (funcall fun)))
   (with-test (:name (:divide-by-zero :bug-346)
-              :fails-on '(or :alpha))   ; bug 346
+              :fails-on :alpha)  ; bug 346
     (assert (verify-backtrace (lambda () (test #'optimized))
                               (list '(/ 42 &rest)
                                     (list '(flet test) #'optimized)))))
   (with-test (:name (:divide-by-zero :bug-356)
-              :fails-on '(or :alpha))   ; bug 356
+              :fails-on :alpha)  ; bug 356
     (assert (verify-backtrace (lambda () (test #'not-optimized))
                               (list '(/ 42 &rest)
                                     '((flet not-optimized))
 
 (with-test (:name (:throw :no-such-tag)
             :fails-on '(or
-                        (and :x86 (or :linux :freebsd sunos))
+                        (and :sparc :linux)
                         :alpha
                         :mips))
   (progn
 (defbt 5 (&optional (opt (oops)))
   (list opt))
 
+(defmacro with-details (bool &body body)
+  `(let ((sb-debug:*show-entry-point-details* ,bool))
+     ,@body))
+
+(defun bug-354 (x)
+  (error "XEPs in backtraces: ~S" x))
+
+(with-test (:name :bug-354)
+  (with-details t
+    (assert (not (verify-backtrace (lambda () (bug-354 354))
+                                   '((bug-354 &rest)
+                                     ((sb-c::tl-xep bug-354) &rest))))))
+  (assert (verify-backtrace (lambda () (bug-354 354)) '((bug-354 354)))))
+
 ;;; FIXME: This test really should be broken into smaller pieces
-(with-test (:name (:backtrace :misc)
-            :fails-on '(and :x86 (or :linux :sunos)))
-  (macrolet ((with-details (bool &body body)
-               `(let ((sb-debug:*show-entry-point-details* ,bool))
-                 ,@body)))
-
-    ;; TL-XEP
-    (print :tl-xep)
-    (with-details t
-      (assert (verify-backtrace #'namestring
-                                '(((sb-c::tl-xep namestring) 0 ?)))))
-    (with-details nil
-      (assert (verify-backtrace #'namestring
-                                '((namestring)))))
-
-
-    ;; &MORE-PROCESSOR
-    (with-details t
-      (assert (verify-backtrace (lambda () (bt.1.1 :key))
-                                '(((sb-c::&more-processor bt.1.1) &rest))))
-      (assert (verify-backtrace (lambda () (bt.1.2 :key))
-                                '(((sb-c::&more-processor bt.1.2) &rest))))
-      (assert (verify-backtrace (lambda () (bt.1.3 :key))
-                                '(((sb-c::&more-processor bt.1.3) &rest)))))
-    (with-details nil
-      (assert (verify-backtrace (lambda () (bt.1.1 :key))
-                                '((bt.1.1 :key))))
-      (assert (verify-backtrace (lambda () (bt.1.2 :key))
-                                '((bt.1.2 &rest))))
-      (assert (verify-backtrace (lambda () (bt.1.3 :key))
-                                '((bt.1.3 &rest)))))
-
-    ;; XEP
-    (print :xep)
-    (with-details t
-      (assert (verify-backtrace #'bt.2.1
-                                '(((sb-c::xep bt.2.1) 0 ?))))
-      (assert (verify-backtrace #'bt.2.2
-                                '(((sb-c::xep bt.2.2) &rest))))
-      (assert (verify-backtrace #'bt.2.3
-                                '(((sb-c::xep bt.2.3) &rest)))))
-    (with-details nil
-      (assert (verify-backtrace #'bt.2.1
-                                '((bt.2.1))))
-      (assert (verify-backtrace #'bt.2.2
-                                '((bt.2.2 &rest))))
-      (assert (verify-backtrace #'bt.2.3
-                                '((bt.2.3 &rest)))))
-
-    ;; VARARGS-ENTRY
-    (print :varargs-entry)
-    (with-details t
-      (assert (verify-backtrace #'bt.3.1
-                                '(((sb-c::varargs-entry bt.3.1) :key nil))))
-      (assert (verify-backtrace #'bt.3.2
-                                '(((sb-c::varargs-entry bt.3.2) :key ?))))
-      (assert (verify-backtrace #'bt.3.3
-                                '(((sb-c::varargs-entry bt.3.3) &rest)))))
-    (with-details nil
-      (assert (verify-backtrace #'bt.3.1
-                                '((bt.3.1 :key nil))))
-      (assert (verify-backtrace #'bt.3.2
-                                '((bt.3.2 :key ?))))
-      (assert (verify-backtrace #'bt.3.3
-                                '((bt.3.3 &rest)))))
-
-    ;; HAIRY-ARG-PROCESSOR
-    (print :hairy-args-processor)
-    (with-details t
-      (assert (verify-backtrace #'bt.4.1
-                                '(((sb-c::hairy-arg-processor bt.4.1) ?))))
-      (assert (verify-backtrace #'bt.4.2
-                                '(((sb-c::hairy-arg-processor bt.4.2) ?))))
-      (assert (verify-backtrace #'bt.4.3
-                                '(((sb-c::hairy-arg-processor bt.4.3) &rest)))))
-    (with-details nil
-      (assert (verify-backtrace #'bt.4.1
-                                '((bt.4.1 ?))))
-      (assert (verify-backtrace #'bt.4.2
-                                '((bt.4.2 ?))))
-      (assert (verify-backtrace #'bt.4.3
-                                '((bt.4.3 &rest)))))
-
-    ;; &OPTIONAL-PROCESSOR
-    (print :optional-processor)
-    (with-details t
-      (assert (verify-backtrace #'bt.5.1
-                                '(((sb-c::&optional-processor bt.5.1)))))
-      (assert (verify-backtrace #'bt.5.2
-                                '(((sb-c::&optional-processor bt.5.2) &rest))))
-      (assert (verify-backtrace #'bt.5.3
-                                '(((sb-c::&optional-processor bt.5.3) &rest)))))
-    (with-details nil
-      (assert (verify-backtrace #'bt.5.1
-                                '((bt.5.1))))
-      (assert (verify-backtrace #'bt.5.2
-                                '((bt.5.2 &rest))))
-      (assert (verify-backtrace #'bt.5.3
-                                '((bt.5.3 &rest)))))))
+(with-test (:name (:backtrace :tl-xep)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace #'namestring
+                              '(((sb-c::tl-xep namestring) 0 ?)))))
+  (with-details nil
+    (assert (verify-backtrace #'namestring
+                              '((namestring))))))
+
+(with-test (:name (:backtrace :more-processor)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace (lambda () (bt.1.1 :key))
+                              '(((sb-c::&more-processor bt.1.1) &rest))))
+    (assert (verify-backtrace (lambda () (bt.1.2 :key))
+                              '(((sb-c::&more-processor bt.1.2) &rest))))
+    (assert (verify-backtrace (lambda () (bt.1.3 :key))
+                              '(((sb-c::&more-processor bt.1.3) &rest)))))
+  (with-details nil
+    (assert (verify-backtrace (lambda () (bt.1.1 :key))
+                              '((bt.1.1 :key))))
+    (assert (verify-backtrace (lambda () (bt.1.2 :key))
+                              '((bt.1.2 &rest))))
+    (assert (verify-backtrace (lambda () (bt.1.3 :key))
+                              '((bt.1.3 &rest))))))
+
+(with-test (:name (:backtrace :xep)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace #'bt.2.1
+                              '(((sb-c::xep bt.2.1) 0 ?))))
+    (assert (verify-backtrace #'bt.2.2
+                              '(((sb-c::xep bt.2.2) &rest))))
+    (assert (verify-backtrace #'bt.2.3
+                              '(((sb-c::xep bt.2.3) &rest)))))
+  (with-details nil
+    (assert (verify-backtrace #'bt.2.1
+                              '((bt.2.1))))
+    (assert (verify-backtrace #'bt.2.2
+                              '((bt.2.2 &rest))))
+    (assert (verify-backtrace #'bt.2.3
+                              '((bt.2.3 &rest))))))
+
+(with-test (:name (:backtrace :varargs-entry)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace #'bt.3.1
+                              '(((sb-c::varargs-entry bt.3.1) :key nil))))
+    (assert (verify-backtrace #'bt.3.2
+                              '(((sb-c::varargs-entry bt.3.2) :key ?))))
+    (assert (verify-backtrace #'bt.3.3
+                              '(((sb-c::varargs-entry bt.3.3) &rest)))))
+  (with-details nil
+    (assert (verify-backtrace #'bt.3.1
+                              '((bt.3.1 :key nil))))
+    (assert (verify-backtrace #'bt.3.2
+                              '((bt.3.2 :key ?))))
+    (assert (verify-backtrace #'bt.3.3
+                              '((bt.3.3 &rest))))))
+
+(with-test (:name (:backtrace :hairy-args-processor)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace #'bt.4.1
+                              '(((sb-c::hairy-arg-processor bt.4.1) ?))))
+    (assert (verify-backtrace #'bt.4.2
+                              '(((sb-c::hairy-arg-processor bt.4.2) ?))))
+    (assert (verify-backtrace #'bt.4.3
+                              '(((sb-c::hairy-arg-processor bt.4.3) &rest)))))
+  (with-details nil
+    (assert (verify-backtrace #'bt.4.1
+                              '((bt.4.1 ?))))
+    (assert (verify-backtrace #'bt.4.2
+                              '((bt.4.2 ?))))
+    (assert (verify-backtrace #'bt.4.3
+                              '((bt.4.3 &rest))))))
+
+
+(with-test (:name (:backtrace :optional-processor)
+                  :fails-on '(and :x86 (or :sunos)))
+  (with-details t
+    (assert (verify-backtrace #'bt.5.1
+                              '(((sb-c::&optional-processor bt.5.1)))))
+    (assert (verify-backtrace #'bt.5.2
+                              '(((sb-c::&optional-processor bt.5.2) &rest))))
+    (assert (verify-backtrace #'bt.5.3
+                              '(((sb-c::&optional-processor bt.5.3) &rest)))))
+  (with-details nil
+    (assert (verify-backtrace #'bt.5.1
+                              '((bt.5.1))))
+    (assert (verify-backtrace #'bt.5.2
+                              '((bt.5.2 &rest))))
+    (assert (verify-backtrace #'bt.5.3
+                              '((bt.5.3 &rest))))))
+
+(write-line "//compile nil")
+(defvar *compile-nil-error* (compile nil '(lambda (x) (cons (when x (error "oops")) nil))))
+(defvar *compile-nil-non-tc* (compile nil '(lambda (y) (cons (funcall *compile-nil-error* y) nil))))
+(assert (verify-backtrace (lambda () (funcall *compile-nil-non-tc* 13))
+                          '(((lambda (x)) 13)
+                            ((lambda (y)) 13))))
+
+(with-test (:name :clos-slot-typecheckfun-named)
+  (assert
+   (verify-backtrace
+    (lambda ()
+      (eval `(locally (declare (optimize safety))
+               (defclass clos-typecheck-test ()
+                 ((slot :type fixnum)))
+               (setf (slot-value (make-instance 'clos-typecheck-test) 'slot) t))))
+    '(((sb-pcl::slot-typecheck fixnum) t)))))
+
+(with-test (:name :clos-emf-named)
+  (assert
+   (verify-backtrace
+    (lambda ()
+      (eval `(progn
+               (defmethod clos-emf-named-test ((x symbol)) x)
+               (defmethod clos-emf-named-test :before (x) (assert x))
+               (clos-emf-named-test nil))))
+    '(((sb-pcl::emf clos-emf-named-test) ? ? nil)))))
+
+(with-test (:name :bug-310173)
+  (flet ((make-fun (n)
+           (let* ((names '(a b))
+                  (req (loop repeat n collect (pop names))))
+             (compile nil
+                      `(lambda (,@req &rest rest)
+                         (let ((* *)) ; no tail-call
+                           (apply '/ ,@req rest)))))))
+    (assert
+     (verify-backtrace (lambda ()
+                         (funcall (make-fun 0) 10 11 0))
+                       '((sb-kernel:two-arg-/ 10/11 0)
+                         (/ 10 11 0)
+                         ((lambda (&rest rest)) 10 11 0))))
+    (assert
+     (verify-backtrace (lambda ()
+                         (funcall (make-fun 1) 10 11 0))
+                       '((sb-kernel:two-arg-/ 10/11 0)
+                         (/ 10 11 0)
+                         ((lambda (a &rest rest)) 10 11 0))))
+    (assert
+     (verify-backtrace (lambda ()
+                         (funcall (make-fun 2) 10 11 0))
+                       '((sb-kernel:two-arg-/ 10/11 0)
+                         (/ 10 11 0)
+                         ((lambda (a b &rest rest)) 10 11 0))))))
 
 ;;;; test TRACE
 
 ;;; This is not a WITH-TEST :FAILS-ON PPC DARWIN since there are
 ;;; suspicions that the breakpoint trace might corrupt the whole image
 ;;; on that platform.
-#-(and (or ppc x86) darwin)
+#-(and (or ppc x86 x86-64) (or darwin sunos))
 (with-test (:name (trace :encapsulate nil)
-            :fails-on '(or :ppc :sparc :mips))
+            :fails-on '(or (and :ppc (not :linux)) :sparc :mips))
   (let ((out (with-output-to-string (*trace-output*)
                (trace trace-this :encapsulate nil)
                (assert (eq 'ok (trace-this)))
     (assert (search "TRACE-THIS" out))
     (assert (search "returned OK" out))))
 
-#-(and (or ppc x86) darwin)
+#-(and (or ppc x86 x86-64) darwin)
 (with-test (:name (trace-recursive :encapsulate nil)
-            :fails-on '(or :ppc :sparc :mips))
+            :fails-on '(or (and :ppc (not :linux)) :sparc :mips))
   (let ((out (with-output-to-string (*trace-output*)
                (trace trace-fact :encapsulate nil)
                (assert (= 120 (trace-fact 5)))
     (assert (search "returned 1" out))
     (assert (search "returned 120" out))))
 
+(defun trace-and-fmakunbound-this (x)
+  x)
+
+(with-test (:name :bug-667657)
+  (trace trace-and-fmakunbound-this)
+  (fmakunbound 'trace-and-fmakunbound-this)
+  (untrace)
+  (assert (not (trace))))
+
+(with-test (:name :bug-414)
+  (handler-bind ((warning #'error))
+    (load (compile-file "bug-414.lisp"))
+    (disassemble 'bug-414)))
+
+(with-test (:name :bug-310175)
+  (let ((dx-arg (cons t t)))
+    (declare (dynamic-extent dx-arg))
+    (flet ((dx-arg-backtrace (x)
+             (declare (optimize (debug 2)))
+             (prog1 (sb-debug:backtrace-as-list 10)
+               (assert (sb-debug::stack-allocated-p x)))))
+      (declare (notinline dx-arg-backtrace))
+      (assert (member-if (lambda (frame)
+                           (and (consp frame)
+                                (equal '(flet dx-arg-backtrace) (car frame))
+                                (notany #'sb-debug::stack-allocated-p (cdr frame))))
+                         (dx-arg-backtrace dx-arg))))))
+
 ;;;; test infinite error protection
 
 (defmacro nest-errors (n-levels error-form)
   ;; after 50 successful throws to SB-IMPL::TOPLEVEL-CATCHER sbcl used
   ;; to halt, it produces so much garbage that's hard to suppress that
   ;; it is tested only once
+  (write-line "--HARMLESS BUT ALARMING BACKTRACE COMING UP--")
   (let ((*debugger-hook* #'erroring-debugger-hook))
     (loop repeat 1 do
           (let ((error-counter 0)
                    (catch 'sb-impl::toplevel-catcher
                      (nest-errors 20 (error "infinite error ~s"
                                             (incf error-counter)))
-                     :normal-exit))))))))
+                     :normal-exit)))))))
+  (write-line "--END OF H-B-A-B--"))
 
 (enable-debugger)