;; 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))
(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)
;; 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))
;;; 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-)
(gen nil)
(in nil)
(out nil)
+ ;; Set of all blocks that dominate this block. NIL is interpreted
+ ;; as "all blocks in component".
+ (dominators nil :type (or null sset))
+ ;; the LOOP that this block belongs to
+ (loop nil :type (or null cloop))
+ ;; next block in the loop.
+ (loop-next nil :type (or null cblock))
;; the component this block is in, or NIL temporarily during IR1
;; conversion and in deleted blocks
(component (progn
;;; 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)
;;; 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
;; has already been analyzed, but new references have been added by
;; inline expansion. Unlike NEW-FUNCTIONALS, this is not disjoint
;; from COMPONENT-LAMBDAS.
- (reanalyze-functionals nil :type list))
+ (reanalyze-functionals 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)
+ ;; The default LOOP in the component.
+ (outer-loop (make-loop :kind :outer :head head) :type cloop))
(defprinter (component :identity t)
name
#!+sb-show id
;;; 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 :block :tagbody))
+ :type (member :special-bind :catch :unwind-protect
+ :block :tagbody :dynamic-extent))
;; the node that messes things up. This is the last node in the
;; 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.
;;;
;;; 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
;;; 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.
;; true if there was ever a REF or SET node for this leaf. This may
;; be true when REFS and SETS are null, since code can be deleted.
(ever-used nil :type boolean)
+ ;; is it declared dynamic-extent?
+ (dynamic-extent nil :type boolean)
;; some kind of info used by the back end
(info nil))
;; :DELETED
;; This function has been found to be uncallable, and has been
;; marked for deletion.
+ ;;
+ ;; :ZOMBIE
+ ;; Effectless [MV-]LET; has no BIND node.
(kind nil :type (member nil :optional :deleted :external :toplevel
:escape :cleanup :let :mv-let :assignment
- :toplevel-xep))
+ :zombie :toplevel-xep))
;; Is this a function that some external entity (e.g. the fasl dumper)
;; refers to, so that even when it appears to have no references, it
;; shouldn't be deleted? In the old days (before
;;; 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))
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)
consequent
alternative)
-(defstruct (cset (:include valued-node
+(def!struct (cset (:include valued-node
(derived-type (make-single-value-type
*universal-type*)))
(:conc-name set-)
;;; 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
(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)
"<deleted>"))
args)))
-(defun call-full-like-p (call)
- (declare (type combination call))
- (let ((kind (basic-combination-kind call)))
- (or (eq kind :full)
- (and (fun-info-p kind)
- (null (fun-info-templates kind))
- (not (fun-info-ir2-convert kind))))))
-
;;; 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)
;;; 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.
;;; 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)
;;; 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)
;; NIL
;; No type check is necessary (VALUE type is a subtype of the TYPE-TO-CHECK.)
;;
+ ;; :EXTERNAL
+ ;; Type check will be performed by NODE-DEST.
+ ;;
;; T
;; A type check is needed.
- (%type-check t :type (member t nil))
+ (%type-check t :type (member t :external nil))
;; the lvar which is checked
(value (missing-arg) :type lvar))
(defprinter (cast :identity t)
;;; 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)
;;; 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
\f
;;;; 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)
projects / sbcl.git / blobdiff