From 20748f2dd7965dcd1446a1cb27e5a5af18a0e5bb Mon Sep 17 00:00:00 2001 From: William Harold Newman Date: Sat, 10 Nov 2001 21:10:56 +0000 Subject: [PATCH] 0.pre7.86.flaky7.2: (still dies with the same assertion failure) factored out some idioms.. ..LAMBDA-BLOCK ..LAMBDA-COMPONENT (previously known as CLAMBDA-COMPONENT) s/entry-function/entry-fun/ s/tail-set-functions/tail-set-funs/ --- src/code/pprint.lisp | 2 +- src/code/toplevel.lisp | 8 +- src/compiler/control.lisp | 3 +- src/compiler/debug-dump.lisp | 3 +- src/compiler/debug.lisp | 24 +++--- src/compiler/dfo.lisp | 23 ++--- src/compiler/entry.lisp | 4 +- src/compiler/gtn.lisp | 4 +- src/compiler/ir1final.lisp | 2 +- src/compiler/ir1opt.lisp | 6 +- src/compiler/ir1tran.lisp | 8 +- src/compiler/ir1util.lisp | 32 ++++--- src/compiler/ir2tran.lisp | 4 +- src/compiler/locall.lisp | 193 +++++++++++++++++++++++------------------- src/compiler/ltn.lisp | 2 +- src/compiler/main.lisp | 14 ++- src/compiler/node.lisp | 10 +-- src/compiler/represent.lisp | 2 +- 18 files changed, 181 insertions(+), 163 deletions(-) diff --git a/src/code/pprint.lisp b/src/code/pprint.lisp index fee0c7f..2067b07 100644 --- a/src/code/pprint.lisp +++ b/src/code/pprint.lisp @@ -918,7 +918,7 @@ (when (funcall (pprint-dispatch-entry-test-fn entry) object) (return entry))))) (if entry - (values (pprint-dispatch-entry-function entry) t) + (values (pprint-dispatch-entry-fun entry) t) (values #'(lambda (stream object) (output-ugly-object object stream)) nil)))) diff --git a/src/code/toplevel.lisp b/src/code/toplevel.lisp index a2a141f..9196734 100644 --- a/src/code/toplevel.lisp +++ b/src/code/toplevel.lisp @@ -512,12 +512,14 @@ (handler-case (progn (format *error-output* - "~@~2%" + "~&~@~2%" (type-of condition) condition) ;; Flush *ERROR-OUTPUT* even before the BACKTRACE, so that - ;; even if we hit an error within BACKTRACE we'll at least - ;; have the CONDITION printed out before we die. + ;; even if we hit an error within BACKTRACE (e.g. a bug in + ;; the debugger's own frame-walking code, or a bug in a user + ;; PRINT-OBJECT method) we'll at least have the CONDITION + ;; printed out before we die. (finish-output *error-output*) ;; (Where to truncate the BACKTRACE is of course arbitrary, but ;; it seems as though we should at least truncate it somewhere.) diff --git a/src/compiler/control.lisp b/src/compiler/control.lisp index 3d96ee6..76390e4 100644 --- a/src/compiler/control.lisp +++ b/src/compiler/control.lisp @@ -59,8 +59,7 @@ (cond ((and pred (not (physenv-nlx-info env)) - (not (eq (node-block (lambda-bind (block-home-lambda block))) - block))) + (not (eq (lambda-block (block-home-lambda block)) block))) (let ((current pred) (current-num (block-number pred))) (block DONE diff --git a/src/compiler/debug-dump.lisp b/src/compiler/debug-dump.lisp index a63d179..73f3aed 100644 --- a/src/compiler/debug-dump.lisp +++ b/src/compiler/debug-dump.lisp @@ -554,8 +554,7 @@ :adjustable t))) (dolist (fun (component-lambdas component)) (clrhash var-locs) - (dfuns (cons (label-position - (block-label (node-block (lambda-bind fun)))) + (dfuns (cons (label-position (block-label (lambda-block fun))) (compute-1-debug-fun fun var-locs)))) (let* ((sorted (sort (dfuns) #'< :key #'car)) (fun-map (compute-debug-fun-map sorted))) diff --git a/src/compiler/debug.lisp b/src/compiler/debug.lisp index fa8bbf3..c8759f9 100644 --- a/src/compiler/debug.lisp +++ b/src/compiler/debug.lisp @@ -170,15 +170,15 @@ (defun check-function-stuff (functional) (ecase (functional-kind functional) (:external - (let ((fun (functional-entry-function functional))) + (let ((fun (functional-entry-fun functional))) (check-function-reached fun functional) (when (functional-kind fun) (barf "The function for XEP ~S has kind." functional)) - (unless (eq (functional-entry-function fun) functional) + (unless (eq (functional-entry-fun fun) functional) (barf "bad back-pointer in function for XEP ~S" functional)))) ((:let :mv-let :assignment) (check-function-reached (lambda-home functional) functional) - (when (functional-entry-function functional) + (when (functional-entry-fun functional) (barf "The LET ~S has entry function." functional)) (unless (member functional (lambda-lets (lambda-home functional))) (barf "The LET ~S is not in LETs for HOME." functional)) @@ -188,8 +188,8 @@ (when (lambda-lets functional) (barf "LETs in a LET: ~S" functional))) (:optional - (when (functional-entry-function functional) - (barf ":OPTIONAL ~S has an ENTRY-FUNCTION." functional)) + (when (functional-entry-fun functional) + (barf ":OPTIONAL ~S has an ENTRY-FUN." functional)) (let ((ef (lambda-optional-dispatch functional))) (check-function-reached ef functional) (unless (or (member functional (optional-dispatch-entry-points ef)) @@ -198,16 +198,14 @@ (barf ":OPTIONAL ~S is not an e-p for its OPTIONAL-DISPATCH ~S." functional ef)))) (:toplevel - (unless (eq (functional-entry-function functional) functional) - (barf "The ENTRY-FUNCTION in ~S isn't a self-pointer." functional))) + (unless (eq (functional-entry-fun functional) functional) + (barf "The ENTRY-FUN in ~S isn't a self-pointer." functional))) ((nil :escape :cleanup) - (let ((ef (functional-entry-function functional))) + (let ((ef (functional-entry-fun functional))) (when ef (check-function-reached ef functional) (unless (eq (functional-kind ef) :external) - (barf "The ENTRY-FUNCTION in ~S isn't an XEP: ~S." - functional - ef))))) + (barf "The ENTRY-FUN in ~S isn't an XEP: ~S." functional ef))))) (:deleted (return-from check-function-stuff))) @@ -249,7 +247,7 @@ (observe-functional new-fun)) (dolist (fun (component-lambdas c)) (when (eq (functional-kind fun) :external) - (let ((ef (functional-entry-function fun))) + (let ((ef (functional-entry-fun fun))) (when (optional-dispatch-p ef) (observe-functional ef)))) (observe-functional fun) @@ -928,7 +926,7 @@ (component (component-head thing)) #| (cloop (loop-head thing))|# (integer (continuation-block (num-cont thing))) - (functional (node-block (lambda-bind (main-entry thing)))) + (functional (lambda-block (main-entry thing))) (null (error "Bad thing: ~S." thing)) (symbol (block-or-lose (gethash thing *free-functions*))))) diff --git a/src/compiler/dfo.lisp b/src/compiler/dfo.lisp index 4107521..044b564 100644 --- a/src/compiler/dfo.lisp +++ b/src/compiler/dfo.lisp @@ -119,13 +119,12 @@ ;;; reachable from a non-local exit. (defun walk-home-call-graph (block component) (declare (type cblock block) (type component component)) - (let ((home (block-home-lambda block))) - (if (eq (functional-kind home) :deleted) + (let ((home-lambda (block-home-lambda block))) + (if (eq (functional-kind home-lambda) :deleted) component - (let* ((bind-block (node-block (lambda-bind home))) - (home-component (block-component bind-block))) + (let ((home-component (lambda-component home-lambda))) (cond ((eq (component-kind home-component) :initial) - (dfo-scavenge-call-graph home component)) + (dfo-scavenge-call-graph home-lambda component)) ((eq home-component component) component) (t @@ -354,7 +353,7 @@ ;; are moved to the appropriate newc component tail. (dolist (toplevel-lambda toplevel-lambdas) (/show toplevel-lambda) - (let* ((block (node-block (lambda-bind toplevel-lambda))) + (let* ((block (lambda-block toplevel-lambda)) (old-component (block-component block)) (old-component-lambdas (component-lambdas old-component)) (new-component nil)) @@ -418,8 +417,7 @@ (let* ((bind (lambda-bind lambda)) (bind-block (node-block bind)) (component (block-component bind-block)) - (result-component - (block-component (node-block (lambda-bind result-lambda)))) + (result-component (lambda-component result-lambda)) (result-return-block (node-block (lambda-return result-lambda)))) ;; Move blocks into the new COMPONENT, and move any nodes directly @@ -503,10 +501,7 @@ (merge-1-tl-lambda result-lambda lambda))) (t (dolist (lambda (rest lambdas)) - (setf (functional-entry-function lambda) nil) - (delete-component - (block-component - (node-block (lambda-bind lambda))))))) + (setf (functional-entry-fun lambda) nil) + (delete-component (lambda-component lambda))))) - (values (block-component (node-block (lambda-bind result-lambda))) - result-lambda))) + (values (lambda-component result-lambda) result-lambda))) diff --git a/src/compiler/entry.lisp b/src/compiler/entry.lisp index 5c56812..33ea6cc 100644 --- a/src/compiler/entry.lisp +++ b/src/compiler/entry.lisp @@ -54,7 +54,7 @@ (defun compute-entry-info (fun info) (declare (type clambda fun) (type entry-info info)) (let ((bind (lambda-bind fun)) - (internal-fun (functional-entry-function fun))) + (internal-fun (functional-entry-fun fun))) (setf (entry-info-closure-p info) (not (null (physenv-closure (lambda-physenv fun))))) (setf (entry-info-offset info) (gen-label)) @@ -87,7 +87,7 @@ (case (functional-kind lambda) (:external (unless (lambda-has-external-references-p lambda) - (let* ((ef (functional-entry-function lambda)) + (let* ((ef (functional-entry-fun lambda)) (new (make-functional :kind :toplevel-xep :info (leaf-info lambda) diff --git a/src/compiler/gtn.lisp b/src/compiler/gtn.lisp index 400ee93..876e14a 100644 --- a/src/compiler/gtn.lisp +++ b/src/compiler/gtn.lisp @@ -110,7 +110,7 @@ ;;; a non-standard convention. (defun use-standard-returns (tails) (declare (type tail-set tails)) - (let ((funs (tail-set-functions tails))) + (let ((funs (tail-set-funs tails))) (or (and (find-if #'external-entry-point-p funs) (find-if #'has-full-call-use funs)) (block punt @@ -131,7 +131,7 @@ ;;; there is no such function, then be more vague. (defun return-value-efficiency-note (tails) (declare (type tail-set tails)) - (let ((funs (tail-set-functions tails))) + (let ((funs (tail-set-funs tails))) (when (policy (lambda-bind (first funs)) (> (max speed space) inhibit-warnings)) diff --git a/src/compiler/ir1final.lisp b/src/compiler/ir1final.lisp index 175d73a..50e9cc2 100644 --- a/src/compiler/ir1final.lisp +++ b/src/compiler/ir1final.lisp @@ -56,7 +56,7 @@ ;;; also delete the FUNCTIONAL from *FREE-FUNCTIONS* to eliminate the ;;; possibility that new references might be converted to it. (defun finalize-xep-definition (fun) - (let* ((leaf (functional-entry-function fun)) + (let* ((leaf (functional-entry-fun fun)) (defined-ftype (definition-type leaf))) (setf (leaf-type leaf) defined-ftype) (when (leaf-has-source-name-p leaf) diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp index 616c984..122810d 100644 --- a/src/compiler/ir1opt.lisp +++ b/src/compiler/ir1opt.lisp @@ -497,7 +497,7 @@ (defun ir1-optimize-return (node) (declare (type creturn node)) (let* ((tails (lambda-tail-set (return-lambda node))) - (funs (tail-set-functions tails))) + (funs (tail-set-funs tails))) (collect ((res *empty-type* values-type-union)) (dolist (fun funs) (let ((return (lambda-return fun))) @@ -509,7 +509,7 @@ (when (type/= (res) (tail-set-type tails)) (setf (tail-set-type tails) (res)) - (dolist (fun (tail-set-functions tails)) + (dolist (fun (tail-set-funs tails)) (dolist (ref (leaf-refs fun)) (reoptimize-continuation (node-cont ref))))))) @@ -1313,7 +1313,7 @@ (defun propagate-local-call-args (call fun) (declare (type combination call) (type clambda fun)) - (unless (or (functional-entry-function fun) + (unless (or (functional-entry-fun fun) (lambda-optional-dispatch fun)) (let* ((vars (lambda-vars fun)) (union (mapcar #'(lambda (arg var) diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp index 7a10dc1..fc7078e 100644 --- a/src/compiler/ir1tran.lisp +++ b/src/compiler/ir1tran.lisp @@ -346,7 +346,7 @@ (res (ir1-convert-lambda-body forms () :debug-name (debug-namify "top level form ~S" form)))) - (setf (functional-entry-function res) res + (setf (functional-entry-fun res) res (functional-arg-documentation res) () (functional-kind res) :toplevel) res))) @@ -1354,8 +1354,8 @@ :%debug-name debug-name)) (result (or result (make-continuation)))) - ;; This function should fail internal assertions if we didn't set - ;; up a valid debug name above. + ;; just to check: This function should fail internal assertions if + ;; we didn't set up a valid debug name above. ;; ;; (In SBCL we try to make everything have a debug name, since we ;; lack the omniscient perspective the original implementors used @@ -1396,7 +1396,7 @@ (let ((block (continuation-block result))) (when block (let ((return (make-return :result result :lambda lambda)) - (tail-set (make-tail-set :functions (list lambda))) + (tail-set (make-tail-set :funs (list lambda))) (dummy (make-continuation))) (setf (lambda-tail-set lambda) tail-set) (setf (lambda-return lambda) return) diff --git a/src/compiler/ir1util.lisp b/src/compiler/ir1util.lisp index 1e3369e..c8709fb 100644 --- a/src/compiler/ir1util.lisp +++ b/src/compiler/ir1util.lisp @@ -254,8 +254,16 @@ #!-sb-fluid (declare (inline node-home-lambda)) (the physenv (lambda-physenv (node-home-lambda node)))) -;;; Return the enclosing cleanup for environment of the first or last node -;;; in BLOCK. +#!-sb-fluid (declaim (maybe-inline lambda-block)) +(defun lambda-block (clambda) + (declare (type clambda clambda)) + (node-block (lambda-bind clambda))) +(defun lambda-component (clambda) + (declare (inline lambda-block)) + (block-component (lambda-block clambda))) + +;;; Return the enclosing cleanup for environment of the first or last +;;; node in BLOCK. (defun block-start-cleanup (block) (declare (type cblock block)) (node-enclosing-cleanup (continuation-next (block-start block)))) @@ -559,7 +567,7 @@ ;;; DELETE-REF will handle the deletion. (defun delete-functional (fun) (aver (and (null (leaf-refs fun)) - (not (functional-entry-function fun)))) + (not (functional-entry-fun fun)))) (etypecase fun (optional-dispatch (delete-optional-dispatch fun)) (clambda (delete-lambda fun))) @@ -578,8 +586,8 @@ ;;; (it won't be there before local call analysis, but no matter.) If ;;; the lambda was never referenced, we give a note. ;;; -;;; If the lambda is an XEP, then we null out the ENTRY-FUNCTION in its -;;; ENTRY-FUNCTION so that people will know that it is not an entry point +;;; If the lambda is an XEP, then we null out the ENTRY-FUN in its +;;; ENTRY-FUN so that people will know that it is not an entry point ;;; anymore. (defun delete-lambda (leaf) (declare (type clambda leaf)) @@ -609,15 +617,15 @@ (unlink-blocks (node-block return) (component-tail component))) (setf (component-reanalyze component) t) (let ((tails (lambda-tail-set leaf))) - (setf (tail-set-functions tails) - (delete leaf (tail-set-functions tails))) + (setf (tail-set-funs tails) + (delete leaf (tail-set-funs tails))) (setf (lambda-tail-set leaf) nil)) (setf (component-lambdas component) (delete leaf (component-lambdas component))))) (when (eq kind :external) - (let ((fun (functional-entry-function leaf))) - (setf (functional-entry-function fun) nil) + (let ((fun (functional-entry-fun leaf))) + (setf (functional-entry-fun fun) nil) (when (optional-dispatch-p fun) (delete-optional-dispatch fun))))) @@ -643,7 +651,7 @@ ;;; or even converted to a let. (defun delete-optional-dispatch (leaf) (declare (type optional-dispatch leaf)) - (let ((entry (functional-entry-function leaf))) + (let ((entry (functional-entry-fun leaf))) (unless (and entry (leaf-refs entry)) (aver (or (not entry) (eq (functional-kind entry) :deleted))) (setf (functional-kind leaf) :deleted) @@ -686,7 +694,7 @@ (clambda (ecase (functional-kind leaf) ((nil :let :mv-let :assignment :escape :cleanup) - (aver (not (functional-entry-function leaf))) + (aver (not (functional-entry-fun leaf))) (delete-lambda leaf)) (:external (delete-lambda leaf)) @@ -1056,7 +1064,7 @@ (setf (block-delete-p block) t)) (dolist (fun (component-lambdas component)) (setf (functional-kind fun) nil) - (setf (functional-entry-function fun) nil) + (setf (functional-entry-fun fun) nil) (setf (leaf-refs fun) nil) (delete-functional fun)) (do-blocks (block component) diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp index 2ad7d66..8b170e9 100644 --- a/src/compiler/ir2tran.lisp +++ b/src/compiler/ir2tran.lisp @@ -770,7 +770,7 @@ ((node-tail-p node) (ir2-convert-tail-local-call node block fun)) (t - (let ((start (block-label (node-block (lambda-bind fun)))) + (let ((start (block-label (lambda-block fun))) (returns (tail-set-info (lambda-tail-set fun))) (cont (node-cont node))) (ecase (if returns @@ -1015,7 +1015,7 @@ (declare (type bind node) (type ir2-block block) (type clambda fun)) (let ((start-label (entry-info-offset (leaf-info fun))) (env (physenv-info (node-physenv node)))) - (let ((ef (functional-entry-function fun))) + (let ((ef (functional-entry-fun fun))) (cond ((and (optional-dispatch-p ef) (optional-dispatch-more-entry ef)) ;; Special case the xep-allocate-frame + copy-more-arg case. (vop xep-allocate-frame node block start-label t) diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp index dc7c1ed..0233e3c 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))))) @@ -177,7 +177,7 @@ ;;; 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-expression fun) :debug-name (debug-namify @@ -185,8 +185,8 @@ (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 @@ -209,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 @@ -272,22 +272,30 @@ (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-fun (lambda-p fun)) - (push fun (component-lambdas component))) + ;; 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))) + (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 (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. @@ -367,7 +375,7 @@ (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)) @@ -404,7 +412,7 @@ (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))))) @@ -631,11 +639,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. @@ -644,23 +652,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)) @@ -673,18 +681,18 @@ (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.. ;; @@ -698,10 +706,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; @@ -709,62 +717,75 @@ ;; 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) + + (let ((lets (lambda-lets clambda))) + ;; All CLAMBDA's LETs belong to HOME now. (dolist (let lets) (setf (lambda-home let) home) (setf (lambda-physenv let) home-env)) - (setf (lambda-lets home) (nconc lets (lambda-lets home))) - (setf (lambda-lets fun) ())) + ;; CLAMBDA no longer has an independent existence as an entity + ;; which has LETs. + (setf (lambda-lets clambda) nil)) + ;; HOME no longer calls CLAMBDA, and owns all of CLAMBDA's old + ;; calls. (setf (lambda-calls home) - (delete fun (nunion (lambda-calls fun) (lambda-calls home)))) - (setf (lambda-calls fun) ()) + (delete clambda + (nunion (lambda-calls clambda) + (lambda-calls home)))) + ;; CLAMBDA no longer has an independent existence as an entity + ;; which calls things. + (setf (lambda-calls clambda) nil) + ;; All 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)) @@ -889,11 +910,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 +;;; 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 +;;; 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) @@ -902,7 +923,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)) @@ -913,18 +934,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-has-source-name-p fun) - (eq (component-kind - (block-component - (node-block (lambda-bind 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 @@ -941,13 +960,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 @@ -955,14 +974,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))) @@ -1011,7 +1030,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 @@ -1037,7 +1056,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) diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp index 66d201d..ed1bff3 100644 --- a/src/compiler/ltn.lisp +++ b/src/compiler/ltn.lisp @@ -424,7 +424,7 @@ (node-ends-block call) (let ((block (node-block call))) (unlink-blocks block (first (block-succ block))) - (link-blocks block (node-block (lambda-bind callee))))) + (link-blocks block (lambda-block callee)))) (values)) ;;; Annotate the value continuation. diff --git a/src/compiler/main.lisp b/src/compiler/main.lisp index 9d8e582..f3b81da 100644 --- a/src/compiler/main.lisp +++ b/src/compiler/main.lisp @@ -828,15 +828,13 @@ ;;; utilities for extracting COMPONENTs of FUNCTIONALs -(defun clambda-component (clambda) - (block-component (node-block (lambda-bind clambda)))) (defun functional-components (f) (declare (type functional f)) (etypecase f - (clambda (list (clambda-component f))) + (clambda (list (lambda-component f))) (optional-dispatch (let ((result nil)) (labels ((frob (clambda) - (pushnew (clambda-component clambda) + (pushnew (lambda-component clambda) result)) (maybe-frob (maybe-clambda) (when maybe-clambda @@ -870,7 +868,7 @@ (/show "in MAKE-FUNCTIONAL-FROM-TOP-LEVEL-LAMBDA" locall-fun fun component) (/show (component-lambdas component)) (/show (lambda-calls fun)) - (setf (functional-entry-function fun) locall-fun + (setf (functional-entry-fun fun) locall-fun (functional-kind fun) :external (functional-has-external-references-p fun) t) fun))) @@ -903,8 +901,7 @@ :name name :path path))) (/show "back in %COMPILE from M-F-FROM-TL-LAMBDA" fun) - (/show (block-component (node-block (lambda-bind fun)))) - (/show (component-lambdas (block-component (node-block (lambda-bind fun))))) + (/show (lambda-component fun) (component-lambdas (lambda-component fun))) ;; FIXME: The compile-it code from here on is sort of a ;; twisted version of the code in COMPILE-TOPLEVEL. It'd be @@ -914,6 +911,7 @@ ;; the :LOCALL-ONLY option to IR1-FOR-LAMBDA. Then maybe the ;; whole FUNCTIONAL-KIND=:TOPLEVEL case could go away..) + #+nil (break "before LOCALL-ANALYZE-CLAMBDAS-UNTIL-DONE" fun) (locall-analyze-clambdas-until-done (list fun)) (/show (lambda-calls fun)) #+nil (break "back from LOCALL-ANALYZE-CLAMBDAS-UNTIL-DONE" fun) @@ -1158,7 +1156,7 @@ (defun compile-load-time-value-lambda (lambdas) (aver (null (cdr lambdas))) (let* ((lambda (car lambdas)) - (component (block-component (node-block (lambda-bind lambda))))) + (component (lambda-component lambda))) (when (eql (component-kind component) :toplevel) (setf (component-name component) (leaf-debug-name lambda)) (compile-component component) diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp index 7b499a6..abda10b 100644 --- a/src/compiler/node.lisp +++ b/src/compiler/node.lisp @@ -527,7 +527,7 @@ ;;; end up tail-recursive causes TAIL-SET merging. (defstruct (tail-set) ;; a list of all the LAMBDAs in this tail set - (functions nil :type list) + (funs nil :type list) ;; our current best guess of the type returned by these functions. ;; This is the union across all the functions of the return node's ;; RESULT-TYPE, excluding local calls. @@ -535,7 +535,7 @@ ;; some info used by the back end (info nil)) (defprinter (tail-set :identity t) - functions + funs type (info :test info)) @@ -788,13 +788,13 @@ ;; ;; :EXTERNAL ;; an external entry point lambda. The function it is an entry - ;; for is in the ENTRY-FUNCTION slot. + ;; for is in the ENTRY-FUN slot. ;; ;; :TOPLEVEL ;; a top level lambda, holding a compiled top level form. ;; Compiled very much like NIL, but provides an indication of ;; top level context. A :TOPLEVEL lambda should have *no* - ;; references. Its ENTRY-FUNCTION is a self-pointer. + ;; references. Its ENTRY-FUN is a self-pointer. ;; ;; :TOPLEVEL-XEP ;; After a component is compiled, we clobber any top level code @@ -838,7 +838,7 @@ ;; :TOPLEVEL lambda (which is its own XEP) this is a self-pointer. ;; ;; With all other kinds, this is null. - (entry-function nil :type (or functional null)) + (entry-fun nil :type (or functional null)) ;; the value of any inline/notinline declaration for a local function (inlinep nil :type inlinep) ;; If we have a lambda that can be used as in inline expansion for diff --git a/src/compiler/represent.lisp b/src/compiler/represent.lisp index fb87aa5..a6a7480 100644 --- a/src/compiler/represent.lisp +++ b/src/compiler/represent.lisp @@ -323,7 +323,7 @@ t))) (frob lambda) (when tails - (dolist (fun (tail-set-functions tails)) + (dolist (fun (tail-set-funs tails)) (frob fun)))))) (values)) -- 1.7.10.4