(res home))))
(res)))
-;;; If FUN is not already in COMPONENT, just return that component.
-;;; Otherwise, move the code for FUN and all functions it physically
-;;; depends on (either because of calls or because of closure
-;;; relationships) into COMPONENT, or possibly into another COMPONENT
-;;; that we find to be related. Return whatever COMPONENT we actually
-;;; merged into.
+;;; If CLAMBDA is not already in COMPONENT, just return that
+;;; component. Otherwise, move the code for CLAMBDA and all lambdas it
+;;; physically depends on (either because of calls or because of
+;;; closure relationships) into COMPONENT, or possibly into another
+;;; COMPONENT that we find to be related. Return whatever COMPONENT we
+;;; actually merged into.
;;;
;;; (Note: The analogous CMU CL code only scavenged call-based
;;; dependencies, not closure dependencies. That seems to've been by
;;; unreachable) because if the return is unreachable it (and its
;;; successor link) will be deleted in the post-deletion pass.
;;;
-;;; We then do a FIND-DFO-AUX starting at the head of FUN. If this
+;;; We then do a FIND-DFO-AUX starting at the head of CLAMBDA. If this
;;; flow-graph walk encounters another component (which can only
;;; happen due to a non-local exit), then we move code into that
;;; component instead. We then recurse on all functions called from
-;;; FUN, moving code into whichever component the preceding call
+;;; CLAMBDA, moving code into whichever component the preceding call
;;; returned.
;;;
-;;; If FUN is in the initial component, but the BLOCK-FLAG is set in
-;;; the bind block, then we just return COMPONENT, since we must have
-;;; already reached this function in the current walk (or the
+;;; If CLAMBDA is in the initial component, but the BLOCK-FLAG is set
+;;; in the bind block, then we just return COMPONENT, since we must
+;;; have already reached this function in the current walk (or the
;;; component would have been changed).
;;;
;;; If the function is an XEP, then we also walk all functions that
;;; ensures that conversion of a full call to a local call won't
;;; result in a need to join components, since the components will
;;; already be one.
-(defun dfo-scavenge-dependency-graph (fun component)
- (declare (type clambda fun) (type component component))
- (let* ((bind-block (node-block (lambda-bind fun)))
+(defun dfo-scavenge-dependency-graph (clambda component)
+ (declare (type clambda clambda) (type component component))
+ (assert (not (eql (lambda-kind clambda) :deleted)))
+ (let* ((bind-block (node-block (lambda-bind clambda)))
(old-lambda-component (block-component bind-block))
- (return (lambda-return fun)))
+ (return (lambda-return clambda)))
(cond
((eq old-lambda-component component)
component)
((block-flag bind-block)
component)
(t
- (push fun (component-lambdas component))
+ (push clambda (component-lambdas component))
(setf (component-lambdas old-lambda-component)
- (delete fun (component-lambdas old-lambda-component)))
+ (delete clambda (component-lambdas old-lambda-component)))
(link-blocks (component-head component) bind-block)
(unlink-blocks (component-head old-lambda-component) bind-block)
(when return
(let ((res (find-initial-dfo-aux bind-block component)))
(declare (type component res))
;; Scavenge call relationships.
- (let ((calls (if (eq (functional-kind fun) :external)
- (append (find-reference-funs fun)
- (lambda-calls fun))
- (lambda-calls fun))))
+ (let ((calls (if (eq (lambda-kind clambda) :external)
+ (append (find-reference-funs clambda)
+ (lambda-calls clambda))
+ (lambda-calls clambda))))
(dolist (call calls)
- (setf res (dfo-scavenge-dependency-graph call res))))
- ;; TO DO: Scavenge closure-over relationships.
- (values)
+ (let ((call-home (lambda-home call)))
+ (setf res (dfo-scavenge-dependency-graph call-home res)))))
+ ;; Scavenge closure-over relationships: if FUN refers to a
+ ;; variable whose home lambda is not FUN, then the home lambda
+ ;; should be in the same component as FUN. (sbcl-0.6.13, and
+ ;; CMU CL, didn't do this, leading to the occasional failure
+ ;; when physenv analysis, which is local to each component,
+ ;; would bogusly conclude that a closed-over variable was
+ ;; unused and thus delete it. See e.g. cmucl-imp 2001-11-29.)
+ (dolist (var (lambda-refers-to-vars clambda))
+ (unless (null (lambda-var-refs var)) ; i.e. unless deleted
+ (let ((var-home-home (lambda-home (lambda-var-home var))))
+ (unless (eql (lambda-kind var-home-home) :deleted)
+ (setf res
+ (dfo-scavenge-dependency-graph var-home-home res))))))
;; Voila.
res)))))
-;;; Return true if FUN either is an XEP or has EXITS to some of its
-;;; ENTRIES.
-(defun has-xep-or-nlx (fun)
- (declare (type clambda fun))
- (or (eq (functional-kind fun) :external)
- (let ((entries (lambda-entries fun)))
+;;; Return true if CLAMBDA either is an XEP or has EXITS to some of
+;;; its ENTRIES.
+(defun has-xep-or-nlx (clambda)
+ (declare (type clambda clambda))
+ (or (eq (functional-kind clambda) :external)
+ (let ((entries (lambda-entries clambda)))
(and entries
(find-if #'entry-exits entries)))))
projects / sbcl.git / blobdiff