X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fnode.lisp;h=e2635d20e5cb027374133e6e3acd766db1c80258;hb=1bfc464c657a8f4ad24ef612f76a38d8f6f1bbad;hp=ddde59eea4f1dcb564cb50c34e002a2a8d8a9f59;hpb=1a6def3955b715472eb2c75b15660912b9f90173;p=sbcl.git diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp index ddde59e..e2635d2 100644 --- a/src/compiler/node.lisp +++ b/src/compiler/node.lisp @@ -84,7 +84,7 @@ ;; cached type of this continuation's value. If NIL, then this must ;; be recomputed: see CONTINUATION-DERIVED-TYPE. (%derived-type nil :type (or ctype null)) - ;; Node where this continuation is used, if unique. This is always + ;; the node where this continuation is used, if unique. This is always ;; null in :DELETED and :UNUSED continuations, and is never null in ;; :INSIDE-BLOCK continuations. In a :BLOCK-START continuation, the ;; Block's START-USES indicate whether NIL means no uses or more @@ -304,7 +304,7 @@ (test-constraint nil :type (or sset null))) (def!method print-object ((cblock cblock) stream) (print-unreadable-object (cblock stream :type t :identity t) - (format stream ":START c~D" (cont-num (block-start cblock))))) + (format stream ":START c~W" (cont-num (block-start cblock))))) ;;; The BLOCK-ANNOTATION class is inherited (via :INCLUDE) by ;;; different BLOCK-INFO annotation structures so that code @@ -323,6 +323,14 @@ ;;; A COMPONENT structure provides a handle on a connected piece of ;;; the flow graph. Most of the passes in the compiler operate on ;;; COMPONENTs rather than on the entire flow graph. +;;; +;;; According to the CMU CL internals/front.tex, the reason for +;;; separating compilation into COMPONENTs is +;;; to increase the efficiency of large block compilations. In +;;; addition to improving locality of reference and reducing the +;;; size of flow analysis problems, this allows back-end data +;;; structures to be reclaimed after the compilation of each +;;; component. (defstruct (component (:copier nil)) ;; the kind of component ;; @@ -368,22 +376,22 @@ ;; deleted or LET lambdas. ;; ;; Note that logical associations between CLAMBDAs and COMPONENTs - ;; seem to exist for a while before this is initialized. In - ;; particular, I got burned by writing some code to use this value - ;; to decide which components need LOCAL-CALL-ANALYZE, when it turns - ;; out that LOCAL-CALL-ANALYZE had a role in initializing this value + ;; seem to exist for a while before this is initialized. See e.g. + ;; the NEW-FUNS slot. In particular, I got burned by writing some + ;; code to use this value to decide which components need + ;; LOCALL-ANALYZE-COMPONENT, when it turns out that + ;; LOCALL-ANALYZE-COMPONENT had a role in initializing this value ;; (and DFO stuff does too, maybe). Also, even after it's ;; initialized, it might change as CLAMBDAs are deleted or merged. ;; -- WHN 2001-09-30 (lambdas () :type list) - ;; a list of FUNCTIONAL structures for functions that are newly - ;; converted, and haven't been local-call analyzed yet. Initially - ;; functions are not in the LAMBDAS list. LOCAL-CALL-ANALYZE moves - ;; them there (possibly as LETs, or implicitly as XEPs if an - ;; OPTIONAL-DISPATCH.) Between runs of LOCAL-CALL-ANALYZE there may - ;; be some debris of converted or even deleted functions in this - ;; list. - (new-functions () :type list) + ;; a list of FUNCTIONALs for functions that are newly converted, and + ;; haven't been local-call analyzed yet. Initially functions are not + ;; in the LAMBDAS list. Local call analysis moves them there + ;; (possibly as LETs, or implicitly as XEPs if an OPTIONAL-DISPATCH.) + ;; Between runs of local call analysis there may be some debris of + ;; converted or even deleted functions in this list. + (new-funs () :type list) ;; If this is true, then there is stuff in this component that could ;; benefit from further IR1 optimization. (reoptimize t :type boolean) @@ -408,11 +416,11 @@ ;; arguments for the note, or the FUN-TYPE that would have ;; enabled the transformation but failed to match. (failed-optimizations (make-hash-table :test 'eq) :type hash-table) - ;; This is similar to NEW-FUNCTIONS, but is used when a function has + ;; This is similar to NEW-FUNS, but is used when a function has ;; already been analyzed, but new references have been added by - ;; inline expansion. Unlike NEW-FUNCTIONS, this is not disjoint from + ;; inline expansion. Unlike NEW-FUNS, this is not disjoint from ;; COMPONENT-LAMBDAS. - (reanalyze-functions nil :type list)) + (reanalyze-funs nil :type list)) (defprinter (component :identity t) name (reanalyze :test reanalyze)) @@ -488,7 +496,7 @@ ;;; TNs, or eventually stack slots and registers). -- WHN 2001-09-29 (defstruct (physenv (:copier nil)) ;; the function that allocates this physical environment - (function (missing-arg) :type clambda) + (lambda (missing-arg) :type clambda :read-only t) #| ; seems not to be used as of sbcl-0.pre7.51 ;; a list of all the lambdas that allocate variables in this ;; physical environment @@ -508,7 +516,7 @@ ;; some kind of info used by the back end (info nil)) (defprinter (physenv :identity t) - function + lambda (closure :test closure) (nlx-info :test nlx-info)) @@ -527,7 +535,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 +543,7 @@ ;; some info used by the back end (info nil)) (defprinter (tail-set :identity t) - functions + funs type (info :test info)) @@ -788,13 +796,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 +846,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 @@ -903,17 +911,16 @@ ;; If this CLAMBDA is a LET, then this slot holds the LAMBDA whose ;; LETS list we are in, otherwise it is a self-pointer. (home nil :type (or clambda null)) - ;; a list of all the all the lambdas that have been LET-substituted - ;; in this lambda. This is only non-null in lambdas that aren't - ;; LETs. - (lets () :type list) - ;; a list of all the ENTRY nodes in this function and its LETs, or - ;; null in a LET - (entries () :type list) - ;; a list of all the functions directly called from this function - ;; (or one of its LETs) using a non-LET local call. This may include - ;; deleted functions because nobody bothers to clear them out. - (calls () :type list) + ;; all the lambdas that have been LET-substituted in this lambda. + ;; This is only non-null in lambdas that aren't LETs. + (lets nil :type list) + ;; all the ENTRY nodes in this function and its LETs, or null in a LET + (entries nil :type list) + ;; CLAMBDAs which are locally called by this lambda, and other + ;; objects (closed-over LAMBDA-VARs and XEPs) which this lambda + ;; depends on in such a way that DFO shouldn't put them in separate + ;; components. + (calls-or-closes nil :type list) ;; the TAIL-SET that this LAMBDA is in. This is null during creation. ;; ;; In CMU CL, and old SBCL, this was also NILed out when LET @@ -1046,8 +1053,8 @@ ;;; LAMBDA-VARs with no REFs are considered to be deleted; physical ;;; environment analysis isn't done on these variables, so the back ;;; end must check for and ignore unreferenced variables. Note that a -;;; deleted lambda-var may have sets; in this case the back end is -;;; still responsible for propagating the Set-Value to the set's Cont. +;;; deleted LAMBDA-VAR may have sets; in this case the back end is +;;; still responsible for propagating the SET-VALUE to the set's CONT. (def!struct (lambda-var (:include basic-var)) ;; true if this variable has been declared IGNORE (ignorep nil :type boolean) @@ -1234,12 +1241,12 @@ ;;; original exit continuation is the exit node's CONT. (defstruct (exit (:include node) (:copier nil)) - ;; The Entry node that this is an exit for. If null, this is a + ;; the ENTRY node that this is an exit for. If null, this is a ;; degenerate exit. A degenerate exit is used to "fill" an empty ;; block (which isn't allowed in IR1.) In a degenerate exit, Value ;; is always also null. (entry nil :type (or entry null)) - ;; The continuation yeilding the value we are to exit with. If NIL, + ;; the continuation yielding the value we are to exit with. If NIL, ;; then no value is desired (as in GO). (value nil :type (or continuation null))) (defprinter (exit :identity t)