0.pre7.109:

[sbcl.git] / src / compiler / ir1opt.lisp

diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp
index 616c984..ff7fb3a 100644 (file)
--- a/src/compiler/ir1opt.lisp
+++ b/src/compiler/ir1opt.lisp
@@ -497,7 +497,7 @@
 (defun ir1-optimize-return (node)
   (declare (type creturn node))
   (let* ((tails (lambda-tail-set (return-lambda node)))
-        (funs (tail-set-functions tails)))
+        (funs (tail-set-funs tails)))
     (collect ((res *empty-type* values-type-union))
       (dolist (fun funs)
        (let ((return (lambda-return fun)))
@@ -509,7 +509,7 @@
 
       (when (type/= (res) (tail-set-type tails))
        (setf (tail-set-type tails) (res))
-       (dolist (fun (tail-set-functions tails))
+       (dolist (fun (tail-set-funs tails))
          (dolist (ref (leaf-refs fun))
            (reoptimize-continuation (node-cont ref)))))))
 
@@ -1242,7 +1242,7 @@
 ;;; changes. We look at each changed argument. If the corresponding
 ;;; variable is set, then we call PROPAGATE-FROM-SETS. Otherwise, we
 ;;; consider substituting for the variable, and also propagate
-;;; derived-type information for the arg to all the Var's refs.
+;;; derived-type information for the arg to all the VAR's refs.
 ;;;
 ;;; Substitution is inhibited when the arg leaf's derived type isn't a
 ;;; subtype of the argument's asserted type. This prevents type
@@ -1259,7 +1259,7 @@
 ;;; are done, then we delete the LET.
 ;;;
 ;;; Note that we are responsible for clearing the
-;;; Continuation-Reoptimize flags.
+;;; CONTINUATION-REOPTIMIZE flags.
 (defun propagate-let-args (call fun)
   (declare (type combination call) (type clambda fun))
   (loop for arg in (combination-args call)
@@ -1283,8 +1283,7 @@
                                  this-comp)
                              t)
                             (t
-                             (aver (eq (functional-kind (lambda-home fun))
-                                       :toplevel))
+                             (aver (lambda-toplevelish-p (lambda-home fun)))
                              nil)))
                   leaf var))
                t)))))
@@ -1313,7 +1312,7 @@
 (defun propagate-local-call-args (call fun)
   (declare (type combination call) (type clambda fun))
 
-  (unless (or (functional-entry-function fun)
+  (unless (or (functional-entry-fun fun)
              (lambda-optional-dispatch fun))
     (let* ((vars (lambda-vars fun))
           (union (mapcar #'(lambda (arg var)