X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Flocall.lisp;h=855a877c83cf7fa9a9c2e2ce65a9971916578e3d;hb=f9d6d21a7f54638292214ceb9886edc03b99d545;hp=d848bf6e91a00137027b17ce529502b79d5d39a2;hpb=a8fa26a6e9804d3548f5bca9361a91345a689099;p=sbcl.git diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index d848bf6..855a877 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -21,13 +21,14 @@ (in-package "SB!C") -;;; This function propagates information from the variables in the function -;;; Fun to the actual arguments in Call. This is also called by the VALUES IR1 -;;; optimizer when it sleazily converts MV-BINDs to LETs. +;;; This function propagates information from the variables in the +;;; function FUN to the actual arguments in CALL. This is also called +;;; by the VALUES IR1 optimizer when it sleazily converts MV-BINDs to +;;; LETs. ;;; -;;; We flush all arguments to Call that correspond to unreferenced variables -;;; in Fun. We leave NILs in the Combination-Args so that the remaining args -;;; still match up with their vars. +;;; We flush all arguments to CALL that correspond to unreferenced +;;; variables in FUN. We leave NILs in the COMBINATION-ARGS so that +;;; the remaining args still match up with their vars. ;;; ;;; We also apply the declared variable type assertion to the argument ;;; continuations. @@ -46,17 +47,19 @@ (values)) -;;; This function handles merging the tail sets if Call is potentially -;;; tail-recursive, and is a call to a function with a different TAIL-SET than -;;; Call's Fun. This must be called whenever we alter IR1 so as to place a -;;; local call in what might be a TR context. Note that any call which returns -;;; its value to a RETURN is considered potentially TR, since any implicit -;;; MV-PROG1 might be optimized away. -;;; -;;; We destructively modify the set for the calling function to represent both, -;;; and then change all the functions in callee's set to reference the first. -;;; If we do merge, we reoptimize the RETURN-RESULT continuation to cause -;;; IR1-OPTIMIZE-RETURN to recompute the tail set type. +;;; This function handles merging the tail sets if CALL is potentially +;;; tail-recursive, and is a call to a function with a different +;;; TAIL-SET than CALL's FUN. This must be called whenever we alter +;;; IR1 so as to place a local call in what might be a tail-recursive +;;; context. Note that any call which returns its value to a RETURN is +;;; considered potentially tail-recursive, since any implicit MV-PROG1 +;;; might be optimized away. +;;; +;;; We destructively modify the set for the calling function to +;;; represent both, and then change all the functions in callee's set +;;; to reference the first. If we do merge, we reoptimize the +;;; RETURN-RESULT continuation to cause IR1-OPTIMIZE-RETURN to +;;; recompute the tail set type. (defun merge-tail-sets (call &optional (new-fun (combination-lambda call))) (declare (type basic-combination call) (type clambda new-fun)) (let ((return (continuation-dest (node-cont call)))) @@ -64,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))))) @@ -88,17 +91,17 @@ (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)) ;;;; external entry point creation -;;; Return a Lambda form that can be used as the definition of the XEP +;;; Return a LAMBDA form that can be used as the definition of the XEP ;;; for FUN. ;;; -;;; If FUN is a lambda, then we check the number of arguments +;;; If FUN is a LAMBDA, then we check the number of arguments ;;; (conditional on policy) and call FUN with all the arguments. ;;; ;;; If FUN is an OPTIONAL-DISPATCH, then we dispatch off of the number @@ -106,7 +109,7 @@ ;;; calling the entry with the appropriate prefix of the passed ;;; arguments. ;;; -;;; If there is a more arg, then there are a couple of optimizations +;;; If there is a &MORE arg, then there are a couple of optimizations ;;; that we make (more for space than anything else): ;;; -- If MIN-ARGS is 0, then we make the more entry a T clause, since ;;; no argument count error is possible. @@ -118,10 +121,10 @@ ;;; compared to the cost of everything else going on. ;;; ;;; Note that if policy indicates it, argument type declarations in -;;; Fun will be verified. Since nothing is known about the type of the +;;; 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 @@ -130,7 +133,7 @@ (temps (make-gensym-list (length (lambda-vars fun))))) `(lambda (,n-supplied ,@temps) (declare (type index ,n-supplied)) - ,(if (policy nil (zerop safety)) + ,(if (policy *lexenv* (zerop safety)) `(declare (ignore ,n-supplied)) `(%verify-argument-count ,n-supplied ,nargs)) (%funcall ,fun ,@temps)))) @@ -168,47 +171,48 @@ ;;; then associate this lambda with FUN as its XEP. After the ;;; conversion, we iterate over the function's associated lambdas, ;;; redoing local call analysis so that the XEP calls will get -;;; converted. We also bind *LEXENV* to change the compilation policy -;;; over to the interface policy. +;;; converted. ;;; ;;; We set REANALYZE and REOPTIMIZE in the component, just in case we ;;; 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* ((*lexenv* (make-lexenv :policy (make-interface-policy *lexenv*))) - (res (ir1-convert-lambda (make-xep-lambda fun)))) - (setf (functional-kind res) :external) - (setf (leaf-ever-used res) t) - (setf (functional-entry-function res) fun) - (setf (functional-entry-function fun) res) - (setf (component-reanalyze *current-component*) t) - (setf (component-reoptimize *current-component*) t) + (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-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 +;;; Notice a REF that is not in a local-call context. If the REF is ;;; already to an XEP, then do nothing, otherwise change it to the ;;; XEP, making an XEP if necessary. ;;; -;;; If Ref is to a special :Cleanup or :Escape function, then we treat -;;; it as though it was not an XEP reference (i.e. leave it alone.) +;;; If REF is to a special :CLEANUP or :ESCAPE function, then we treat +;;; it as though it was not an XEP reference (i.e. leave it alone). (defun reference-entry-point (ref) (declare (type ref ref)) (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 +;;; Attempt to convert all references to FUN to local calls. The ;;; reference must be the function for a call, and the function ;;; continuation must be used only once, since otherwise we cannot be ;;; sure what function is to be called. The call continuation would be @@ -219,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)) @@ -243,44 +247,81 @@ (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 -;;; 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. -;;; -;;; COMPONENT-REANALYZE-FUNCTIONS is treated similarly to -;;; NEW-FUNCTIONS, but we don't add lambdas to the LAMBDAS. -(defun local-call-analyze (component) +;;; 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-FUNS may +;;; contain all sorts of drivel, since it is not updated when we +;;; delete functions, etc. Only COMPONENT-LAMBDAS is updated. +;;; +;;; 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 locall-analyze-clambdas-until-done (clambdas) + (loop + (let ((did-something nil)) + (dolist (clambda clambdas) + (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-funs component) + (setf did-something t) + (locall-analyze-component component)))) + (unless did-something + (return)))) (values)) -;;; If policy is auspicious, CALL is not in an XEP, and we don't seem +;;; If policy is auspicious and CALL is not in an XEP and we don't seem ;;; to be in an infinite recursive loop, then change the reference to ;;; reference a fresh copy. We return whichever function we decide to ;;; reference. @@ -288,14 +329,16 @@ (if (and (policy call (and (>= speed space) (>= speed compilation-speed))) (not (eq (functional-kind (node-home-lambda call)) :external)) - (not *converting-for-interpreter*) (inline-expansion-ok call)) (with-ir1-environment call (let* ((*lexenv* (functional-lexenv fun)) (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) @@ -303,29 +346,30 @@ (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)) -;;; Dispatch to the appropriate function to attempt to convert a call. Ref -;;; most be a reference to a FUNCTIONAL. This is called in IR1 optimize as -;;; well as in local call analysis. If the call is is already :Local, we do -;;; nothing. If the call is already scheduled for deletion, also do nothing -;;; (in addition to saving time, this also avoids some problems with optimizing -;;; collections of functions that are partially deleted.) +;;; Dispatch to the appropriate function to attempt to convert a call. +;;; REF must be a reference to a FUNCTIONAL. This is called in IR1 +;;; optimize as well as in local call analysis. If the call is is +;;; already :LOCAL, we do nothing. If the call is already scheduled +;;; for deletion, also do nothing (in addition to saving time, this +;;; also avoids some problems with optimizing collections of functions +;;; that are partially deleted.) ;;; -;;; This is called both before and after FIND-INITIAL-DFO runs. When called -;;; on a :INITIAL component, we don't care whether the caller and callee are in -;;; the same component. Afterward, we must stick with whatever component -;;; division we have chosen. +;;; This is called both before and after FIND-INITIAL-DFO runs. When +;;; called on a :INITIAL component, we don't care whether the caller +;;; and callee are in the same component. Afterward, we must stick +;;; with whatever component division we have chosen. ;;; -;;; Before attempting to convert a call, we see whether the function is -;;; supposed to be inline expanded. Call conversion proceeds as before -;;; after any expansion. +;;; Before attempting to convert a call, we see whether the function +;;; is supposed to be inline expanded. Call conversion proceeds as +;;; before after any expansion. ;;; -;;; We bind *Compiler-Error-Context* to the node for the call so that +;;; We bind *COMPILER-ERROR-CONTEXT* to the node for the call so that ;;; warnings will get the right context. (defun convert-call-if-possible (ref call) (declare (type ref ref) (type basic-combination call)) @@ -337,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)) @@ -381,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) @@ -429,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 @@ -464,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. -;;; -;;; 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. +;;; 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. (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)) @@ -483,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)))))) @@ -602,42 +649,42 @@ ;;;; LET conversion ;;;; -;;;; Converting to a LET has differing significance to various parts of the -;;;; compiler: -;;;; -- The body of a LET is spliced in immediately after the 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 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. -;;;; -- 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. -;;;; -- LET conversion has dynamic scope implications, since control transfers -;;;; within the same environment are local. In a local 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. -;;; -;;; 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)) +;;;; Converting to a LET has differing significance to various parts +;;;; of the compiler: +;;;; -- The body of a LET is spliced in immediately after the +;;;; 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 +;;;; 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 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. +;;;; -- LET conversion has dynamic scope implications, since control +;;;; transfers within the same environment are local. In a local +;;;; 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 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 (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)) @@ -650,47 +697,113 @@ (link-blocks call-block bind-block) next-block))) -;;; 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. +;;; 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 (clambda) + ;; Until sbcl-0.pre7.37.flaky5.2, we did + ;; (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-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 :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 + ;; FINALIZE-XEP-DEFINITION tried to find out its DEFINED-TYPE from + ;; the now-NILed-out TAIL-SET. So.. + ;; + ;; To deal with this problem, we no longer NIL out + ;; (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-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; + ;; but we save a newly-allocated tail-set, derived from the old + ;; 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 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 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 clambda)) nil)) + +;;; 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) - (declare (type clambda fun) (type basic-combination call)) +(defun merge-lets (clambda 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)) - (let ((tails (lambda-tail-set fun))) - (setf (tail-set-functions tails) - (delete fun (tail-set-functions tails)))) - (setf (lambda-tail-set fun) nil) + (setf (lambda-call-lexenv clambda) (node-lexenv call)) + + (depart-from-tail-set clambda) + (let* ((home (node-home-lambda call)) - (home-env (lambda-environment home))) - (push fun (lambda-lets home)) - (setf (lambda-home fun) home) - (setf (lambda-environment fun) home-env) + (home-env (lambda-physenv home))) + + ;; CLAMBDA belongs to HOME now. + (push clambda (lambda-lets home)) + (setf (lambda-home clambda) home) + (setf (lambda-physenv clambda) home-env) - (let ((lets (lambda-lets fun))) + ;; All of CLAMBDA's LETs belong to HOME now. + (let ((lets (lambda-lets clambda))) (dolist (let lets) (setf (lambda-home let) home) - (setf (lambda-environment let) home-env)) + (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)) ;;; Handle the value semantics of LET conversion. Delete FUN's return @@ -745,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 @@ -784,14 +899,15 @@ ;;; We do different things depending on whether the caller and callee ;;; have returns left: -;;; -- If the callee has no return we just do MOVE-LET-CALL-CONT. Either -;;; the function doesn't return, or all returns are via tail-recursive -;;; local calls. -;;; -- If CALL is a non-tail call, or if both have returns, then we -;;; delete the callee's return, move its uses to the call's result -;;; continuation, and transfer control to the appropriate return point. -;;; -- If the callee has a return, but the caller doesn't, then we move the -;;; return to the caller. +;;; -- If the callee has no return we just do MOVE-LET-CALL-CONT. +;;; Either the function doesn't return, or all returns are via +;;; tail-recursive local calls. +;;; -- If CALL is a non-tail call, or if both have returns, then +;;; we delete the callee's return, move its uses to the call's +;;; result continuation, and transfer control to the appropriate +;;; return point. +;;; -- If the callee has a return, but the caller doesn't, then we +;;; move the return to the caller. (defun move-return-stuff (fun call next-block) (declare (type clambda fun) (type basic-combination call) (type (or cblock null) next-block)) @@ -813,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) @@ -826,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)) @@ -837,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 @@ -865,27 +979,28 @@ ;;; 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 (basic-combination-p dest) + (when (and dest + (basic-combination-p dest) (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))) @@ -934,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 @@ -960,12 +1075,14 @@ (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) (let ((dest (continuation-dest (node-cont ref)))) - (when (block-delete-p (node-block dest)) (return nil)) + (when (or (not dest) + (block-delete-p (node-block dest))) + (return nil)) (let ((home (node-home-lambda ref))) (unless (eq home fun) (when call-fun (return nil))