X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Flocall.lisp;h=855a877c83cf7fa9a9c2e2ce65a9971916578e3d;hb=f9d6d21a7f54638292214ceb9886edc03b99d545;hp=b8f469757466acf37883a6c42ba3f416053ccb3c;hpb=7fd2eb4b1bc68e8aaec233c4a39bdfc40225bda2;p=sbcl.git diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index b8f4697..855a877 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -67,11 +67,11 @@ (let ((call-set (lambda-tail-set (node-home-lambda call))) (fun-set (lambda-tail-set new-fun))) (unless (eq call-set fun-set) - (let ((funs (tail-set-functions fun-set))) + (let ((funs (tail-set-funs fun-set))) (dolist (fun funs) (setf (lambda-tail-set fun) call-set)) - (setf (tail-set-functions call-set) - (nconc (tail-set-functions call-set) funs))) + (setf (tail-set-funs call-set) + (nconc (tail-set-funs call-set) funs))) (reoptimize-continuation (return-result return)) t))))) @@ -91,7 +91,7 @@ (declare (type ref ref) (type combination call) (type clambda fun)) (propagate-to-args call fun) (setf (basic-combination-kind call) :local) - (pushnew fun (lambda-calls (node-home-lambda call))) + (pushnew fun (lambda-calls-or-closes (node-home-lambda call))) (merge-tail-sets call fun) (change-ref-leaf ref fun) (values)) @@ -124,7 +124,7 @@ ;;; FUN will be verified. Since nothing is known about the type of the ;;; XEP arg vars, type checks will be emitted when the XEP's arg vars ;;; are passed to the actual function. -(defun make-xep-lambda (fun) +(defun make-xep-lambda-expression (fun) (declare (type functional fun)) (etypecase fun (clambda @@ -177,22 +177,25 @@ ;;; discover an XEP after the initial local call analyze pass. (defun make-external-entry-point (fun) (declare (type functional fun)) - (aver (not (functional-entry-function fun))) + (aver (not (functional-entry-fun fun))) (with-ir1-environment (lambda-bind (main-entry fun)) - (let ((res (ir1-convert-lambda (make-xep-lambda fun)))) + (let ((res (ir1-convert-lambda (make-xep-lambda-expression fun) + :debug-name (debug-namify + "XEP for ~A" + (leaf-debug-name fun))))) (setf (functional-kind res) :external (leaf-ever-used res) t - (functional-entry-function res) fun - (functional-entry-function fun) res + (functional-entry-fun res) fun + (functional-entry-fun fun) res (component-reanalyze *current-component*) t (component-reoptimize *current-component*) t) (etypecase fun - (clambda (local-call-analyze-1 fun)) + (clambda (locall-analyze-fun-1 fun)) (optional-dispatch (dolist (ep (optional-dispatch-entry-points fun)) - (local-call-analyze-1 ep)) + (locall-analyze-fun-1 ep)) (when (optional-dispatch-more-entry fun) - (local-call-analyze-1 (optional-dispatch-more-entry fun))))) + (locall-analyze-fun-1 (optional-dispatch-more-entry fun))))) res))) ;;; Notice a REF that is not in a local-call context. If the REF is @@ -206,7 +209,7 @@ (let ((fun (ref-leaf ref))) (unless (or (external-entry-point-p fun) (member (functional-kind fun) '(:escape :cleanup))) - (change-ref-leaf ref (or (functional-entry-function fun) + (change-ref-leaf ref (or (functional-entry-fun fun) (make-external-entry-point fun)))))) ;;; Attempt to convert all references to FUN to local calls. The @@ -220,10 +223,10 @@ ;;; function as an entry-point, creating a new XEP if necessary. We ;;; don't try to convert calls that are in error (:ERROR kind.) ;;; -;;; This is broken off from LOCAL-CALL-ANALYZE so that people can -;;; force analysis of newly introduced calls. Note that we don't do -;;; LET conversion here. -(defun local-call-analyze-1 (fun) +;;; This is broken off from LOCALL-ANALYZE-COMPONENT so that people +;;; can force analysis of newly introduced calls. Note that we don't +;;; do LET conversion here. +(defun locall-analyze-fun-1 (fun) (declare (type functional fun)) (let ((refs (leaf-refs fun)) (first-time t)) @@ -244,57 +247,76 @@ (values)) -;;; We examine all NEW-FUNCTIONS in component, attempting to convert -;;; calls into local calls when it is legal. We also attempt to -;;; convert each LAMBDA to a LET. LET conversion is also triggered by -;;; deletion of a function reference, but functions that start out -;;; eligible for conversion must be noticed sometime. +;;; We examine all NEW-FUNS in COMPONENT, attempting to convert calls +;;; into local calls when it is legal. We also attempt to convert each +;;; LAMBDA to a LET. LET conversion is also triggered by deletion of a +;;; function reference, but functions that start out eligible for +;;; conversion must be noticed sometime. ;;; ;;; Note that there is a lot of action going on behind the scenes ;;; here, triggered by reference deletion. In particular, the -;;; COMPONENT-LAMBDAS are being hacked to remove newly deleted and let +;;; COMPONENT-LAMBDAS are being hacked to remove newly deleted and LET ;;; converted LAMBDAs, so it is important that the LAMBDA is added to -;;; the COMPONENT-LAMBDAS when it is. Also, the -;;; COMPONENT-NEW-FUNCTIONS may contain all sorts of drivel, since it -;;; is not updated when we delete functions, etc. Only -;;; COMPONENT-LAMBDAS is updated. +;;; the COMPONENT-LAMBDAS when it is. Also, the COMPONENT-NEW-FUNS may +;;; contain all sorts of drivel, since it is not updated when we +;;; delete functions, etc. Only COMPONENT-LAMBDAS is updated. ;;; -;;; COMPONENT-REANALYZE-FUNCTIONS is treated similarly to -;;; NEW-FUNCTIONS, but we don't add lambdas to the LAMBDAS. -(defun local-call-analyze (component) +;;; COMPONENT-REANALYZE-FUNS is treated similarly to +;;; NEW-FUNS, but we don't add lambdas to the LAMBDAS. +(defun locall-analyze-component (component) (declare (type component component)) (loop - (let* ((new (pop (component-new-functions component))) - (fun (or new (pop (component-reanalyze-functions component))))) + (let* ((new-fun (pop (component-new-funs component))) + (fun (or new-fun (pop (component-reanalyze-funs component))))) (unless fun (return)) (let ((kind (functional-kind fun))) (cond ((member kind '(:deleted :let :mv-let :assignment))) ((and (null (leaf-refs fun)) (eq kind nil) - (not (functional-entry-function fun))) + (not (functional-entry-fun fun))) (delete-functional fun)) (t - (when (and new (lambda-p fun)) - (push fun (component-lambdas component))) - (local-call-analyze-1 fun) + ;; Fix/check FUN's relationship to COMPONENT-LAMDBAS. + (cond ((not (lambda-p fun)) + ;; Since FUN's not a LAMBDA, this doesn't apply: no-op. + (values)) + (new-fun ; FUN came from NEW-FUNS, hence is new. + ;; FUN becomes part of COMPONENT-LAMBDAS now. + (aver (not (member fun (component-lambdas component)))) + (push fun (component-lambdas component))) + ((eql (lambda-inlinep fun) :inline) + ;; FUNs marked :INLINE are sometimes in + ;; COMPONENT-LAMBDAS and sometimes not. I (WHN + ;; 2002-01-01) haven't figured this one out yet, + ;; so don't assert anything. + ;; + ;; (One possibility: LAMBDAs to represent the + ;; inline expansions of things which are defined + ;; elsewhere might not be in COMPONENT-LAMBDAS, + ;; which LAMBDAs to represent the inline + ;; expansions of local functions might in + ;; COMPONENT-LAMBDAS?) + (values)) + (t ; FUN's old. + ;; FUN should be in COMPONENT-LAMBDAS already. + (aver (member fun (component-lambdas component))))) + (locall-analyze-fun-1 fun) (when (lambda-p fun) (maybe-let-convert fun))))))) - (values)) -(defun local-call-analyze-until-done (clambdas) +(defun locall-analyze-clambdas-until-done (clambdas) (loop - (/show "at head of LOCAL-CALL-ANALYZE-UNTIL-DONE loop") (let ((did-something nil)) (dolist (clambda clambdas) - (let* ((component (block-component (node-block (lambda-bind clambda)))) + (let* ((component (lambda-component clambda)) (*all-components* (list component))) ;; The original CMU CL code seemed to implicitly assume that ;; COMPONENT is the only one here. Let's make that explicit. (aver (= 1 (length (functional-components clambda)))) (aver (eql component (first (functional-components clambda)))) - (when (component-new-functions component) + (when (component-new-funs component) (setf did-something t) - (local-call-analyze component)))) + (locall-analyze-component component)))) (unless did-something (return)))) (values)) @@ -313,8 +335,10 @@ (won nil) (res (catch 'local-call-lossage (prog1 - (ir1-convert-lambda (functional-inline-expansion - fun)) + (ir1-convert-lambda + (functional-inline-expansion fun) + :debug-name (debug-namify "local inline ~A" + (leaf-debug-name fun))) (setq won t))))) (cond (won (change-ref-leaf ref res) @@ -322,9 +346,9 @@ (t (let ((*compiler-error-context* call)) (compiler-note "couldn't inline expand because expansion ~ - calls this let-converted local function:~ + calls this LET-converted local function:~ ~% ~S" - (leaf-name res))) + (leaf-debug-name res))) fun)))) fun)) @@ -357,14 +381,14 @@ (block-delete-p block) (eq (functional-kind (block-home-lambda block)) :deleted) (member (functional-kind original-fun) - '(:top-level-xep :deleted)) + '(:toplevel-xep :deleted)) (not (or (eq (component-kind component) :initial) (eq (block-component (node-block (lambda-bind (main-entry original-fun)))) component)))) (let ((fun (if (external-entry-point-p original-fun) - (functional-entry-function original-fun) + (functional-entry-fun original-fun) original-fun)) (*compiler-error-context* call)) @@ -401,12 +425,12 @@ (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-function fun)) + (not (functional-entry-fun fun)) (= (length (leaf-refs fun)) 1) (= (length (basic-combination-args call)) 1)) (let ((ep (car (last (optional-dispatch-entry-points fun))))) (setf (basic-combination-kind call) :local) - (pushnew ep (lambda-calls (node-home-lambda call))) + (pushnew ep (lambda-calls-or-closes (node-home-lambda call))) (merge-tail-sets call ep) (change-ref-leaf ref ep) @@ -449,7 +473,7 @@ call-args nargs) (setf (basic-combination-kind call) :error))))) -;;;; optional, more and keyword calls +;;;; &OPTIONAL, &MORE and &KEYWORD calls ;;; This is similar to CONVERT-LAMBDA-CALL, but deals with ;;; OPTIONAL-DISPATCHes. If only fixed args are supplied, then convert @@ -484,17 +508,17 @@ (setf (basic-combination-kind call) :error)))) (values)) -;;; This function is used to convert a call to an entry point when complex -;;; transformations need to be done on the original arguments. Entry is the -;;; entry point function that we are calling. Vars is a list of variable names -;;; which are bound to the original call arguments. Ignores is the subset of -;;; Vars which are ignored. Args is the list of arguments to the entry point -;;; function. +;;; This function is used to convert a call to an entry point when +;;; complex transformations need to be done on the original arguments. +;;; ENTRY is the entry point function that we are calling. VARS is a +;;; list of variable names which are bound to the original call +;;; arguments. IGNORES is the subset of VARS which are ignored. ARGS +;;; is the list of arguments to the entry point function. ;;; -;;; In order to avoid gruesome graph grovelling, we introduce a new function -;;; that rearranges the arguments and calls the entry point. We analyze the -;;; new function and the entry point immediately so that everything gets -;;; converted during the single pass. +;;; In order to avoid gruesome graph grovelling, we introduce a new +;;; function that rearranges the arguments and calls the entry point. +;;; We analyze the new function and the entry point immediately so +;;; that everything gets converted during the single pass. (defun convert-hairy-fun-entry (ref call entry vars ignores args) (declare (list vars ignores args) (type ref ref) (type combination call) (type clambda entry)) @@ -503,7 +527,10 @@ (ir1-convert-lambda `(lambda ,vars (declare (ignorable . ,ignores)) - (%funcall ,entry . ,args)))))) + (%funcall ,entry . ,args)) + :debug-name (debug-namify "hairy fun entry ~S" + (continuation-fun-name + (basic-combination-fun call))))))) (convert-call ref call new-fun) (dolist (ref (leaf-refs entry)) (convert-call-if-possible ref (continuation-dest (node-cont ref)))))) @@ -628,11 +655,11 @@ ;;;; corresponding combination node, making the control transfer ;;;; explicit and allowing LETs to be mashed together into a single ;;;; block. The value of the LET is delivered directly to the -;;;; original continuation for the call,eliminating the need to +;;;; original continuation for the call, eliminating the need to ;;;; propagate information from the dummy result continuation. ;;;; -- As far as IR1 optimization is concerned, it is interesting in ;;;; that there is only one expression that the variable can be bound -;;;; to, and this is easily substitited for. +;;;; to, and this is easily substituted for. ;;;; -- LETs are interesting to environment analysis and to the back ;;;; end because in most ways a LET can be considered to be "the ;;;; same function" as its home function. @@ -641,23 +668,23 @@ ;;;; control transfer, cleanup code must be emitted to remove ;;;; dynamic bindings that are no longer in effect. -;;; Set up the control transfer to the called lambda. We split the -;;; call block immediately after the call, and link the head of FUN to -;;; the call block. The successor block after splitting (where we -;;; return to) is returned. +;;; Set up the control transfer to the called CLAMBDA. We split the +;;; call block immediately after the call, and link the head of +;;; CLAMBDA to the call block. The successor block after splitting +;;; (where we return to) is returned. ;;; ;;; If the lambda is is a different component than the call, then we ;;; call JOIN-COMPONENTS. This only happens in block compilation ;;; before FIND-INITIAL-DFO. -(defun insert-let-body (fun call) - (declare (type clambda fun) (type basic-combination call)) +(defun insert-let-body (clambda call) + (declare (type clambda clambda) (type basic-combination call)) (let* ((call-block (node-block call)) - (bind-block (node-block (lambda-bind fun))) + (bind-block (node-block (lambda-bind clambda))) (component (block-component call-block))) - (let ((fun-component (block-component bind-block))) - (unless (eq fun-component component) + (let ((clambda-component (block-component bind-block))) + (unless (eq clambda-component component) (aver (eq (component-kind component) :initial)) - (join-components component fun-component))) + (join-components component clambda-component))) (let ((*current-component* component)) (node-ends-block call)) @@ -670,24 +697,24 @@ (link-blocks call-block bind-block) next-block))) -;;; Remove FUN from the tail set of anything it used to be in the -;;; same set as; but leave FUN with a valid tail set value of +;;; Remove CLAMBDA from the tail set of anything it used to be in the +;;; same set as; but leave CLAMBDA with a valid tail set value of ;;; its own, for the benefit of code which might try to pull ;;; something out of it (e.g. return type). -(defun depart-from-tail-set (fun) +(defun depart-from-tail-set (clambda) ;; Until sbcl-0.pre7.37.flaky5.2, we did - ;; (LET ((TAILS (LAMBDA-TAIL-SET FUN))) - ;; (SETF (TAIL-SET-FUNCTIONS TAILS) - ;; (DELETE FUN (TAIL-SET-FUNCTIONS TAILS)))) - ;; (SETF (LAMBDA-TAIL-SET FUN) NIL) + ;; (LET ((TAILS (LAMBDA-TAIL-SET CLAMBDA))) + ;; (SETF (TAIL-SET-FUNS TAILS) + ;; (DELETE CLAMBDA (TAIL-SET-FUNS TAILS)))) + ;; (SETF (LAMBDA-TAIL-SET CLAMBDA) NIL) ;; here. Apparently the idea behind the (SETF .. NIL) was that since - ;; TAIL-SET-FUNCTIONS no longer thinks we're in the tail set, it's + ;; TAIL-SET-FUNS no longer thinks we're in the tail set, it's ;; inconsistent, and perhaps unsafe, for us to think we're in the ;; tail set. Unfortunately.. ;; ;; The (SETF .. NIL) caused problems in sbcl-0.pre7.37.flaky5.2 when ;; I was trying to get Python to emit :EXTERNAL LAMBDAs directly - ;; (instead of only being able to emit funny little :TOP-LEVEL stubs + ;; (instead of only being able to emit funny little :TOPLEVEL stubs ;; which you called in order to get the address of an external LAMBDA): ;; the external function was defined in terms of internal function, ;; which was LET-converted, and then things blew up downstream when @@ -695,10 +722,10 @@ ;; the now-NILed-out TAIL-SET. So.. ;; ;; To deal with this problem, we no longer NIL out - ;; (LAMBDA-TAIL-SET FUN) here. Instead: - ;; * If we're the only function in TAIL-SET-FUNCTIONS, it should + ;; (LAMBDA-TAIL-SET CLAMBDA) here. Instead: + ;; * If we're the only function in TAIL-SET-FUNS, it should ;; be safe to leave ourself linked to it, and it to you. - ;; * If there are other functions in TAIL-SET-FUNCTIONS, then we're + ;; * If there are other functions in TAIL-SET-FUNS, then we're ;; afraid of future optimizations on those functions causing ;; the TAIL-SET object no longer to be valid to describe our ;; return value. Thus, we delete ourselves from that object; @@ -706,62 +733,76 @@ ;; one, for ourselves, for the use of later code (e.g. ;; FINALIZE-XEP-DEFINITION) which might want to ;; know about our return type. - (let* ((old-tail-set (lambda-tail-set fun)) - (old-tail-set-functions (tail-set-functions old-tail-set))) - (unless (= 1 (length old-tail-set-functions)) - (setf (tail-set-functions old-tail-set) - (delete fun old-tail-set-functions)) + (let* ((old-tail-set (lambda-tail-set clambda)) + (old-tail-set-funs (tail-set-funs old-tail-set))) + (unless (= 1 (length old-tail-set-funs)) + (setf (tail-set-funs old-tail-set) + (delete clambda old-tail-set-funs)) (let ((new-tail-set (copy-tail-set old-tail-set))) - (setf (lambda-tail-set fun) new-tail-set - (tail-set-functions new-tail-set) (list fun))))) + (setf (lambda-tail-set clambda) new-tail-set + (tail-set-funs new-tail-set) (list clambda))))) ;; The documentation on TAIL-SET-INFO doesn't tell whether it could ;; remain valid in this case, so we nuke it on the theory that ;; missing information tends to be less dangerous than incorrect ;; information. - (setf (tail-set-info (lambda-tail-set fun)) nil)) + (setf (tail-set-info (lambda-tail-set clambda)) nil)) -;;; Handle the environment semantics of LET conversion. We add the -;;; lambda and its LETs to LETs for the CALL's home function. We merge -;;; the calls for FUN with the calls for the home function, removing -;;; FUN in the process. We also merge the ENTRIES. +;;; Handle the environment semantics of LET conversion. We add CLAMBDA +;;; and its LETs to LETs for the CALL's home function. We merge the +;;; calls for CLAMBDA with the calls for the home function, removing +;;; CLAMBDA in the process. We also merge the ENTRIES. ;;; ;;; We also unlink the function head from the component head and set ;;; COMPONENT-REANALYZE to true to indicate that the DFO should be ;;; recomputed. -(defun merge-lets (fun call) +(defun merge-lets (clambda call) - (declare (type clambda fun) (type basic-combination call)) + (declare (type clambda clambda) (type basic-combination call)) (let ((component (block-component (node-block call)))) - (unlink-blocks (component-head component) (node-block (lambda-bind fun))) + (unlink-blocks (component-head component) (lambda-block clambda)) (setf (component-lambdas component) - (delete fun (component-lambdas component))) + (delete clambda (component-lambdas component))) (setf (component-reanalyze component) t)) - (setf (lambda-call-lexenv fun) (node-lexenv call)) + (setf (lambda-call-lexenv clambda) (node-lexenv call)) - (depart-from-tail-set fun) + (depart-from-tail-set clambda) (let* ((home (node-home-lambda call)) (home-env (lambda-physenv home))) - (push fun (lambda-lets home)) - (setf (lambda-home fun) home) - (setf (lambda-physenv fun) home-env) - (let ((lets (lambda-lets fun))) + ;; CLAMBDA belongs to HOME now. + (push clambda (lambda-lets home)) + (setf (lambda-home clambda) home) + (setf (lambda-physenv clambda) home-env) + + ;; All of CLAMBDA's LETs belong to HOME now. + (let ((lets (lambda-lets clambda))) (dolist (let lets) (setf (lambda-home let) home) (setf (lambda-physenv let) home-env)) + (setf (lambda-lets home) (nconc lets (lambda-lets home)))) + ;; CLAMBDA no longer has an independent existence as an entity + ;; which has LETs. + (setf (lambda-lets clambda) nil) - (setf (lambda-lets home) (nconc lets (lambda-lets home))) - (setf (lambda-lets fun) ())) - - (setf (lambda-calls home) - (delete fun (nunion (lambda-calls fun) (lambda-calls home)))) - (setf (lambda-calls fun) ()) + ;; HOME no longer calls CLAMBDA, and owns all of CLAMBDA's old + ;; DFO dependencies. + (setf (lambda-calls-or-closes home) + (delete clambda + (nunion (lambda-calls-or-closes clambda) + (lambda-calls-or-closes home)))) + ;; CLAMBDA no longer has an independent existence as an entity + ;; which calls things or has DFO dependencies. + (setf (lambda-calls-or-closes clambda) nil) + ;; All of CLAMBDA's ENTRIES belong to HOME now. (setf (lambda-entries home) - (nconc (lambda-entries fun) (lambda-entries home))) - (setf (lambda-entries fun) ())) + (nconc (lambda-entries clambda) + (lambda-entries home))) + ;; CLAMBDA no longer has an independent existence as an entity + ;; with ENTRIES. + (setf (lambda-entries clambda) nil)) (values)) @@ -817,29 +858,31 @@ ;;; NEXT-BLOCK (FUN's return point.) We can't do this by DO-USES on ;;; the RETURN-RESULT, because the return might have been deleted (if ;;; all calls were TR.) -;;; -;;; The called function might be an assignment in the case where we -;;; are currently converting that function. In steady-state, -;;; assignments never appear in the lambda-calls. (defun unconvert-tail-calls (fun call next-block) - (dolist (called (lambda-calls fun)) - (dolist (ref (leaf-refs called)) - (let ((this-call (continuation-dest (node-cont ref)))) - (when (and (node-tail-p this-call) - (eq (node-home-lambda this-call) fun)) - (setf (node-tail-p this-call) nil) - (ecase (functional-kind called) - ((nil :cleanup :optional) - (let ((block (node-block this-call)) - (cont (node-cont call))) - (ensure-block-start cont) - (unlink-blocks block (first (block-succ block))) - (link-blocks block next-block) - (delete-continuation-use this-call) - (add-continuation-use this-call cont))) - (:deleted) - (:assignment - (aver (eq called fun)))))))) + (dolist (called (lambda-calls-or-closes fun)) + (when (lambda-p called) + (dolist (ref (leaf-refs called)) + (let ((this-call (continuation-dest (node-cont ref)))) + (when (and this-call + (node-tail-p this-call) + (eq (node-home-lambda this-call) fun)) + (setf (node-tail-p this-call) nil) + (ecase (functional-kind called) + ((nil :cleanup :optional) + (let ((block (node-block this-call)) + (cont (node-cont call))) + (ensure-block-start cont) + (unlink-blocks block (first (block-succ block))) + (link-blocks block next-block) + (delete-continuation-use this-call) + (add-continuation-use this-call cont))) + (:deleted) + ;; The called function might be an assignment in the + ;; case where we are currently converting that function. + ;; In steady-state, assignments never appear as a called + ;; function. + (:assignment + (aver (eq called fun))))))))) (values)) ;;; Deal with returning from a LET or assignment that we are @@ -886,11 +929,11 @@ (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-CONTINUATION on the args and -;;; Cont so that LET-specific IR1 optimizations get a chance. We blow +;;; work. We change the CALL's CONT to be the continuation heading the +;;; BIND block, and also do REOPTIMIZE-CONTINUATION on the args and +;;; CONT so that LET-specific IR1 optimizations get a chance. We blow ;;; away any entry for the function in *FREE-FUNCTIONS* so that nobody -;;; will create new reference to it. +;;; 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) @@ -899,7 +942,7 @@ (move-return-stuff fun call next-block) (merge-lets fun call))) -;;; Reoptimize all of Call's args and its result. +;;; Reoptimize all of CALL's args and its result. (defun reoptimize-call (call) (declare (type basic-combination call)) (dolist (arg (basic-combination-args call)) @@ -910,18 +953,16 @@ ;;; We also don't convert calls to named functions which appear in the ;;; initial component, delaying this until optimization. This -;;; minimizes the likelyhood that we well let-convert a function which -;;; may have references added due to later local inline expansion +;;; minimizes the likelihood that we will LET-convert a function which +;;; may have references added due to later local inline expansion. (defun ok-initial-convert-p (fun) - (not (and (leaf-name fun) - (eq (component-kind - (block-component - (node-block (lambda-bind fun)))) + (not (and (leaf-has-source-name-p fun) + (eq (component-kind (lambda-component fun)) :initial)))) ;;; This function is called when there is some reason to believe that -;;; the lambda Fun might be converted into a let. This is done after -;;; local call analysis, and also when a reference is deleted. We only +;;; CLAMBDA might be converted into a LET. This is done after local +;;; call analysis, and also when a reference is deleted. We only ;;; convert to a let when the function is a normal local function, has ;;; no XEP, and is referenced in exactly one local call. Conversion is ;;; also inhibited if the only reference is in a block about to be @@ -938,13 +979,13 @@ ;;; We don't attempt to convert calls to functions that have an XEP, ;;; since we might be embarrassed later when we want to convert a ;;; newly discovered local call. Also, see OK-INITIAL-CONVERT-P. -(defun maybe-let-convert (fun) - (declare (type clambda fun)) - (let ((refs (leaf-refs fun))) +(defun maybe-let-convert (clambda) + (declare (type clambda clambda)) + (let ((refs (leaf-refs clambda))) (when (and refs (null (rest refs)) - (member (functional-kind fun) '(nil :assignment)) - (not (functional-entry-function fun))) + (member (functional-kind clambda) '(nil :assignment)) + (not (functional-entry-fun clambda))) (let* ((ref-cont (node-cont (first refs))) (dest (continuation-dest ref-cont))) (when (and dest @@ -952,14 +993,14 @@ (eq (basic-combination-fun dest) ref-cont) (eq (basic-combination-kind dest) :local) (not (block-delete-p (node-block dest))) - (cond ((ok-initial-convert-p fun) t) + (cond ((ok-initial-convert-p clambda) t) (t (reoptimize-continuation ref-cont) nil))) - (unless (eq (functional-kind fun) :assignment) - (let-convert fun dest)) + (unless (eq (functional-kind clambda) :assignment) + (let-convert clambda dest)) (reoptimize-call dest) - (setf (functional-kind fun) + (setf (functional-kind clambda) (if (mv-combination-p dest) :mv-let :let)))) t))) @@ -1008,7 +1049,7 @@ (fun (combination-lambda call))) (setf (node-tail-p call) t) (unlink-blocks block (first (block-succ block))) - (link-blocks block (node-block (lambda-bind fun))) + (link-blocks block (lambda-block fun)) (values t (maybe-convert-to-assignment fun)))))) ;;; This is called when we believe it might make sense to convert Fun @@ -1034,7 +1075,7 @@ (defun maybe-convert-to-assignment (fun) (declare (type clambda fun)) (when (and (not (functional-kind fun)) - (not (functional-entry-function fun))) + (not (functional-entry-fun fun))) (let ((non-tail nil) (call-fun nil)) (when (and (dolist (ref (leaf-refs fun) t)