;;; do LET conversion here.
(defun locall-analyze-fun-1 (fun)
(declare (type functional fun))
- (let ((refs (leaf-refs fun))
- (first-time t))
+ (let ((refs (leaf-refs fun)))
(dolist (ref refs)
(let* ((lvar (node-lvar ref))
(dest (when lvar (lvar-dest lvar))))
- (cond ((and (basic-combination-p dest)
- (eq (basic-combination-fun dest) lvar)
- (eq (lvar-uses lvar) ref))
+ (unless (node-to-be-deleted-p ref)
+ (cond ((and (basic-combination-p dest)
+ (eq (basic-combination-fun dest) lvar)
+ (eq (lvar-uses lvar) ref))
- (convert-call-if-possible ref dest)
+ (convert-call-if-possible ref dest)
- (unless (eq (basic-combination-kind dest) :local)
- (reference-entry-point ref)))
- (t
- (reference-entry-point ref))))
- (setq first-time nil)))
+ (unless (eq (basic-combination-kind dest) :local)
+ (reference-entry-point ref)))
+ (t
+ (reference-entry-point ref)))))))
(values))
(original-fun (ref-leaf ref)))
(aver (functional-p original-fun))
(unless (or (member (basic-combination-kind call) '(:local :error))
- (block-delete-p block)
- (eq (functional-kind (block-home-lambda block)) :deleted)
+ (node-to-be-deleted-p call)
(member (functional-kind original-fun)
'(:toplevel-xep :deleted))
(not (or (eq (component-kind component) :initial)
(defun convert-mv-call (ref call fun)
(declare (type ref ref) (type mv-combination call) (type functional fun))
(when (and (looks-like-an-mv-bind fun)
- (not (functional-entry-fun fun))
(singleton-p (leaf-refs fun))
(singleton-p (basic-combination-args call)))
(let* ((*current-component* (node-component ref))
(ep (optional-dispatch-entry-point-fun
fun (optional-dispatch-max-args fun))))
- (aver (= (optional-dispatch-min-args fun) 0))
- (setf (basic-combination-kind call) :local)
- (pushnew ep (lambda-calls-or-closes (node-home-lambda call)))
- (merge-tail-sets call ep)
- (change-ref-leaf ref ep)
+ (when (null (leaf-refs ep))
+ (aver (= (optional-dispatch-min-args fun) 0))
+ (aver (not (functional-entry-fun fun)))
+ (setf (basic-combination-kind call) :local)
+ (pushnew ep (lambda-calls-or-closes (node-home-lambda call)))
+ (merge-tail-sets call ep)
+ (change-ref-leaf ref ep)
- (assert-lvar-type
- (first (basic-combination-args call))
- (make-short-values-type (mapcar #'leaf-type (lambda-vars ep)))
- (lexenv-policy (node-lexenv call)))))
+ (assert-lvar-type
+ (first (basic-combination-args call))
+ (make-short-values-type (mapcar #'leaf-type (lambda-vars ep)))
+ (lexenv-policy (node-lexenv call))))))
(values))
;;; Attempt to convert a call to a lambda. If the number of args is
(values))
;;; Actually do LET conversion. We call subfunctions to do most of the
-;;; work. We change the CALL's CONT to be the continuation heading the
-;;; BIND block, and also do REOPTIMIZE-LVAR on the args and
-;;; CONT so that LET-specific IR1 optimizations get a chance. We blow
-;;; away any entry for the function in *FREE-FUNS* so that nobody
-;;; will create new references to it.
+;;; work. We do REOPTIMIZE-LVAR on the args and CALL's lvar so that
+;;; LET-specific IR1 optimizations get a chance. We blow away any
+;;; entry for the function in *FREE-FUNS* so that nobody will create
+;;; new references to it.
(defun let-convert (fun call)
(declare (type clambda fun) (type basic-combination call))
(let ((next-block (if (node-tail-p call)
(when (and (basic-combination-p dest)
(eq (basic-combination-fun dest) ref-lvar)
(eq (basic-combination-kind dest) :local)
- (not (block-delete-p (node-block dest)))
+ (not (node-to-be-deleted-p dest))
(cond ((ok-initial-convert-p clambda) t)
(t
(reoptimize-lvar ref-lvar)
(let ((outside-non-tail-call nil)
(outside-call nil))
(when (and (dolist (ref (leaf-refs clambda) t)
- (let ((dest (lvar-dest (node-lvar ref))))
+ (let ((dest (node-dest ref)))
(when (or (not dest)
(block-delete-p (node-block dest)))
(return nil))