0.pre7.98:

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

diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp
index 2ad7d66..8fa72f4 100644 (file)
--- a/src/compiler/ir2tran.lisp
+++ b/src/compiler/ir2tran.lisp
@@ -54,10 +54,10 @@
 ;;;; leaf reference
 
 ;;; Return the TN that holds the value of THING in the environment ENV.
+(declaim (ftype (function ((or nlx-info lambda-var) physenv) tn)
+               find-in-physenv))
 (defun find-in-physenv (thing physenv)
-  (declare (type (or nlx-info lambda-var) thing) (type physenv physenv)
-          (values tn))
-  (or (cdr (assoc thing (ir2-physenv-environment (physenv-info physenv))))
+  (or (cdr (assoc thing (ir2-physenv-closure (physenv-info physenv))))
       (etypecase thing
        (lambda-var
         ;; I think that a failure of this assertion means that we're
@@ -390,7 +390,7 @@
          dest))
   (values))
 
-;;; If necessary, emit coercion code needed to deliver the Results to
+;;; If necessary, emit coercion code needed to deliver the RESULTS to
 ;;; the specified continuation. NODE and BLOCK provide context for
 ;;; emitting code. Although usually obtained from STANDARD-RESULT-TNs
 ;;; or CONTINUATION-RESULT-TNs, RESULTS my be a list of any type or
@@ -649,7 +649,7 @@
            (locs loc))))
 
       (when old-fp
-       (dolist (thing (ir2-physenv-environment called-env))
+       (dolist (thing (ir2-physenv-closure called-env))
          (temps (find-in-physenv (car thing) this-1env))
          (locs (cdr thing)))
        
@@ -770,7 +770,7 @@
          ((node-tail-p node)
           (ir2-convert-tail-local-call node block fun))
          (t
-          (let ((start (block-label (node-block (lambda-bind fun))))
+          (let ((start (block-label (lambda-block fun)))
                 (returns (tail-set-info (lambda-tail-set fun)))
                 (cont (node-cont node)))
             (ecase (if returns
@@ -1015,7 +1015,7 @@
   (declare (type bind node) (type ir2-block block) (type clambda fun))
   (let ((start-label (entry-info-offset (leaf-info fun)))
        (env (physenv-info (node-physenv node))))
-    (let ((ef (functional-entry-function fun)))
+    (let ((ef (functional-entry-fun fun)))
       (cond ((and (optional-dispatch-p ef) (optional-dispatch-more-entry ef))
             ;; Special case the xep-allocate-frame + copy-more-arg case.
             (vop xep-allocate-frame node block start-label t)
@@ -1023,13 +1023,13 @@
            (t
             ;; No more args, so normal entry.
             (vop xep-allocate-frame node block start-label nil)))
-      (if (ir2-physenv-environment env)
+      (if (ir2-physenv-closure env)
          (let ((closure (make-normal-tn *backend-t-primitive-type*)))
            (vop setup-closure-environment node block start-label closure)
            (when (getf (functional-plist ef) :fin-function)
              (vop funcallable-instance-lexenv node block closure closure))
            (let ((n -1))
-             (dolist (loc (ir2-physenv-environment env))
+             (dolist (loc (ir2-physenv-closure env))
                (vop closure-ref node block closure (incf n) (cdr loc)))))
          (vop setup-environment node block start-label)))
 
@@ -1143,10 +1143,10 @@
 ;;; stack. It returns the OLD-FP and RETURN-PC for the current
 ;;; function as multiple values.
 (defoptimizer (sb!kernel:%caller-frame-and-pc ir2-convert) (() node block)
-  (let ((env (physenv-info (node-physenv node))))
+  (let ((ir2-physenv (physenv-info (node-physenv node))))
     (move-continuation-result node block
-                             (list (ir2-physenv-old-fp env)
-                                   (ir2-physenv-return-pc env))
+                             (list (ir2-physenv-old-fp ir2-physenv)
+                                   (ir2-physenv-return-pc ir2-physenv))
                              (node-cont node))))
 \f
 ;;;; multiple values
@@ -1330,7 +1330,6 @@
            (ir2-continuation-locs (continuation-info (second args)))
            nil))
          (nil)))
-
   (move-continuation-result node block () (node-cont node))
   (values))