;;;; 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
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
(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)))
((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
(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)
(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)))
;;; 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
(ir2-continuation-locs (continuation-info (second args)))
nil))
(nil)))
-
(move-continuation-result node block () (node-cont node))
(values))