(when (eq sb-ext:*evaluator-mode* :interpret)
(sb-ext:quit :unix-status 104))
-(setq sb-c::*check-consistency* t)
+(setq sb-c::*check-consistency* t
+ sb-ext:*stack-allocate-dynamic-extent* t)
(defmacro defun-with-dx (name arglist &body body)
- `(locally
- (declare (optimize sb-c::stack-allocate-dynamic-extent))
- (defun ,name ,arglist
- ,@body)))
+ `(defun ,name ,arglist
+ ,@body))
(declaim (notinline opaque-identity))
(defun opaque-identity (x)
;;; value-cells
(defun-with-dx dx-value-cell (x)
- (declare (optimize sb-c::stack-allocate-value-cells))
;; Not implemented everywhere, yet.
- #+(or x86 x86-64 mips)
+ #+(or x86 x86-64 mips hppa)
(let ((cell x))
- (declare (dynamic-extent cell))
+ (declare (sb-int:truly-dynamic-extent cell))
(flet ((f ()
(incf cell)))
(declare (dynamic-extent #'f))
(setf (car x) nil))
nil))
+(defparameter *bar* nil)
+(declaim (inline make-nested-bad make-nested-good))
+(defstruct (nested (:constructor make-nested-bad (&key bar &aux (bar (setf *bar* bar))))
+ (:constructor make-nested-good (&key bar)))
+ bar)
+
+(defun-with-dx nested-good (y)
+ (let ((x (list (list (make-nested-good :bar (list (list (make-nested-good :bar (list y)))))))))
+ (declare (dynamic-extent x))
+ (true x)))
+
+(defun-with-dx nested-bad (y)
+ (let ((x (list (list (make-nested-bad :bar (list (list (make-nested-bad :bar (list y)))))))))
+ (declare (dynamic-extent x))
+ (unless (equalp (caar x) (make-nested-good :bar *bar*))
+ (error "got ~S, wanted ~S" (caar x) (make-nested-good :bar *bar*)))
+ (caar x)))
+
+(with-test (:name :conservative-nested-dx)
+ ;; NESTED-BAD should not stack-allocate :BAR due to the SETF.
+ (assert (equalp (nested-bad 42) (make-nested-good :bar *bar*)))
+ (assert (equalp *bar* (list (list (make-nested-bad :bar (list 42)))))))
+
;;; multiple uses for dx lvar
(defun-with-dx multiple-dx-uses ()
;;; handler-case and handler-bind should use DX internally
(defun dx-handler-bind (x)
- (handler-bind ((error (lambda (c) (break "OOPS: ~S caused ~S" x c)))
+ (handler-bind ((error
+ (lambda (c) (break "OOPS: ~S caused ~S" x c)))
((and serious-condition (not error))
#'(lambda (c) (break "OOPS2: ~S did ~S" x c))))
(/ 2 x)))
(:no-error (res)
(1- res))))))
-;;; with-spinlock should use DX and not cons
+;;; with-spinlock and with-mutex should use DX and not cons
(defvar *slock* (sb-thread::make-spinlock :name "slocklock"))
(sb-thread::with-spinlock (*slock*)
(true *slock*)))
+(defvar *mutex* (sb-thread::make-mutex :name "mutexlock"))
+
+(defun test-mutex ()
+ (sb-thread:with-mutex (*mutex*)
+ (true *mutex*)))
+
;;; not really DX, but GETHASH and (SETF GETHASH) should not cons
(defvar *table* (make-hash-table))
(defvar *a-cons* (cons nil nil))
-#+(or x86 x86-64 alpha ppc sparc mips)
+#+(or x86 x86-64 alpha ppc sparc mips hppa)
(progn
(assert-no-consing (dxclosure 42))
(assert-no-consing (dxlength 1 2 3))
(assert-no-consing (cons-on-stack 42))
(assert-no-consing (make-array-on-stack))
(assert-no-consing (make-foo1-on-stack 123))
+ (assert-no-consing (nested-good 42))
(#+raw-instance-init-vops assert-no-consing
#-raw-instance-init-vops progn
(make-foo2-on-stack 1.24 1.23d0))
;; Not strictly DX..
(assert-no-consing (test-hash-table))
#+sb-thread
- (assert-no-consing (test-spinlock)))
+ (progn
+ (assert-no-consing (test-spinlock))
+ (assert-no-consing (test-mutex))))
\f
;;; Bugs found by Paul F. Dietz
(assert (every (lambda (x) (eql x 0)) a))))
(assert-no-consing (bdowning-2005-iv-16))
-
(defun-with-dx let-converted-vars-dx-allocated-bug (x y z)
(let* ((a (list x y z))
(b (list x y z))
(c (list a b)))
(declare (dynamic-extent c))
(values (first c) (second c))))
-(multiple-value-bind (i j) (let-converted-vars-dx-allocated-bug 1 2 3)
- (assert (and (equal i j)
- (equal i (list 1 2 3)))))
+
+(with-test (:name :let-converted-vars-dx-allocated-bug)
+ (multiple-value-bind (i j) (let-converted-vars-dx-allocated-bug 1 2 3)
+ (assert (and (equal i j)
+ (equal i (list 1 2 3))))))
;;; workaround for bug 419 -- real issue remains, but check that the
;;; bandaid holds.
(def 0 (list :one) (list :two) (list :three))
(def 1 (make-array 128) (list 1 2 3 4 5 6 7 8) (list 'list))
(def 2 (list 1) (list 2 3) (list 4 5 6 7)))
+
+;;; Test that unknown-values coming after a DX value won't mess up the stack analysis
+(defun test-update-uvl-live-sets (x y z)
+ (declare (optimize speed (safety 0)))
+ (flet ((bar (a b)
+ (declare (dynamic-extent a))
+ (eval `(list (length ',a) ',b))))
+ (list (bar x y)
+ (bar (list x y z) ; dx push
+ (list
+ (multiple-value-call 'list
+ (eval '(values 1 2 3)) ; uv push
+ (max y z)
+ ) ; uv pop
+ 14)
+ ))))
+(assert (equal '((0 4) (3 ((1 2 3 5) 14))) (test-update-uvl-live-sets #() 4 5)))
+
+(with-test (:name :regression-1.0.23.38)
+ (compile nil '(lambda ()
+ (flet ((make (x y)
+ (let ((res (cons x x)))
+ (setf (cdr res) y)
+ res)))
+ (declaim (inline make))
+ (let ((z (make 1 2)))
+ (declare (dynamic-extent z))
+ (print z)
+ t))))
+ (compile nil '(lambda ()
+ (flet ((make (x y)
+ (let ((res (cons x x)))
+ (setf (cdr res) y)
+ (if x res y))))
+ (declaim (inline make))
+ (let ((z (make 1 2)))
+ (declare (dynamic-extent z))
+ (print z)
+ t)))))
\f
projects / sbcl.git / blobdiff