\f
;;;; Check that we get debug arglists right.
+;;; FIXME: This should use some get-argslist like functionality that
+;;; we actually export.
+;;;
;;; Return the debug arglist of the function object FUN as a list, or
;;; punt with :UNKNOWN.
(defun get-arglist (fun)
;;; 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-name
- &key (key #'first) (test #'eql)
- (allow-bogus-frames nil))
- (let ((result nil)
- (return-value nil))
- (block outer-handler
- (handler-bind
- ((error #'(lambda (condition)
- (let ((backtrace (ignore-errors
- (sb-debug:backtrace-as-list))))
- ;; Make sure we find what we're looking for.
- (when (member frame-name backtrace
- :key key :test test)
- (setf result (list :error condition)))
- ;; Make sure there's no bogus stack frames
- ;; unless they're explicitly allowed.
- (when (and (not allow-bogus-frames)
- (member "bogus stack frame" backtrace
- :key #'first :test #'equal))
+(defun verify-backtrace (test-function frame-specs &key (allow-stunted nil))
+ (labels ((args-equal (want real)
+ (cond ((eq '&rest (car want))
+ t)
+ ((endp want)
+ (endp real))
+ ((or (eq '? (car want)) (equal (car want) (car real)))
+ (args-equal (cdr want) (cdr real)))
+ (t
+ nil))))
+ (let ((result nil))
+ (block outer-handler
+ (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))))
+
+ (setf result condition)
+
+ (unless backtrace
+ (print :missing-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 :mismatch spec frame))
+ (setf result nil)))
+ frame-specs
+ backtrace)
+
;; Make sure the backtrace isn't stunted in
;; any way. (Depends on running in the main
;; thread.)
- (unless (member 'sb-impl::toplevel-init backtrace
- :key #'first :test #'equal)
- (setf result nil)))
- (return-from outer-handler))))
- (funcall test-function)))
- (values result return-value)))
+ (let ((end (last backtrace 2)))
+ (unless (equal (caar end)
+ (if *show-entry-point-details*
+ '(sb-c::tl-xep sb-impl::toplevel-init)
+ 'sb-impl::toplevel-init))
+ (print (list :backtrace-stunted (caar end)))
+ (setf result nil)))
+ (return-from outer-handler)))))
+ (funcall test-function)))
+ result)))
+
+(defvar *undefined-function-frame*
+ ;; bug 353
+ '(#+(or x86 x86-64) "bogus stack frame"
+ #-(or x86 x86-64) "undefined function"))
+#-(or alpha) ; bug 346
;;; Test for "undefined function" (undefined_tramp) working properly.
;;; Try it with and without tail call elimination, since they can have
;;; different effects. (Specifically, if undefined_tramp is incorrect
;;; a stunted stack can result from the tail call variant.)
-#-(or alpha x86) ; bug 345
-(progn
- (flet ((test-function ()
- (declare (optimize (speed 2) (debug 1))) ; tail call elimination
- (#:undefined-function 42)))
- (assert (verify-backtrace #'test-function "undefined function"
- :test #'equal)))
+(flet ((optimized ()
+ (declare (optimize (speed 2) (debug 1))) ; tail call elimination
+ (#:undefined-function 42))
+ (not-optimized ()
+ (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
+ (#:undefined-function 42))
+ (test (fun)
+ (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
+ (funcall fun)))
+
+ (assert (verify-backtrace
+ (lambda () (test #'optimized))
+ (list *undefined-function-frame*
+ (list '(flet test) #'optimized))))
- (flet ((test-function ()
- (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
- (#:undefined-function 42)))
- (assert (verify-backtrace #'test-function "undefined function"
- :test #'equal))))
+ ;; bug 353: This test fails at least most of the time for x86/linux
+ ;; ca. 0.8.20.16. -- WHN
+ #-(and x86 linux)
+ (assert (verify-backtrace
+ (lambda () (test #'not-optimized))
+ (list *undefined-function-frame*
+ (list '(flet not-optimized))
+ (list '(flet test) #'not-optimized)))))
+#-alpha ; bug 346
;;; Division by zero was a common error on PPC. It depended on the
;;; return function either being before INTEGER-/-INTEGER in memory,
;;; or more than MOST-POSITIVE-FIXNUM bytes ahead. It also depends on
;;; the return value (to the flet or the enclosing top level form) is
;;; more than MOST-POSITIVE-FIXNUM with the current spaces on OS X.
;;; Enabling it might catch other problems, so do it anyway.
-#-alpha ; bug 346
+(flet ((optimized ()
+ (declare (optimize (speed 2) (debug 1))) ; tail call elimination
+ (/ 42 0))
+ (not-optimized ()
+ (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
+ (/ 42 0))
+ (test (fun)
+ (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
+ (funcall fun)))
+ (assert (verify-backtrace (lambda () (test #'optimized))
+ (list '(/ 42 &rest)
+ (list '(flet test) #'optimized))))
+ (assert (verify-backtrace (lambda () (test #'not-optimized))
+ (list '(/ 42 &rest)
+ '((flet not-optimized))
+ (list '(flet test) #'not-optimized)))))
+
+#-(or alpha (and x86 linux)) ; bug 61
(progn
- (flet ((test-function ()
- (declare (optimize (speed 1) (debug 2))) ; tail call elimination
- (/ 42 0)))
- (assert (verify-backtrace #'test-function '/)))
-
- (flet ((test-function ()
- (declare (optimize (speed 1) (debug 2))) ; no tail call elimination
- (/ 42 0)))
- (assert (verify-backtrace #'test-function '/))))
-
-#-(or x86 alpha) ; bug 61
-(defun throw-test ()
- (throw 'no-such-tag t))
-(assert (verify-backtrace #'throw-test 'throw-test))
+ (defun throw-test ()
+ (throw 'no-such-tag t))
+ (assert (verify-backtrace #'throw-test '((throw-test)))))
+
+;;; test entry point handling in backtraces
+
+(defun oops ()
+ (error "oops"))
+
+(defmacro defbt (n ll &body body)
+ `(progn
+ ;; normal debug info
+ (defun ,(intern (format nil "BT.~A.1" n)) ,ll
+ ,@body)
+ ;; no arguments saved
+ (defun ,(intern (format nil "BT.~A.2" n)) ,ll
+ (declare (optimize (debug 1) (speed 3)))
+ ,@body)
+ ;; no lambda-list saved
+ (defun ,(intern (format nil "BT.~A.3" n)) ,ll
+ (declare (optimize (debug 0)))
+ ,@body)))
+
+(defbt 1 (&key key)
+ (list key))
+
+(defbt 2 (x)
+ (list x))
+
+(defbt 3 (&key (key (oops)))
+ (list key))
+
+;;; ERROR instead of OOPS so that tail call elimination doesn't happen
+(defbt 4 (&optional opt)
+ (list (error "error")))
+
+(defbt 5 (&optional (opt (oops)))
+ (list opt))
+
+#-(and x86 linux)
+(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))))))
+
+;;;; test TRACE
+
+(defun trace-this ()
+ 'ok)
+
+(let ((out (with-output-to-string (*trace-output*)
+ (trace trace-this)
+ (assert (eq 'ok (trace-this)))
+ (untrace))))
+ (assert (search "TRACE-THIS" out))
+ (assert (search "returned OK" out)))
+
+#-(and ppc darwin)
+;;; bug 379
+(let ((out (with-output-to-string (*trace-output*)
+ (trace trace-this :encapsulate nil)
+ (assert (eq 'ok (trace-this)))
+ (untrace))))
+ (assert (search "TRACE-THIS" out))
+ (assert (search "returned OK" out)))
;;; success
(quit :unix-status 104)