;;; the largest number of TNs whose liveness changes that we can have
;;; in any block
-(defconstant local-tn-limit 64)
+(def!constant local-tn-limit 64)
(deftype local-tn-number () `(integer 0 (,local-tn-limit)))
(deftype local-tn-count () `(integer 0 ,local-tn-limit))
\f
;;;; IR1 annotations used for IR2 conversion
-;;; Block-Info
-;;; Holds the IR2-Block structure. If there are overflow blocks,
-;;; then this points to the first IR2-Block. The Block-Info of the
+;;; BLOCK-INFO
+;;; Holds the IR2-BLOCK structure. If there are overflow blocks,
+;;; then this points to the first IR2-BLOCK. The BLOCK-INFO of the
;;; dummy component head and tail are dummy IR2 blocks that begin
;;; and end the emission order thread.
;;;
-;;; Component-Info
-;;; Holds the IR2-Component structure.
+;;; COMPONENT-INFO
+;;; Holds the IR2-COMPONENT structure.
;;;
-;;; Continuation-Info
-;;; Holds the IR2-Continuation structure. Continuations whose
+;;; CONTINUATION-INFO
+;;; Holds the IR2-CONTINUATION structure. Continuations whose
;;; values aren't used won't have any.
;;;
-;;; Cleanup-Info
+;;; CLEANUP-INFO
;;; If non-null, then a TN in which the affected dynamic
;;; environment pointer should be saved after the binding is
;;; instantiated.
;;;
-;;; Physenv-Info
-;;; Holds the Ir2-Physenv structure.
+;;; PHYSENV-INFO
+;;; Holds the IR2-PHYSENV structure.
;;;
-;;; Tail-Set-Info
-;;; Holds the Return-Info structure.
+;;; TAIL-SET-INFO
+;;; Holds the RETURN-INFO structure.
;;;
-;;; NLX-Info-Info
-;;; Holds the IR2-NLX-Info structure.
+;;; NLX-INFO-INFO
+;;; Holds the IR2-NLX-INFO structure.
;;;
-;;; Leaf-Info
+;;; LEAF-INFO
;;; If a non-set lexical variable, the TN that holds the value in
;;; the home environment. If a constant, then the corresponding
;;; constant TN. If an XEP lambda, then the corresponding
;;; Entry-Info structure.
;;;
-;;; Basic-Combination-Info
+;;; BASIC-COMBINATION-INFO
;;; The template chosen by LTN, or
;;; :FULL if this is definitely a full call.
;;; :FUNNY if this is an oddball thing with IR2-convert.
;;; :LOCAL if this is a local call.
;;;
-;;; Node-Tail-P
+;;; NODE-TAIL-P
;;; After LTN analysis, this is true only in combination nodes that are
;;; truly tail recursive.
;; Similarly, a continuation is POPPED if its DEST is in this block
;; but has its uses elsewhere. The continuations are in the order
;; that are pushed/popped in the block. Note that the args to a
- ;; single MV-Combination appear reversed in POPPED, since we must
+ ;; single MV-COMBINATION appear reversed in POPPED, since we must
;; effectively pop the last argument first. All pops must come
;; before all pushes (although internal MV uses may be interleaved.)
;; POPPED is computed by LTN, and PUSHED is computed by stack
;; assign all the more args one LTN number, and all the more results
;; another LTN number. We can do this, since more operands are
;; referenced simultaneously as far as conflict analysis is
- ;; concerned. Note that all these :More TNs will be global TNs.
+ ;; concerned. Note that all these :MORE TNs will be global TNs.
(local-tns (make-array local-tn-limit) :type local-tn-vector)
;; Bit-vectors used during lifetime analysis to keep track of
;; references to local TNs. When indexed by the LTN number, the
- ;; index for a TN is non-zero in Written if it is ever written in
- ;; the block, and in Live-Out if the first reference is a read.
+ ;; index for a TN is non-zero in WRITTEN if it is ever written in
+ ;; the block, and in LIVE-OUT if the first reference is a read.
(written (make-array local-tn-limit :element-type 'bit
:initial-element 0)
:type local-tn-bit-vector)
:type local-tn-bit-vector)
;; This is similar to the above, but is updated by lifetime flow
;; analysis to have a 1 for LTN numbers of TNs live at the end of
- ;; the block. This takes into account all TNs that aren't :Live.
- (live-in (make-array local-tn-limit :element-type 'bit
- :initial-element 0)
+ ;; the block. This takes into account all TNs that aren't :LIVE.
+ (live-in (make-array local-tn-limit :element-type 'bit :initial-element 0)
:type local-tn-bit-vector)
;; a thread running through the global-conflicts structures for this
;; block, sorted by TN number
;; CONSTANT-TNs are non-packed TNs that represent constants.
;; :CONSTANT TNs may eventually be converted to :CACHED-CONSTANT
;; normal TNs.
+ ;;
+ ;; FIXME: What is :CACHED-CONSTANT?
(normal-tns nil :type (or tn null))
(restricted-tns nil :type (or tn null))
(wired-tns nil :type (or tn null))
;; overhead that is eventually stuffed in somehow.
(constants (make-array 10 :fill-pointer 0 :adjustable t) :type vector)
;; some kind of info about the component's run-time representation.
- ;; This is filled in by the VM supplied Select-Component-Format function.
+ ;; This is filled in by the VM supplied SELECT-COMPONENT-FORMAT function.
format
;; a list of the ENTRY-INFO structures describing all of the entries
;; into this component. Filled in by entry analysis.
(entries nil :type list)
- ;; Head of the list of :ALIAS TNs in this component, threaded by TN-NEXT.
+ ;; head of the list of :ALIAS TNs in this component, threaded by TN-NEXT
(alias-tns nil :type (or tn null))
;; SPILLED-VOPS is a hashtable translating from "interesting" VOPs
;; to a list of the TNs spilled at that VOP. This is used when
(:copier nil))
;; VOP-INFO structure containing static info about the operation
(info nil :type (or vop-info null))
- ;; the IR2-Block this VOP is in
+ ;; the IR2-BLOCK this VOP is in
(block (missing-arg) :type ir2-block)
;; VOPs evaluated after and before this one. Null at the
;; beginning/end of the block, and temporarily during IR2
(info-arg-count 0 :type index)
;; a function that emits the VOPs for this template. Arguments:
;; 1] Node for source context.
- ;; 2] IR2-Block that we place the VOP in.
+ ;; 2] IR2-BLOCK that we place the VOP in.
;; 3] This structure.
- ;; 4] Head of argument TN-Ref list.
- ;; 5] Head of result TN-Ref list.
- ;; 6] If Info-Arg-Count is non-zero, then a list of the magic
+ ;; 4] Head of argument TN-REF list.
+ ;; 5] Head of result TN-REF list.
+ ;; 6] If INFO-ARG-COUNT is non-zero, then a list of the magic
;; arguments.
;;
;; Two values are returned: the first and last VOP emitted. This vop
(def!struct (vop-info
(:include template)
(:make-load-form-fun ignore-it))
- ;; side-effects of this VOP and side-effects that affect the value
+ ;; side effects of this VOP and side effects that affect the value
;; of this VOP
(effects (missing-arg) :type attributes)
(affected (missing-arg) :type attributes)
;;; Boxed-Reg: any boxed register (any boxed object)
;;; Unboxed-Reg: any unboxed register (any unboxed object)
;;; Float-Reg, Double-Float-Reg: float in FP register.
-;;; Stack: boxed object on the stack (on cstack)
+;;; Stack: boxed object on the stack (on control stack)
;;; Word: any 32bit unboxed object on nstack.
;;; Double: any 64bit unboxed object on nstack.
;; wired TNs.
(primitive-type nil :type (or primitive-type null))
;; If this TN represents a variable or constant, then this is the
- ;; corresponding Leaf.
+ ;; corresponding LEAF.
(leaf nil :type (or leaf null))
;; thread that links TNs together so that we can find them
(next nil :type (or tn null))
- ;; head of TN-Ref lists for reads and writes of this TN
+ ;; head of TN-REF lists for reads and writes of this TN
(reads nil :type (or tn-ref null))
(writes nil :type (or tn-ref null))
;; a link we use when building various temporary TN lists
(next* nil :type (or tn null))
- ;; some block that contains a reference to this TN, or Nil if we
+ ;; some block that contains a reference to this TN, or NIL if we
;; haven't seen any reference yet. If the TN is local, then this is
;; the block it is local to.
(local nil :type (or ir2-block null))
;; If a local TN, the block relative number for this TN. Global TNs
;; whose liveness changes within a block are also assigned a local
;; number during the conflicts analysis of that block. If the TN has
- ;; no local number within the block, then this is Nil.
+ ;; no local number within the block, then this is NIL.
(local-number nil :type (or local-tn-number null))
;; If this object is a local TN, this slot is a bit-vector with 1
;; for the local-number of every TN that we conflict with.
- (local-conflicts (make-array local-tn-limit :element-type 'bit
+ (local-conflicts (make-array local-tn-limit
+ :element-type 'bit
:initial-element 0)
:type local-tn-bit-vector)
;; head of the list of GLOBAL-CONFLICTS structures for a global TN.
;; the intersection between the lifetimes for two global TNs to be
;; easily found. If null, then this TN is a local TN.
(global-conflicts nil :type (or global-conflicts null))
- ;; during lifetime analysis, this is used as a pointer into the
- ;; conflicts chain, for scanning through blocks in reverse DFO
+ ;; During lifetime analysis, this is used as a pointer into the
+ ;; conflicts chain, for scanning through blocks in reverse DFO.
(current-conflict nil)
;; In a :SAVE TN, this is the TN saved. In a :NORMAL or :ENVIRONMENT
;; TN, this is the associated save TN. In TNs with no save TN, this
(defstruct (global-conflicts
(:constructor make-global-conflicts (kind tn block number))
(:copier nil))
- ;; the IR2-Block that this structure represents the conflicts for
+ ;; the IR2-BLOCK that this structure represents the conflicts for
(block (missing-arg) :type ir2-block)
- ;; thread running through all the Global-Conflict for Block. This
+ ;; thread running through all the GLOBAL-CONFLICTSs for BLOCK. This
;; thread is sorted by TN number
- (next nil :type (or global-conflicts null))
- ;; the way that TN is used by Block
+ (next-blockwise nil :type (or global-conflicts null))
+ ;; the way that TN is used by BLOCK
;;
- ;; :READ
- ;; The TN is read before it is written. It starts the block live,
- ;; but is written within the block.
+ ;; :READ
+ ;; The TN is read before it is written. It starts the block live,
+ ;; but is written within the block.
;;
- ;; :WRITE
- ;; The TN is written before any read. It starts the block dead,
- ;; and need not have a read within the block.
+ ;; :WRITE
+ ;; The TN is written before any read. It starts the block dead,
+ ;; and need not have a read within the block.
;;
- ;; :READ-ONLY
- ;; The TN is read, but never written. It starts the block live,
- ;; and is not killed by the block. Lifetime analysis will promote
- ;; :Read-Only TNs to :Live if they are live at the block end.
+ ;; :READ-ONLY
+ ;; The TN is read, but never written. It starts the block live,
+ ;; and is not killed by the block. Lifetime analysis will promote
+ ;; :READ-ONLY TNs to :LIVE if they are live at the block end.
;;
- ;; :LIVE
- ;; The TN is not referenced. It is live everywhere in the block.
+ ;; :LIVE
+ ;; The TN is not referenced. It is live everywhere in the block.
(kind :read-only :type (member :read :write :read-only :live))
;; a local conflicts vector representing conflicts with TNs live in
- ;; Block. The index for the local TN number of each TN we conflict
- ;; with in this block is 1. To find the full conflict set, the :Live
- ;; TNs for Block must also be included. This slot is not meaningful
- ;; when Kind is :Live.
+ ;; BLOCK. The index for the local TN number of each TN we conflict
+ ;; with in this block is 1. To find the full conflict set, the :LIVE
+ ;; TNs for BLOCK must also be included. This slot is not meaningful
+ ;; when KIND is :LIVE.
(conflicts (make-array local-tn-limit
:element-type 'bit
:initial-element 0)
:type local-tn-bit-vector)
;; the TN we are recording conflicts for.
(tn (missing-arg) :type tn)
- ;; thread through all the Global-Conflicts for TN
- (tn-next nil :type (or global-conflicts null))
- ;; TN's local TN number in Block. :Live TNs don't have local numbers.
+ ;; thread through all the GLOBAL-CONFLICTSs for TN
+ (next-tnwise nil :type (or global-conflicts null))
+ ;; TN's local TN number in BLOCK. :LIVE TNs don't have local numbers.
(number nil :type (or local-tn-number null)))
(defprinter (global-conflicts)
tn
projects / sbcl.git / blobdiff