X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fdebug.impure.lisp;h=33b38613417058308b8c429d1f0d60b1d64f8657;hb=cf49f2d086069a9c1b57f501df9a6a0bd3a34c3c;hp=b902b74e9013fba78e8730111e2ee49a354ac31c;hpb=04a651e749befd65ffd8bf49f689b6e7d55607e2;p=sbcl.git

diff --git a/tests/debug.impure.lisp b/tests/debug.impure.lisp
index b902b74..33b3861 100644
--- a/tests/debug.impure.lisp
+++ b/tests/debug.impure.lisp
@@ -81,7 +81,7 @@
 ;;; and that it contains the frames we expect, doesn't contain any
 ;;; "bogus stack frame"s, and contains the appropriate toplevel call
 ;;; and hasn't been cut off anywhere.
-(defun verify-backtrace (test-function frame-specs &key (allow-stunted nil))
+(defun verify-backtrace (test-function frame-specs &key (allow-stunted nil) details)
   (labels ((args-equal (want real)
              (cond ((eq '&rest (car want))
                     t)
@@ -96,39 +96,66 @@
         (handler-bind
             ((error (lambda (condition)
                       ;; find the part of the backtrace we're interested in
-                      (let* ((full-backtrace (sb-debug:backtrace-as-list))
-                             (backtrace (member (caar frame-specs) full-backtrace
-                                                :key #'car
-                                                :test #'equal)))
-
-                        (setf result condition)
-
-                        (unless 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
-                        (mapcar
-                         (lambda (spec frame)
-                           (unless (or (not spec)
-                                       (and (equal (car spec) (car frame))
-                                            (args-equal (cdr spec)
-                                                        (cdr frame))))
-                             (print (list :wanted spec :got frame))
-                             (setf result nil)))
-                         frame-specs
-                         backtrace)
-
-                        ;; Make sure the backtrace isn't stunted in
-                        ;; any way.  (Depends on running in the main
-                        ;; thread.) FIXME: On Windows we get two
-                        ;; extra foreign frames below regular frames.
-                        (unless (find '(sb-impl::toplevel-init) backtrace
-                                      :test #'equal)
-                          (print (list :backtrace-stunted backtrace))
-                          (setf result nil))
-                        (return-from outer-handler)))))
+                      (let (full-backtrace)
+                        (sb-debug::map-backtrace
+                         (lambda (frame)
+                           (multiple-value-bind (name args info)
+                               (sb-debug::frame-call frame #+nil #+nil
+                                                           :replace-dynamic-extent-objects t)
+                             (if details
+                                 (push (list (cons name args) info) full-backtrace)
+                                 (push (cons name args) full-backtrace)))))
+
+                        (setf full-backtrace (nreverse full-backtrace))
+                        (let ((backtrace (if details
+                                             (member (caaar frame-specs)
+                                                     full-backtrace
+                                                     :key #'caar
+                                                     :test #'equal)
+                                             (member (caar frame-specs)
+                                                     full-backtrace
+                                                     :key #'car
+                                                     :test #'equal))))
+
+                          (setf result condition)
+
+                          (unless 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
+                          (mapcar
+                           (lambda (spec frame)
+                             (unless (or (not spec)
+                                         (if details
+                                             (handler-case
+                                                 (and (args-equal (car spec)
+                                                                  (car frame))
+                                                      (equal (cdr spec) (cdr frame)))
+                                               (error (e)
+                                                 (print (list :spec spec :frame frame))
+                                                 (error e)))
+                                             (and (equal (car spec) (car frame))
+                                                  (args-equal (cdr spec)
+                                                              (cdr frame)))))
+                               (print (list :wanted spec :got frame))
+                               (setf result nil)))
+                           frame-specs
+                           backtrace)
+
+                          ;; Make sure the backtrace isn't stunted in
+                          ;; any way.  (Depends on running in the main
+                          ;; thread.) FIXME: On Windows we get two
+                          ;; extra foreign frames below regular frames.
+                          (unless (find (if details
+                                            '((sb-impl::toplevel-init) ())
+                                            '(sb-impl::toplevel-init))
+                                        backtrace
+                                        :test #'equal)
+                            (print (list :backtrace-stunted backtrace))
+                            (setf result nil))
+                          (return-from outer-handler))))))
           (funcall test-function)))
       result)))
 
@@ -174,15 +201,15 @@
 (with-test (:name :backtrace-interrupted-condition-wait
             :skipped-on '(not :sb-thread)
                   ;; For some unfathomable reason the backtrace becomes
-                  ;; stunted on Darwin, ending at _sigtramp, when we add
-                  ;; :TIMEOUT NIL to the frame we expect. If we leave it out,
-                  ;; the backtrace is fine -- but the test fails. I can only
-                  ;; boggle right now.
-            :fails-on '(or (and :x86 :linux) :darwin))
+                  ;; stunted, ending at _sigtramp, when we add :TIMEOUT NIL to
+                  ;; the frame we expect. If we leave it out, the backtrace is
+                  ;; fine -- but the test fails. I can only boggle right now.
+            :fails-on `(or (and :x86 :linux)
+                           :win32))
   (let ((m (sb-thread:make-mutex))
         (q (sb-thread:make-waitqueue)))
     (assert (verify-backtrace
-            (lambda ()
+             (lambda ()
               (sb-thread:with-mutex (m)
                 (handler-bind ((timeout (lambda (c)
                                           (error "foo"))))
@@ -246,6 +273,44 @@
                             '(((flet bar :in bug-308926) 13)
                               (bug-308926 &rest t)))))
 
+;;; Test backtrace through assembly routines
+;;; :bug-800343
+(macrolet ((test (predicate fun
+                    &optional (two-arg
+                               (find-symbol (format nil "TWO-ARG-~A" fun)
+                                            "SB-KERNEL")))
+               (let ((test-name (make-symbol (format nil "TEST-~A" fun))))
+                 `(flet ((,test-name (x y)
+                           ;; make sure it's not in tail position
+                           (list (,fun x y))))
+                    (with-test (:name (:bug-800343 ,fun))
+                      (assert (verify-backtrace
+                               (lambda ()
+                                 (eval `(funcall ,#',test-name 42 t)))
+                               '((,two-arg 42 t)
+                                 #+(or x86 x86-64)
+                                 ,@(and predicate
+                                    '(("no debug information for frame")))
+                                 ((flet ,test-name :in ,*p*) 42 t))))))))
+             (test-predicates (&rest functions)
+               `(progn ,@(mapcar (lambda (function)
+                                   (if (consp function)
+                                       `(test t ,@function)
+                                       `(test t ,function)))
+                                 functions)))
+             (test-functions (&rest functions)
+               `(progn ,@(mapcar (lambda (function)
+                                   (if (consp function)
+                                       `(test nil ,@function)
+                                       `(test nil ,function)))
+                                 functions))))
+    (test-predicates = < >)
+    (test-functions + - * /
+                    gcd lcm
+                    (logand sb-kernel:two-arg-and)
+                    (logior sb-kernel:two-arg-ior)
+                    (logxor sb-kernel:two-arg-xor)))
+
 ;;; test entry point handling in backtraces
 
 (defun oops ()
@@ -292,109 +357,108 @@
 (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 (not (verify-backtrace (lambda () (bug-354 354))
+                                 '((bug-354 354)
+                                   (((bug-354 &rest) (:tl :external)) 354)))))
   (assert (verify-backtrace (lambda () (bug-354 354)) '((bug-354 354)))))
 
 ;;; FIXME: This test really should be broken into smaller pieces
 (with-test (:name (:backtrace :tl-xep))
-  (with-details t
-    (assert (verify-backtrace #'namestring
-                              '(((sb-c::tl-xep namestring) 0 ?)))))
-  (with-details nil
-    (assert (verify-backtrace #'namestring
-                              '((namestring))))))
+  (assert (verify-backtrace #'namestring
+                            '(((namestring) (:tl :external)))
+                            :details t))
+  (assert (verify-backtrace #'namestring
+                            '((namestring)))))
 
 (with-test (:name (:backtrace :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))))))
+  (assert (verify-backtrace (lambda () (bt.1.1 :key))
+                            '(((bt.1.1 :key) (:more :optional)))
+                            :details t))
+  (assert (verify-backtrace (lambda () (bt.1.2 :key))
+                            '(((bt.1.2 ?) (:more :optional)))
+                            :details t))
+  (assert (verify-backtrace (lambda () (bt.1.3 :key))
+                            '(((bt.1.3 &rest) (:more :optional)))
+                            :details t))
+  (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))
-  (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))))))
-
+  (assert (verify-backtrace #'bt.2.1
+                            '(((bt.2.1) (:external)))
+                            :details t))
+  (assert (verify-backtrace #'bt.2.2
+                            '(((bt.2.2 &rest) (:external)))
+                            :details t))
+  (assert (verify-backtrace #'bt.2.3
+                            '(((bt.2.3 &rest) (:external)))
+                            :details t))
+  (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)))))
+
+;;; This test is somewhat deceptively named. Due to confusion in debug naming
+;;; these functions used to have sb-c::varargs-entry debug names for their
+;;; main lambda.
 (with-test (:name (:backtrace :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))))))
-
+  (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))))
+  (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)))))
+
+;;; This test is somewhat deceptively named. Due to confusion in debug naming
+;;; these functions used to have sb-c::hairy-args-processor debug names for
+;;; their main lambda.
 (with-test (:name (:backtrace :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))))))
+  (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))))
+  (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))
-  (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))))))
+  (assert (verify-backtrace #'bt.5.1
+                            '(((bt.5.1) (:optional)))
+                            :details t))
+  (assert (verify-backtrace #'bt.5.2
+                            '(((bt.5.2 &rest) (:optional)))
+                            :details t))
+  (assert (verify-backtrace #'bt.5.3
+                            '(((bt.5.3 &rest) (:optional)))
+                            :details t))
+  (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))))
@@ -483,7 +547,7 @@
     (assert (search "TRACE-THIS" out))
     (assert (search "returned OK" out))))
 
-(with-test (:name (trace-recursive :encapsulate nil)
+(with-test (:name (:trace-recursive :encapsulate nil)
             :fails-on '(or (and :ppc (not :linux)) :sparc :mips :sunos)
             :broken-on '(or :darwin (and :x86 :sunos)))
   (let ((out (with-output-to-string (*trace-output*)
@@ -517,7 +581,7 @@
     (declare (dynamic-extent dx-arg))
     (flet ((dx-arg-backtrace (x)
              (declare (optimize (debug 2)))
-             (prog1 (sb-debug:backtrace-as-list 10)
+             (prog1 (sb-debug:list-backtrace :count 10)
                (assert (sb-debug::stack-allocated-p x)))))
       (declare (notinline dx-arg-backtrace))
       (assert (member-if (lambda (frame)
@@ -535,7 +599,8 @@
              ((error (lambda (e)
                        (declare (ignore e))
                        (handler-case
-                           (sb-debug:backtrace 100 (make-broadcast-stream))
+                           (sb-debug:print-backtrace :count 100
+                                                     :stream (make-broadcast-stream))
                          (error ()
                            (throw 'done :error))
                          (:no-error ()
@@ -557,7 +622,7 @@
     (format t "recursive condition: ~A~%" condition) (force-output)
     (error "recursive condition: ~A" condition)))
 
-(defun test-inifinite-error-protection ()
+(defun test-infinite-error-protection ()
   ;; 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
@@ -575,14 +640,14 @@
                      :normal-exit)))))))
   (write-line "--END OF H-B-A-B--"))
 
-(with-test (:name infinite-error-protection)
+(with-test (:name :infinite-error-protection)
   (enable-debugger)
-  (test-inifinite-error-protection))
+  (test-infinite-error-protection))
 
-(with-test (:name (infinite-error-protection :thread)
+(with-test (:name (:infinite-error-protection :thread)
                   :skipped-on '(not :sb-thread))
   (enable-debugger)
-  (let ((thread (sb-thread:make-thread #'test-inifinite-error-protection)))
+  (let ((thread (sb-thread:make-thread #'test-infinite-error-protection)))
     (loop while (sb-thread:thread-alive-p thread))))
 
 ;; unconditional, in case either previous left it enabled
@@ -593,7 +658,7 @@
 ;;; Older GENCGC systems had a bug in the pointer validation used by
 ;;; MAKE-LISP-OBJ that made SIMPLE-FUN objects always fail to
 ;;; validate.
-(with-test (:name (make-lisp-obj :simple-funs))
+(with-test (:name (:make-lisp-obj :simple-funs))
   (sb-sys:without-gcing
     (assert (eq #'identity
                 (sb-kernel:make-lisp-obj
@@ -602,7 +667,7 @@
 
 ;;; Older CHENEYGC systems didn't perform any real pointer validity
 ;;; checks beyond "is this pointer to somewhere in heap space".
-(with-test (:name (make-lisp-obj :pointer-validation))
+(with-test (:name (:make-lisp-obj :pointer-validation))
   ;; Fun and games: We need to test MAKE-LISP-OBJ with a known-bogus
   ;; address, but we also need the GC to not pitch a fit if it sees an
   ;; object with said bogus address.  Thus, construct our known-bogus
@@ -651,6 +716,8 @@
                  (if (eq '* match)
                      ;; Whatever, till the next line matches.
                      (let ((text (pop targets)))
+                       #+nil
+                       (format *error-output* "Looking for: ~A~%" text)
                        (unless (search text line)
                          (push text targets)
                          (push match targets)))
@@ -695,7 +762,7 @@
       (let ((f #'(lambda (x cont)
                    (print x (make-broadcast-stream))
                    (if (zerop x)
-                       (error "foo")
+                       (error "~%foo")
                        (funcall cont (1- x) cont)))))
         (funcall f 10 f)))
    '*
@@ -703,7 +770,7 @@
    '*
    "foo"
    '*
-   "source: (ERROR \"foo\")"
+   "source: (ERROR \"~%foo\")"
    '*
    "(LAMBDA (X CONT)"
    '*
@@ -743,4 +810,25 @@
       (unless (zerop (length problems))
         (error problems)))))
 
+(defgeneric gf-dispatch-test/gf (x y)
+  (:method (x y)
+    (+ x y)))
+(defun gf-dispatch-test/f (z)
+  (gf-dispatch-test/gf z))
+
+(with-test (:name :gf-dispatch-backtrace)
+  ;; Fill the cache
+  (gf-dispatch-test/gf 1 1)
+  ;; Wrong argument count
+  (assert (verify-backtrace (lambda () (gf-dispatch-test/f 42))
+                            '(((sb-pcl::gf-dispatch gf-dispatch-test/gf) 42)))))
+
+(with-test (:name (:xep-arglist-clean-up :bug-1192929))
+  (assert
+   (block nil
+     (handler-bind ((error (lambda (e)
+                             (declare (ignore e))
+                             (return (< (length (car (sb-debug:backtrace-as-list 1))) 10)))))
+       (funcall (compile nil `(lambda (i) (declare ((mod 65536) i)) i)) nil)))))
+
 (write-line "/debug.impure.lisp done")