;; 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
;;; 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
;;
;;; 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
;; 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))
;;; 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.
;; some info used by the back end
(info nil))
(defprinter (tail-set :identity t)
- functions
+ funs
type
(info :test info))
;;
;; :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
;; :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
;; (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)
+ ;; a list of all the LAMBDA-VARs directly referred to from this
+ ;; function (or one of its LETs). This may include deleted variables
+ ;; because nobody bothers to clean them out.
+ ;;
+ ;; FIXME: This is completely analogous to the CALLS slot, except the
+ ;; elements here are LAMBDA-VARs instead of FUNCTIONALs. Maybe the
+ ;; two lists should be merged into a single list.
+ (refers-to-vars () :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
;;; 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)