X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Flocall.lisp;h=4f59a8784fcd74f4bc9fb9239d5d409d861c4c34;hb=02c9007b4ca5753406f60019f4fe5e5f8392541a;hp=eb499468df9f4f7ec1cb305f83f1ea42da1cb6e2;hpb=82653abf5573c22c691e2243b70647ecdaa6aea8;p=sbcl.git diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index eb49946..4f59a87 100644 --- a/src/compiler/locall.lisp +++ b/src/compiler/locall.lisp @@ -40,7 +40,8 @@ (let ((arg (car args)) (var (car vars))) (cond ((leaf-refs var) - (assert-continuation-type arg (leaf-type var))) + (assert-continuation-type arg (leaf-type var) + (lexenv-policy (node-lexenv call)))) (t (flush-dest arg) (setf (car args) nil))))) @@ -133,10 +134,12 @@ (temps (make-gensym-list (length (lambda-vars fun))))) `(lambda (,n-supplied ,@temps) (declare (type index ,n-supplied)) - ,(if (policy *lexenv* (zerop safety)) + ,(if (policy *lexenv* (zerop verify-arg-count)) `(declare (ignore ,n-supplied)) `(%verify-arg-count ,n-supplied ,nargs)) - (%funcall ,fun ,@temps)))) + (locally + (declare (optimize (merge-tail-calls 3))) + (%funcall ,fun ,@temps))))) (optional-dispatch (let* ((min (optional-dispatch-min-args fun)) (max (optional-dispatch-max-args fun)) @@ -162,7 +165,9 @@ (n-count (gensym))) `(multiple-value-bind (,n-context ,n-count) (%more-arg-context ,n-supplied ,max) - (%funcall ,more ,@temps ,n-context ,n-count)))))) + (locally + (declare (optimize (merge-tail-calls 3))) + (%funcall ,more ,@temps ,n-context ,n-count))))))) (t (%arg-count-error ,n-supplied))))))))) @@ -177,7 +182,7 @@ ;;; discover an XEP after the initial local call analyze pass. (defun make-xep (fun) (declare (type functional fun)) - (aver (not (functional-entry-fun fun))) + (aver (null (functional-entry-fun fun))) (with-ir1-environment-from-node (lambda-bind (main-entry fun)) (let ((res (ir1-convert-lambda (make-xep-lambda-expression fun) :debug-name (debug-namify @@ -248,69 +253,59 @@ (values)) -;;; 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. +;;; We examine all NEW-FUNCTIONALS 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-FUNS 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-FUNCTIONALS 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. +;;; COMPONENT-REANALYZE-FUNCTIONALS is treated similarly to +;;; COMPONENT-NEW-FUNCTIONALS, but we don't add lambdas to the +;;; LAMBDAS. (defun locall-analyze-component (component) (declare (type component component)) (aver-live-component component) (loop - (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-fun fun))) - (delete-functional fun)) + (let* ((new-functional (pop (component-new-functionals component))) + (functional (or new-functional + (pop (component-reanalyze-functionals component))))) + (unless functional + (return)) + (let ((kind (functional-kind functional))) + (cond ((or (functional-somewhat-letlike-p functional) + (eql kind :deleted)) + (values)) ; nothing to do + ((and (null (leaf-refs functional)) (eq kind nil) + (not (functional-entry-fun functional))) + (delete-functional functional)) (t - ;; Fix/check FUN's relationship to COMPONENT-LAMDBAS. - (cond ((not (lambda-p fun)) - ;; Since FUN isn't a LAMBDA, this doesn't apply: no-op. + ;; Fix/check FUNCTIONAL's relationship to COMPONENT-LAMDBAS. + (cond ((not (lambda-p functional)) + ;; Since FUNCTIONAL isn't 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))) - ;; FIXME: Maybe we don't need this clause? - ;; The only time I really thought I needed it - ;; was bug 138, and adding this clause didn't - ;; fix bug 138 but instead caused all sorts - ;; of other things to fail downstream... - #| - ((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 is 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))))))) + (new-functional ; FUNCTIONAL came from + ; NEW-FUNCTIONALS, hence is new. + ;; FUNCTIONAL becomes part of COMPONENT-LAMBDAS now. + (aver (not (member functional + (component-lambdas component)))) + (push functional (component-lambdas component))) + (t ; FUNCTIONAL is old. + ;; FUNCTIONAL should be in COMPONENT-LAMBDAS already. + (aver (member functional (component-lambdas + component))))) + (locall-analyze-fun-1 functional) + (when (lambda-p functional) + (maybe-let-convert functional))))))) (values)) (defun locall-analyze-clambdas-until-done (clambdas) @@ -323,7 +318,7 @@ ;; 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) + (when (component-new-functionals component) (setf did-something t) (locall-analyze-component component)))) (unless did-something @@ -334,36 +329,38 @@ ;;; to be in an infinite recursive loop, then change the reference to ;;; reference a fresh copy. We return whichever function we decide to ;;; reference. -(defun maybe-expand-local-inline (fun ref call) +(defun maybe-expand-local-inline (original-functional ref call) (if (and (policy call - (and (>= speed space) (>= speed compilation-speed))) + (and (>= speed space) + (>= speed compilation-speed))) (not (eq (functional-kind (node-home-lambda call)) :external)) (inline-expansion-ok call)) - (with-ir1-environment-from-node call - (let* ((*lexenv* (functional-lexenv fun)) - (won nil) - (res (catch 'local-call-lossage - (prog1 - (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) - res) - (t - (let ((*compiler-error-context* call)) - (compiler-note "couldn't inline expand because expansion ~ - calls this LET-converted local function:~ - ~% ~S" - (leaf-debug-name res))) - fun)))) - fun)) + (multiple-value-bind (losing-local-functional converted-lambda) + (catch 'locall-already-let-converted + (with-ir1-environment-from-node call + (let ((*lexenv* (functional-lexenv original-functional))) + (values nil + (ir1-convert-lambda + (functional-inline-expansion original-functional) + :debug-name (debug-namify + "local inline ~A" + (leaf-debug-name + original-functional))))))) + (cond (losing-local-functional + (let ((*compiler-error-context* call)) + (compiler-note "couldn't inline expand because expansion ~ + calls this LET-converted local function:~ + ~% ~S" + (leaf-debug-name losing-local-functional))) + original-functional) + (t + (change-ref-leaf ref converted-lambda) + converted-lambda))) + original-functional)) ;;; 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 +;;; optimization 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 @@ -417,7 +414,7 @@ (values)) ;;; Attempt to convert a multiple-value call. The only interesting -;;; case is a call to a function that Looks-Like-An-MV-Bind, has +;;; case is a call to a function that LOOKS-LIKE-AN-MV-BIND, has ;;; exactly one reference and no XEP, and is called with one values ;;; continuation. ;;; @@ -446,7 +443,8 @@ (assert-continuation-type (first (basic-combination-args call)) (make-values-type :optional (mapcar #'leaf-type (lambda-vars ep)) - :rest *universal-type*)))) + :rest *universal-type*) + (lexenv-policy (node-lexenv call))))) (values)) ;;; Attempt to convert a call to a lambda. If the number of args is @@ -535,8 +533,8 @@ (with-ir1-environment-from-node call (ir1-convert-lambda `(lambda ,vars - (declare (ignorable . ,ignores)) - (%funcall ,entry . ,args)) + (declare (ignorable ,@ignores)) + (%funcall ,entry ,@args)) :debug-name (debug-namify "hairy function entry ~S" (continuation-fun-name (basic-combination-fun call))))))) @@ -568,6 +566,8 @@ (flame (policy call (or (> speed inhibit-warnings) (> space inhibit-warnings)))) (loser nil) + (allowp nil) + (allow-found nil) (temps (make-gensym-list max)) (more-temps (make-gensym-list (length more)))) (collect ((ignores) @@ -607,17 +607,28 @@ (let ((name (continuation-value cont)) (dummy (first temp)) (val (second temp))) + ;; FIXME: check whether KEY was supplied earlier + (when (and (eq name :allow-other-keys) (not allow-found)) + (let ((val (second key))) + (cond ((constant-continuation-p val) + (setq allow-found t + allowp (continuation-value val))) + (t (when flame + (compiler-note "non-constant :ALLOW-OTHER-KEYS value")) + (setf (basic-combination-kind call) :error) + (return-from convert-more-call))))) (dolist (var (key-vars) (progn (ignores dummy val) - (setq loser name))) + (unless (eq name :allow-other-keys) + (setq loser name)))) (let ((info (lambda-var-arg-info var))) (when (eq (arg-info-key info) name) (ignores dummy) (supplied (cons var val)) (return))))))) - (when (and loser (not (optional-dispatch-allowp fun))) + (when (and loser (not (optional-dispatch-allowp fun)) (not allowp)) (compiler-warn "function called with unknown argument keyword ~S" loser) (setf (basic-combination-kind call) :error) @@ -626,7 +637,7 @@ (collect ((call-args)) (do ((var arglist (cdr var)) (temp temps (cdr temp))) - (()) + ((null var)) (let ((info (lambda-var-arg-info (car var)))) (if info (ecase (arg-info-kind info) @@ -756,10 +767,10 @@ ;; 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. +;;; Handle the PHYSENV 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 @@ -778,18 +789,20 @@ (depart-from-tail-set clambda) (let* ((home (node-home-lambda call)) - (home-env (lambda-physenv home))) + (home-physenv (lambda-physenv home))) + + (aver (not (eq home clambda))) ;; CLAMBDA belongs to HOME now. (push clambda (lambda-lets home)) (setf (lambda-home clambda) home) - (setf (lambda-physenv clambda) home-env) + (setf (lambda-physenv clambda) home-physenv) ;; 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-home let) home) + (setf (lambda-physenv let) home-physenv)) (setf (lambda-lets home) (nconc lets (lambda-lets home)))) ;; CLAMBDA no longer has an independent existence as an entity ;; which has LETs. @@ -798,17 +811,17 @@ ;; 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)))) + (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 clambda) - (lambda-entries home))) + (nconc (lambda-entries clambda) + (lambda-entries home))) ;; CLAMBDA no longer has an independent existence as an entity ;; with ENTRIES. (setf (lambda-entries clambda) nil)) @@ -842,7 +855,10 @@ (cont (node-cont call)) (call-type (node-derived-type call))) (when (eq (continuation-use cont) call) - (assert-continuation-type cont (continuation-asserted-type result))) + (set-continuation-type-assertion + cont + (continuation-asserted-type result) + (continuation-type-to-check result))) (unless (eq call-type *wild-type*) (do-uses (use result) (derive-node-type use call-type))) @@ -928,12 +944,21 @@ (cond ((not return)) ((or next-block call-return) (unless (block-delete-p (node-block return)) + (when (and (node-tail-p call) + call-return + (not (eq (node-cont call) + (return-result call-return)))) + ;; We do not care to give a meaningful continuation to + ;; a tail combination, but here we need it. + (delete-continuation-use call) + (add-continuation-use call (return-result call-return))) (move-return-uses fun call (or next-block (node-block call-return))))) (t (aver (node-tail-p call)) (setf (lambda-return call-fun) return) - (setf (return-lambda return) call-fun)))) + (setf (return-lambda return) call-fun) + (setf (lambda-return fun) nil)))) (move-let-call-cont fun) (values)) @@ -960,58 +985,84 @@ (reoptimize-continuation (node-cont call)) (values)) +;;; Are there any declarations in force to say CLAMBDA shouldn't be +;;; LET converted? +(defun declarations-suppress-let-conversion-p (clambda) + ;; From the user's point of view, LET-converting something that + ;; has a name is inlining it. (The user can't see what we're doing + ;; with anonymous things, and suppressing inlining + ;; for such things can easily give Python acute indigestion, so + ;; we don't.) + (when (leaf-has-source-name-p clambda) + ;; ANSI requires that explicit NOTINLINE be respected. + (or (eq (lambda-inlinep clambda) :notinline) + ;; If (= LET-CONVERTION 0) we can guess that inlining + ;; generally won't be appreciated, but if the user + ;; specifically requests inlining, that takes precedence over + ;; our general guess. + (and (policy clambda (= let-convertion 0)) + (not (eq (lambda-inlinep clambda) :inline)))))) + ;;; We also don't convert calls to named functions which appear in the ;;; initial component, delaying this until optimization. This ;;; 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-has-source-name-p fun) - (eq (component-kind (lambda-component fun)) - :initial)))) + (or (declarations-suppress-let-conversion-p fun) + (eq (component-kind (lambda-component fun)) + :initial))))) ;;; This function is called when there is some reason to believe that ;;; 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 -;;; deleted. We return true if we converted. -;;; -;;; These rules may seem unnecessarily restrictive, since there are -;;; some cases where we could do the return with a jump that don't -;;; satisfy these requirements. The reason for doing things this way -;;; is that it makes the concept of a LET much more useful at the -;;; level of IR1 semantics. The :ASSIGNMENT function kind provides -;;; another way to optimize calls to single-return/multiple call -;;; functions. -;;; -;;; 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. +;;; call analysis, and also when a reference is deleted. We return +;;; true if we converted. (defun maybe-let-convert (clambda) (declare (type clambda clambda)) - (let ((refs (leaf-refs clambda))) - (when (and refs - (null (rest refs)) - (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 - (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 clambda) t) - (t - (reoptimize-continuation ref-cont) - nil))) - (unless (eq (functional-kind clambda) :assignment) - (let-convert clambda dest)) - (reoptimize-call dest) - (setf (functional-kind clambda) - (if (mv-combination-p dest) :mv-let :let)))) - t))) + (unless (declarations-suppress-let-conversion-p clambda) + ;; 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 deleted. + ;; + ;; These rules limiting LET conversion may seem unnecessarily + ;; restrictive, since there are some cases where we could do the + ;; return with a jump that don't satisfy these requirements. The + ;; reason for doing things this way is that it makes the concept + ;; of a LET much more useful at the level of IR1 semantics. The + ;; :ASSIGNMENT function kind provides another way to optimize + ;; calls to single-return/multiple call functions. + ;; + ;; 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. + (let ((refs (leaf-refs clambda))) + (when (and refs + (null (rest refs)) + (member (functional-kind clambda) '(nil :assignment)) + (not (functional-entry-fun clambda))) + (let* ((ref (first refs)) + (ref-cont (node-cont ref)) + (dest (continuation-dest ref-cont))) + (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 clambda) t) + (t + (reoptimize-continuation ref-cont) + nil))) + (when (eq clambda (node-home-lambda dest)) + (delete-lambda clambda) + (return-from maybe-let-convert nil)) + (unless (eq (functional-kind clambda) :assignment) + (let-convert clambda dest)) + (reoptimize-call dest) + (setf (functional-kind clambda) + (if (mv-combination-p dest) :mv-let :let)))) + t)))) ;;;; tail local calls and assignments @@ -1061,10 +1112,11 @@ (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 -;;; to an assignment. All this function really does is determine when -;;; a function with more than one call can still be combined with the -;;; calling function's environment. We can convert when: +;;; This is called when we believe it might make sense to convert +;;; CLAMBDA to an assignment. All this function really does is +;;; determine when a function with more than one call can still be +;;; combined with the calling function's environment. We can convert +;;; when: ;;; -- The function is a normal, non-entry function, and ;;; -- Except for one call, all calls must be tail recursive calls ;;; in the called function (i.e. are self-recursive tail calls) @@ -1081,28 +1133,31 @@ ;;; calls as long as they all return to the same place (i.e. have the ;;; same conceptual continuation.) A special case of this would be ;;; when all of the outside calls are tail recursive. -(defun maybe-convert-to-assignment (fun) - (declare (type clambda fun)) - (when (and (not (functional-kind fun)) - (not (functional-entry-fun fun))) - (let ((non-tail nil) - (call-fun nil)) - (when (and (dolist (ref (leaf-refs fun) t) +(defun maybe-convert-to-assignment (clambda) + (declare (type clambda clambda)) + (when (and (not (functional-kind clambda)) + (not (functional-entry-fun clambda))) + (let ((outside-non-tail-call nil) + (outside-call nil)) + (when (and (dolist (ref (leaf-refs clambda) t) (let ((dest (continuation-dest (node-cont ref)))) (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)) - (setq call-fun home)) + (unless (eq home clambda) + (when outside-call + (return nil)) + (setq outside-call dest)) (unless (node-tail-p dest) - (when (or non-tail (eq home fun)) (return nil)) - (setq non-tail dest))))) - (ok-initial-convert-p fun)) - (setf (functional-kind fun) :assignment) - (let-convert fun (or non-tail - (continuation-dest - (node-cont (first (leaf-refs fun)))))) - (when non-tail (reoptimize-call non-tail)) - t)))) + (when (or outside-non-tail-call (eq home clambda)) + (return nil)) + (setq outside-non-tail-call dest))))) + (ok-initial-convert-p clambda)) + (cond (outside-call (setf (functional-kind clambda) :assignment) + (let-convert clambda outside-call) + (when outside-non-tail-call + (reoptimize-call outside-non-tail-call)) + t) + (t (delete-lambda clambda) + nil))))))