(declaim (ftype (function ((or nlx-info lambda-var) physenv) tn)
find-in-physenv))
(defun find-in-physenv (thing physenv)
- (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
(move-continuation-result node block locs cont))
(values))
-;;; Emit code to load a function object representing LEAF into RES.
-;;; This gets interesting when the referenced function is a closure:
-;;; we must make the closure and move the closed over values into it.
+;;; Emit code to load a function object implementing FUN into
+;;; RES. This gets interesting when the referenced function is a
+;;; closure: we must make the closure and move the closed-over values
+;;; into it.
;;;
-;;; LEAF is either a :TOPLEVEL-XEP functional or the XEP lambda for
-;;; the called function, since local call analysis converts all
-;;; closure references. If a TL-XEP, we know it is not a closure.
+;;; FUN is either a :TOPLEVEL-XEP functional or the XEP lambda for the
+;;; called function, since local call analysis converts all closure
+;;; references. If a :TOPLEVEL-XEP, we know it is not a closure.
;;;
;;; If a closed-over LAMBDA-VAR has no refs (is deleted), then we
;;; don't initialize that slot. This can happen with closures over
;;; top level variables, where optimization of the closure deleted the
;;; variable. Since we committed to the closure format when we
;;; pre-analyzed the top level code, we just leave an empty slot.
-(defun ir2-convert-closure (node block leaf res)
- (declare (type ref node) (type ir2-block block)
- (type functional leaf) (type tn res))
- (unless (leaf-info leaf)
- (setf (leaf-info leaf) (make-entry-info)))
- (let ((entry (make-load-time-constant-tn :entry leaf))
- (closure (etypecase leaf
+(defun ir2-convert-closure (ref ir2-block fun res)
+ (declare (type ref ref) (type ir2-block ir2-block)
+ (type functional fun) (type tn res))
+
+ (unless (leaf-info fun)
+ (setf (leaf-info fun)
+ (make-entry-info :name (functional-debug-name fun))))
+ (let ((entry (make-load-time-constant-tn :entry fun))
+ (closure (etypecase fun
(clambda
- (physenv-closure (get-lambda-physenv leaf)))
+
+ ;; This assertion was sort of an experiment. It
+ ;; would be nice and sane and easier to understand
+ ;; things if it were *always* true, but
+ ;; experimentally I observe that it's only
+ ;; *almost* always true. -- WHN 2001-01-02
+ #+nil
+ (aver (eql (lambda-component fun)
+ (block-component (ir2-block-block ir2-block))))
+
+ ;; Check for some weirdness which came up in bug
+ ;; 138, 2002-01-02.
+ ;;
+ ;; The MAKE-LOAD-TIME-CONSTANT-TN call above puts
+ ;; an :ENTRY record into the
+ ;; IR2-COMPONENT-CONSTANTS table. The
+ ;; dump-a-COMPONENT code
+ ;; * treats every HANDLEless :ENTRY record into a
+ ;; patch, and
+ ;; * expects every patch to correspond to an
+ ;; IR2-COMPONENT-ENTRIES record.
+ ;; The IR2-COMPONENT-ENTRIES records are set by
+ ;; ENTRY-ANALYZE walking over COMPONENT-LAMBDAS.
+ ;; Bug 138b arose because there was a HANDLEless
+ ;; :ENTRY record which didn't correspond to an
+ ;; IR2-COMPONENT-ENTRIES record. That problem is
+ ;; hard to debug when it's caught at dump time, so
+ ;; this assertion tries to catch it here.
+ (aver (member fun
+ (component-lambdas (lambda-component fun))))
+
+ ;; another bug-138-related issue: COMPONENT-NEW-FUNS
+ ;; is an IR1 temporary, and now that we're doing IR2
+ ;; it should've been completely flushed (but wasn't).
+ (aver (null (component-new-funs (lambda-component fun))))
+
+ (physenv-closure (get-lambda-physenv fun)))
(functional
- (aver (eq (functional-kind leaf) :toplevel-xep))
+ (aver (eq (functional-kind fun) :toplevel-xep))
nil))))
+
(cond (closure
- (let ((this-env (node-physenv node)))
- (vop make-closure node block entry (length closure) res)
+ (let ((this-env (node-physenv ref)))
+ (vop make-closure ref ir2-block entry (length closure) res)
(loop for what in closure and n from 0 do
(unless (and (lambda-var-p what)
(null (leaf-refs what)))
- (vop closure-init node block
+ (vop closure-init ref ir2-block
res
(find-in-physenv what this-env)
n)))))
(t
- (emit-move node block entry res))))
+ (emit-move ref ir2-block entry res))))
(values))
;;; Convert a SET node. If the node's CONT is annotated, then we also
(multiple-value-bind (check types) (continuation-check-types cont)
(aver (eq check :simple))
(let ((ntypes (length types)))
- (mapcar #'(lambda (from to-type assertion)
- (let ((temp (make-normal-tn to-type)))
- (if assertion
- (emit-type-check node block from temp assertion)
- (emit-move node block from temp))
- temp))
+ (mapcar (lambda (from to-type assertion)
+ (let ((temp (make-normal-tn to-type)))
+ (if assertion
+ (emit-type-check node block from temp assertion)
+ (emit-move node block from temp))
+ temp))
locs ptypes
(if (< ntypes nlocs)
(append types (make-list (- nlocs ntypes)
:initial-element nil))
types))))
- (mapcar #'(lambda (from to-type)
- (if (eq (tn-primitive-type from) to-type)
- from
- (let ((temp (make-normal-tn to-type)))
- (emit-move node block from temp)
- temp)))
+ (mapcar (lambda (from to-type)
+ (if (eq (tn-primitive-type from) to-type)
+ from
+ (let ((temp (make-normal-tn to-type)))
+ (emit-move node block from temp)
+ temp)))
locs
ptypes))))
\f
(unless (eq (tn-primitive-type (car loc)) (car type))
(return nil))))
locs
- (mapcar #'(lambda (loc type)
- (if (eq (tn-primitive-type loc) type)
- loc
- (make-normal-tn type)))
+ (mapcar (lambda (loc type)
+ (if (eq (tn-primitive-type loc) type)
+ loc
+ (make-normal-tn type)))
(if (< nlocs ntypes)
(append locs
(mapcar #'make-normal-tn
(declare (type node node) (type ir2-block block) (list src dest))
(let ((nsrc (length src))
(ndest (length dest)))
- (mapc #'(lambda (from to)
- (unless (eq from to)
- (emit-move node block from to)))
+ (mapc (lambda (from to)
+ (unless (eq from to)
+ (emit-move node block from to)))
(if (> ndest nsrc)
(append src (make-list (- ndest nsrc)
:initial-element (emit-constant nil)))
;;; this.
(defun ir2-convert-let (node block fun)
(declare (type combination node) (type ir2-block block) (type clambda fun))
- (mapc #'(lambda (var arg)
- (when arg
- (let ((src (continuation-tn node block arg))
- (dest (leaf-info var)))
- (if (lambda-var-indirect var)
- (do-make-value-cell node block src dest)
- (emit-move node block src dest)))))
+ (mapc (lambda (var arg)
+ (when arg
+ (let ((src (continuation-tn node block arg))
+ (dest (leaf-info var)))
+ (if (lambda-var-indirect var)
+ (do-make-value-cell node block src dest)
+ (emit-move node block src dest)))))
(lambda-vars fun) (basic-combination-args node))
(values))
(type (or tn null) old-fp))
(let* ((called-env (physenv-info (lambda-physenv fun)))
(this-1env (node-physenv node))
- (actuals (mapcar #'(lambda (x)
- (when x
- (continuation-tn node block x)))
- (combination-args node))))
+ (actuals (mapcar (lambda (x)
+ (when x
+ (continuation-tn node block x)))
+ (combination-args node))))
(collect ((temps)
(locs))
(dolist (var (lambda-vars fun))
(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)))
(multiple-value-bind (temps locs)
(emit-psetq-moves node block fun (ir2-physenv-old-fp this-env))
- (mapc #'(lambda (temp loc)
- (emit-move node block temp loc))
+ (mapc (lambda (temp loc)
+ (emit-move node block temp loc))
temps locs))
(emit-move node block
(declare (type combination node) (type ir2-block block) (type clambda fun))
(multiple-value-bind (temps locs) (emit-psetq-moves node block fun nil)
- (mapc #'(lambda (temp loc)
- (emit-move node block temp loc))
+ (mapc (lambda (temp loc)
+ (emit-move node block temp loc))
temps locs))
(values))
;;; -- Known to be a function, no check needed: return the
;;; continuation loc.
;;; -- Not known what it is.
-(defun function-continuation-tn (node block cont)
+(defun fun-continuation-tn (node block cont)
(declare (type continuation cont))
(let ((2cont (continuation-info cont)))
(if (eq (ir2-continuation-kind 2cont) :delayed)
(return-pc (ir2-physenv-return-pc env)))
(multiple-value-bind (fun-tn named)
- (function-continuation-tn node block (basic-combination-fun node))
+ (fun-continuation-tn node block (basic-combination-fun node))
(if named
(vop* tail-call-named node block
(fun-tn old-fp return-pc pass-refs)
(loc-refs (reference-tn-list locs t))
(nvals (length locs)))
(multiple-value-bind (fun-tn named)
- (function-continuation-tn node block (basic-combination-fun node))
+ (fun-continuation-tn node block (basic-combination-fun node))
(if named
(vop* call-named node block (fp fun-tn args) (loc-refs)
arg-locs nargs nvals)
(locs (ir2-continuation-locs (continuation-info cont)))
(loc-refs (reference-tn-list locs t)))
(multiple-value-bind (fun-tn named)
- (function-continuation-tn node block (basic-combination-fun node))
+ (fun-continuation-tn node block (basic-combination-fun node))
(if named
(vop* multiple-call-named node block (fp fun-tn args) (loc-refs)
arg-locs nargs)
(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)))
(aver (member (functional-kind fun)
'(nil :external :optional :toplevel :cleanup)))
- (when (external-entry-point-p fun)
+ (when (xep-p fun)
(init-xep-environment node block fun)
#!+sb-dyncount
(when *collect-dynamic-statistics*
(returns (tail-set-info (lambda-tail-set fun))))
(cond
((and (eq (return-info-kind returns) :fixed)
- (not (external-entry-point-p fun)))
+ (not (xep-p fun)))
(let ((locs (continuation-tns node block cont
(return-info-types returns))))
(vop* known-return node block
(cont-locs (continuation-tns node block cont types))
(nvals (length cont-locs))
(locs (make-standard-value-tns nvals)))
- (mapc #'(lambda (val loc)
- (emit-move node block val loc))
+ (mapc (lambda (val loc)
+ (emit-move node block val loc))
cont-locs
locs)
(if (= nvals 1)
(fun (ref-leaf (continuation-use (basic-combination-fun node))))
(vars (lambda-vars fun)))
(aver (eq (functional-kind fun) :mv-let))
- (mapc #'(lambda (src var)
- (when (leaf-refs var)
- (let ((dest (leaf-info var)))
- (if (lambda-var-indirect var)
- (do-make-value-cell node block src dest)
- (emit-move node block src dest)))))
+ (mapc (lambda (src var)
+ (when (leaf-refs var)
+ (let ((dest (leaf-info var)))
+ (if (lambda-var-indirect var)
+ (do-make-value-cell node block src dest)
+ (emit-move node block src dest)))))
(continuation-tns node block cont
- (mapcar #'(lambda (x)
- (primitive-type (leaf-type x)))
+ (mapcar (lambda (x)
+ (primitive-type (leaf-type x)))
vars))
vars))
(values))
(cont (node-cont node))
(2cont (continuation-info cont)))
(multiple-value-bind (fun named)
- (function-continuation-tn node block (basic-combination-fun node))
+ (fun-continuation-tn node block (basic-combination-fun node))
(aver (and (not named)
(eq (ir2-continuation-kind start-cont) :unknown)))
(cond
;;; Deliver the values TNs to CONT using MOVE-CONTINUATION-RESULT.
(defoptimizer (values ir2-convert) ((&rest values) node block)
- (let ((tns (mapcar #'(lambda (x)
- (continuation-tn node block x))
+ (let ((tns (mapcar (lambda (x)
+ (continuation-tn node block x))
values)))
(move-continuation-result node block tns (node-cont node))))
(once-only ((n-save-bs '(%primitive current-binding-pointer)))
`(unwind-protect
(progn
- (mapc #'(lambda (var val)
- (%primitive bind val var))
+ (mapc (lambda (var val)
+ (%primitive bind val var))
,vars
,vals)
,@body)
(ir2-continuation-locs (continuation-info (second args)))
nil))
(nil)))
-
(move-continuation-result node block () (node-cont node))
(values))
(when *collect-dynamic-statistics*
(let ((first-node (continuation-next (block-start block))))
(unless (or (and (bind-p first-node)
- (external-entry-point-p
- (bind-lambda first-node)))
+ (xep-p (bind-lambda first-node)))
(eq (continuation-fun-name
(node-cont first-node))
'%nlx-entry))
(unless (or (node-tail-p last)
(info :function :info name)
(policy last (zerop safety)))
- (vop nil-function-returned-error last 2block
+ (vop nil-fun-returned-error last 2block
(if name
(emit-constant name)
(multiple-value-bind (tn named)
- (function-continuation-tn last 2block fun)
+ (fun-continuation-tn last 2block fun)
(aver (not named))
tn)))))))
((not (eq (ir2-block-next 2block) (block-info target)))
(:full
(ir2-convert-full-call node 2block))
(t
- (let ((fun (function-info-ir2-convert kind)))
+ (let ((fun (fun-info-ir2-convert kind)))
(cond (fun
(funcall fun node 2block))
((eq (basic-combination-info node) :full)
projects / sbcl.git / blobdiff