(let ((head (component-head component)))
(do ()
((dolist (ep (block-succ head) t)
- (unless (block-flag ep)
+ (unless (or (block-flag ep) (block-delete-p ep))
(find-dfo-aux ep head component)
(return nil))))))
(let ((num 0))
(do-blocks-backwards (block component :both)
(if (block-flag block)
(setf (block-number block) (incf num))
- (setf (block-delete-p block) t)))
- (do-blocks (block component)
- (when (block-delete-p block)
- (delete-block block))))
+ (delete-block-lazily block)))
+ (clean-component component (component-head component)))
(values))
;;; Move all the code and entry points from OLD to NEW. The code in
(defun find-dfo-aux (block head component)
(unless (eq (block-component block) component)
(join-components component (block-component block)))
- (unless (block-flag block)
+ (unless (or (block-flag block) (block-delete-p block))
(setf (block-flag block) t)
(dolist (succ (block-succ block))
(find-dfo-aux succ head component))
;; in the old LAMBDA into the new one (with LETs implicitly moved
;; by changing their home.)
(do-blocks (block component)
- (do-nodes (node cont block)
+ (do-nodes (node nil block)
(let ((lexenv (node-lexenv node)))
(when (eq (lexenv-lambda lexenv) lambda)
(setf (lexenv-lambda lexenv) result-lambda))))
;; is always a preceding REF NIL node in top level lambdas.
(let ((return (lambda-return lambda)))
(when return
- (let ((return-block (node-block return))
- (result (return-result return)))
- (setf (block-last return-block) (continuation-use result))
- (flush-dest result)
- (delete-continuation result)
- (link-blocks return-block result-return-block))))))
+ (link-blocks (node-block return) result-return-block)
+ (flush-dest (return-result return))
+ (unlink-node return)))))
;;; Given a non-empty list of top level LAMBDAs, smash them into a
;;; top level lambda and component, returning these as values. We use
;; Make sure the result's return node starts a block so that we
;; can splice code in before it.
(let ((prev (node-prev
- (continuation-use
- (return-result result-return)))))
- (when (continuation-use prev)
- (node-ends-block (continuation-use prev)))
- (do-uses (use prev)
- (let ((new (make-continuation)))
- (delete-continuation-use use)
- (add-continuation-use use new))))
+ (lvar-uses (return-result result-return)))))
+ (when (ctran-use prev)
+ (node-ends-block (ctran-use prev))))
(dolist (lambda (rest lambdas))
(merge-1-toplevel-lambda result-lambda lambda)))