X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fnode.lisp;h=d9ff1ebaea1297acb4dfde36da48d1e0bdc7ca43;hb=f705c517d8606a9a72edd11a96725f9c4e4be93d;hp=b0bdde3b2256529e6ee55b8042315e7f19fc35e1;hpb=304c44d731bea3b9ce3c47d864d90eac92ba604e;p=sbcl.git diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp index b0bdde3..d9ff1eb 100644 --- a/src/compiler/node.lisp +++ b/src/compiler/node.lisp @@ -76,6 +76,8 @@ ;; Cached type which is checked by DEST. If NIL, then this must be ;; recomputed: see LVAR-EXTERNALLY-CHECKABLE-TYPE. (%externally-checkable-type nil :type (or null ctype)) + ;; if the LVAR value is DYNAMIC-EXTENT, CLEANUP protecting it. + (dynamic-extent nil :type (or null cleanup)) ;; something or other that the back end annotates this lvar with (info nil)) @@ -83,7 +85,7 @@ (print-unreadable-object (x stream :type t :identity t) (format stream " #~D" (cont-num x)))) -(defstruct (node (:constructor nil) +(def!struct (node (:constructor nil) (:copier nil)) ;; unique ID for debugging #!+sb-show (id (new-object-id) :read-only t) @@ -134,7 +136,7 @@ ;; can null out this slot. (tail-p nil :type boolean)) -(defstruct (valued-node (:conc-name node-) +(def!struct (valued-node (:conc-name node-) (:include node) (:constructor nil) (:copier nil)) @@ -189,7 +191,7 @@ ;;; order. This latter numbering also forms the basis of the block ;;; numbering in the debug-info (though that is relative to the start ;;; of the function.) -(defstruct (cblock (:include sset-element) +(def!struct (cblock (:include sset-element) (:constructor make-block (start)) (:constructor make-block-key) (:conc-name block-) @@ -250,7 +252,7 @@ ;;; The BLOCK-ANNOTATION class is inherited (via :INCLUDE) by ;;; different BLOCK-INFO annotation structures so that code ;;; (specifically control analysis) can be shared. -(defstruct (block-annotation (:constructor nil) +(def!struct (block-annotation (:constructor nil) (:copier nil)) ;; The IR1 block that this block is in the INFO for. (block (missing-arg) :type cblock) @@ -272,9 +274,9 @@ ;;; size of flow analysis problems, this allows back-end data ;;; structures to be reclaimed after the compilation of each ;;; component. -(defstruct (component (:copier nil) - (:constructor - make-component (head tail &aux (last-block tail)))) +(def!struct (component (:copier nil) + (:constructor + make-component (head tail &aux (last-block tail)))) ;; unique ID for debugging #!+sb-show (id (new-object-id) :read-only t) ;; the kind of component @@ -373,7 +375,10 @@ ;; inline expansion. Unlike NEW-FUNCTIONALS, this is not disjoint ;; from COMPONENT-LAMBDAS. (reanalyze-functionals nil :type list) - (delete-blocks nil :type list)) + (delete-blocks nil :type list) + (nlx-info-generated-p nil :type boolean) + ;; this is filled by physical environment analysis + (dx-lvars nil :type list)) (defprinter (component :identity t) name #!+sb-show id @@ -420,7 +425,7 @@ ;;; boundaries by requiring that the exit ctrans initially head their ;;; blocks, and then by not merging blocks when there is a cleanup ;;; change. -(defstruct (cleanup (:copier nil)) +(def!struct (cleanup (:copier nil)) ;; the kind of thing that has to be cleaned up (kind (missing-arg) :type (member :special-bind :catch :unwind-protect @@ -429,13 +434,21 @@ ;; non-messed-up environment. Null only temporarily. This could be ;; deleted due to unreachability. (mess-up nil :type (or node null)) - ;; a list of all the NLX-INFO structures whose NLX-INFO-CLEANUP is - ;; this cleanup. This is filled in by physical environment analysis. - (nlx-info nil :type list)) + ;; For all kinds, except :DYNAMIC-EXTENT: a list of all the NLX-INFO + ;; structures whose NLX-INFO-CLEANUP is this cleanup. This is filled + ;; in by physical environment analysis. + ;; + ;; For :DYNAMIC-EXTENT: a list of all DX LVARs, preserved by this + ;; cleanup. This is filled when the cleanup is created (now by + ;; locall call analysis) and is rechecked by physical environment + ;; analysis. + (info nil :type list)) (defprinter (cleanup :identity t) kind mess-up - (nlx-info :test nlx-info)) + (info :test info)) +(defmacro cleanup-nlx-info (cleanup) + `(cleanup-info ,cleanup)) ;;; A PHYSENV represents the result of physical environment analysis. ;;; @@ -459,7 +472,7 @@ ;;; structure is attached to INFO and used to keep track of ;;; associations between these names and less-abstract things (like ;;; TNs, or eventually stack slots and registers). -- WHN 2001-09-29 -(defstruct (physenv (:copier nil)) +(def!struct (physenv (:copier nil)) ;; the function that allocates this physical environment (lambda (missing-arg) :type clambda :read-only t) ;; This ultimately converges to a list of all the LAMBDA-VARs and @@ -493,7 +506,7 @@ ;;; The tail set is somewhat approximate, because it is too early to ;;; be sure which calls will be tail-recursive. Any call that *might* ;;; end up tail-recursive causes TAIL-SET merging. -(defstruct (tail-set) +(def!struct (tail-set) ;; a list of all the LAMBDAs in this tail set (funs nil :type list) ;; our current best guess of the type returned by these functions. @@ -1094,7 +1107,7 @@ ;;; A REF represents a reference to a LEAF. REF-REOPTIMIZE is ;;; initially (and forever) NIL, since REFs don't receive any values ;;; and don't have any IR1 optimizer. -(defstruct (ref (:include valued-node (reoptimize nil)) +(def!struct (ref (:include valued-node (reoptimize nil)) (:constructor make-ref (leaf &aux (leaf-type (leaf-type leaf)) @@ -1108,7 +1121,7 @@ leaf) ;;; Naturally, the IF node always appears at the end of a block. -(defstruct (cif (:include node) +(def!struct (cif (:include node) (:conc-name if-) (:predicate if-p) (:constructor make-if) @@ -1124,7 +1137,7 @@ consequent alternative) -(defstruct (cset (:include valued-node +(def!struct (cset (:include valued-node (derived-type (make-single-value-type *universal-type*))) (:conc-name set-) @@ -1143,7 +1156,7 @@ ;;; and multiple value combinations. In a let-like function call, this ;;; node appears at the end of its block and the body of the called ;;; function appears as the successor; the NODE-LVAR is null. -(defstruct (basic-combination (:include valued-node) +(def!struct (basic-combination (:include valued-node) (:constructor nil) (:copier nil)) ;; LVAR for the function @@ -1154,20 +1167,23 @@ (args nil :type list) ;; the kind of function call being made. :LOCAL means that this is a ;; local call to a function in the same component, and that argument - ;; syntax checking has been done, etc. Calls to known global - ;; functions are represented by storing the FUN-INFO for the - ;; function in this slot. :FULL is a call to an (as yet) unknown - ;; function. :ERROR is like :FULL, but means that we have discovered - ;; that the call contains an error, and should not be reconsidered - ;; for optimization. - (kind :full :type (or (member :local :full :error) fun-info)) + ;; syntax checking has been done, etc. Calls to known global + ;; functions are represented by storing :KNOWN in this slot and the + ;; FUN-INFO for that function in the FUN-INFO slot. :FULL is a call + ;; to an (as yet) unknown function, or to a known function declared + ;; NOTINLINE. :ERROR is like :FULL, but means that we have + ;; discovered that the call contains an error, and should not be + ;; reconsidered for optimization. + (kind :full :type (member :local :full :error :known)) + ;; if a call to a known global function, contains the FUN-INFO. + (fun-info nil :type (or fun-info null)) ;; some kind of information attached to this node by the back end (info nil)) ;;; The COMBINATION node represents all normal function calls, ;;; including FUNCALL. This is distinct from BASIC-COMBINATION so that ;;; an MV-COMBINATION isn't COMBINATION-P. -(defstruct (combination (:include basic-combination) +(def!struct (combination (:include basic-combination) (:constructor make-combination (fun)) (:copier nil))) (defprinter (combination :identity t) @@ -1182,7 +1198,7 @@ ;;; An MV-COMBINATION is to MULTIPLE-VALUE-CALL as a COMBINATION is to ;;; FUNCALL. This is used to implement all the multiple-value ;;; receiving forms. -(defstruct (mv-combination (:include basic-combination) +(def!struct (mv-combination (:include basic-combination) (:constructor make-mv-combination (fun)) (:copier nil))) (defprinter (mv-combination) @@ -1191,7 +1207,7 @@ ;;; The BIND node marks the beginning of a lambda body and represents ;;; the creation and initialization of the variables. -(defstruct (bind (:include node) +(def!struct (bind (:include node) (:copier nil)) ;; the lambda we are binding variables for. Null when we are ;; creating the LAMBDA during IR1 translation. @@ -1203,7 +1219,7 @@ ;;; return values and represents the control transfer on return. This ;;; is also where we stick information used for TAIL-SET type ;;; inference. -(defstruct (creturn (:include node) +(def!struct (creturn (:include node) (:conc-name return-) (:predicate return-p) (:constructor make-return) @@ -1225,7 +1241,7 @@ ;;; The CAST node represents type assertions. The check for ;;; TYPE-TO-CHECK is performed and then the VALUE is declared to be of ;;; type ASSERTED-TYPE. -(defstruct (cast (:include valued-node) +(def!struct (cast (:include valued-node) (:constructor %make-cast)) (asserted-type (missing-arg) :type ctype) (type-to-check (missing-arg) :type ctype) @@ -1257,7 +1273,7 @@ ;;; The ENTRY node serves to mark the start of the dynamic extent of a ;;; lexical exit. It is the mess-up node for the corresponding :ENTRY ;;; cleanup. -(defstruct (entry (:include node) +(def!struct (entry (:include node) (:copier nil)) ;; All of the EXIT nodes for potential non-local exits to this point. (exits nil :type list) @@ -1271,8 +1287,9 @@ ;;; continuation and the exit continuation's DEST. Instead of using ;;; the returned value being delivered directly to the exit ;;; continuation, it is delivered to our VALUE lvar. The original exit -;;; lvar is the exit node's LVAR. -(defstruct (exit (:include valued-node) +;;; lvar is the exit node's LVAR; physenv analysis also makes it the +;;; lvar of %NLX-ENTRY call. +(def!struct (exit (:include valued-node) (:copier nil)) ;; 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 @@ -1289,7 +1306,7 @@ ;;;; miscellaneous IR1 structures -(defstruct (undefined-warning +(def!struct (undefined-warning #-no-ansi-print-object (:print-object (lambda (x s) (print-unreadable-object (x s :type t)