X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Flocall.lisp;h=3239cd36f4ec45ebf60204f10e272b9a59a5d046;hb=140791a0479787eaca83bea2355c15b65259a823;hp=bf6507b29d60c3f3806fc739bf00ea127b4fe6e5;hpb=57e21c4b62e8c1a1ee7ef59ed2abb0c864fb06bc;p=sbcl.git

diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp
index bf6507b..3239cd3 100644
--- a/src/compiler/locall.lisp
+++ b/src/compiler/locall.lisp
@@ -234,22 +234,21 @@
 ;;; 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))
 
@@ -393,8 +392,7 @@
 	 (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)
@@ -440,22 +438,23 @@
 (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
@@ -948,11 +947,10 @@
   (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)
@@ -1033,7 +1031,7 @@
 	  (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)
@@ -1122,7 +1120,7 @@
     (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))