(setf (block-number block) (incf num))
(setf (block-delete-p block) t)))
(do-blocks (block component)
- (unless (block-flag block)
+ (when (block-delete-p block)
(delete-block block))))
(values))
(unless (eq old-next old-tail)
(setf (block-next head) old-next)
(setf (block-prev old-next) head)
-
+
(setf (block-prev next) old-last)
(setf (block-next old-last) next))
(setf (component-lambdas new)
(nconc (component-lambdas old) (component-lambdas new)))
(setf (component-lambdas old) nil)
- (setf (component-new-funs new) (nconc (component-new-funs old)
- (component-new-funs new))
- (component-new-funs old) nil)
+ (setf (component-new-functionals new)
+ (nconc (component-new-functionals old)
+ (component-new-functionals new)))
+ (setf (component-new-functionals old) nil)
(dolist (xp (block-pred old-tail))
(unlink-blocks xp old-tail)
;;; before it walks the successors. It looks at the home CLAMBDA's
;;; BIND block to see whether that block is in some other component:
;;; -- If the block is in the initial component, then do
-;;; DFO-WALK-DEPENDENCY-GRAPH on the home function to move it
+;;; DFO-SCAVENGE-DEPENDENCY-GRAPH on the home function to move it
;;; into COMPONENT.
;;; -- If the block is in some other component, join COMPONENT into
;;; it and return that component.
(res home))))
(res)))
-;;; If CLAMBDA is not already in COMPONENT, just return that
+;;; If CLAMBDA is 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
;;; oversight, not by design, as per the bug reported by WHN on
;;; cmucl-imp ca. 2001-11-29 and explained by DTC shortly after.)
;;;
-;;; FIXME: Very likely we should be scavenging NLX-based dependencies
-;;; here too. OTOH, there's a lot of global weirdness in NLX handling,
-;;; so it might be taken care of some other way that I haven't figured
-;;; out yet. Perhaps the best way to address this would be to try to
-;;; construct a NLX-based test case which fails in the same way as the
-;;; closure-based test case on cmucl-imp 2001-11-29.)
-;;;
;;; If the function is in an initial component, then we move its head
;;; and tail to COMPONENT and add it to COMPONENT's lambdas. It is
;;; harmless to move the tail (even though the return might be
(unlink-blocks return-block (component-tail old-lambda-component))))
(let ((res (find-initial-dfo-aux bind-block component)))
(declare (type component res))
- ;; Scavenge call relationships.
- (let ((calls (if (eq (lambda-kind clambda) :external)
- (append (find-reference-funs clambda)
- (lambda-calls clambda))
- (lambda-calls clambda))))
- (dolist (call calls)
- (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))))))
+ ;; Scavenge related lambdas.
+ (labels ((scavenge-lambda (clambda)
+ (setf res
+ (dfo-scavenge-dependency-graph (lambda-home clambda)
+ res)))
+ (scavenge-possibly-deleted-lambda (clambda)
+ (unless (eql (lambda-kind clambda) :deleted)
+ (scavenge-lambda clambda)))
+ ;; Scavenge call relationship.
+ (scavenge-call (called-lambda)
+ (scavenge-lambda called-lambda))
+ ;; Scavenge closure over a variable: if CLAMBDA
+ ;; refers to a variable whose home lambda is not
+ ;; CLAMBDA, then the home lambda should be in the
+ ;; same component as CLAMBDA. (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.)
+ (scavenge-closure-var (var)
+ (unless (null (lambda-var-refs var)) ; unless var deleted
+ (let ((var-home-home (lambda-home (lambda-var-home var))))
+ (scavenge-possibly-deleted-lambda var-home-home))))
+ ;; Scavenge closure over an entry for nonlocal exit.
+ ;; This is basically parallel to closure over a
+ ;; variable above.
+ (scavenge-entry (entry)
+ (declare (type entry entry))
+ (let ((entry-home (node-home-lambda entry)))
+ (scavenge-possibly-deleted-lambda entry-home))))
+ (dolist (cc (lambda-calls-or-closes clambda))
+ (etypecase cc
+ (clambda (scavenge-call cc))
+ (lambda-var (scavenge-closure-var cc))
+ (entry (scavenge-entry cc))))
+ (when (eq (lambda-kind clambda) :external)
+ (mapc #'scavenge-call (find-reference-funs clambda))))
;; Voila.
res)))))
(values (real) (top) (real-top))))
-;; COMPONENTs want strings for names, LEAF-DEBUG-NAMEs mightn't be
-;; strings..
+;;; COMPONENTs want strings for names, LEAF-DEBUG-NAMEs mightn't be
+;;; strings...
(defun component-name-from-functional-debug-name (functional)
(declare (type functional functional))
(let ((leaf-debug-name (leaf-debug-name functional)))
;; an existing component if we find that there are references
;; between them. Any code that is left in an initial component
;; must be unreachable, so we can delete it. Stray links to the
- ;; initial component tail (due NIL function terminated blocks)
+ ;; initial component tail (due to NIL function terminated blocks)
;; are moved to the appropriate new component tail.
(dolist (toplevel-lambda toplevel-lambdas)
- (let* ((block (lambda-block toplevel-lambda))
- (old-component (block-component block))
+ (let* ((old-component (lambda-component toplevel-lambda))
(old-component-lambdas (component-lambdas old-component))
(new-component nil))
(aver (member toplevel-lambda old-component-lambdas))