(format stream "~D" (cont-num x))))
(def!struct (node (:constructor nil)
+ (:include sset-element (number (incf *compiler-sset-counter*)))
(:copier nil))
;; unique ID for debugging
#!+sb-show (id (new-object-id) :read-only t)
;; entire initial component just to clear the flags.
(flag nil)
;; some kind of info used by the back end
- (info nil))
+ (info nil)
+ ;; what macroexpansions happened "in" this block, used for xref
+ (macroexpands nil :type list)
+ ;; Cache the physenv of a block during lifetime analysis. :NONE if
+ ;; no cached value has been stored yet.
+ (physenv-cache :none :type (or null physenv (member :none))))
(def!method print-object ((cblock cblock) stream)
(print-unreadable-object (cblock stream :type t :identity t)
(format stream "~W :START c~W"
;; on me (e.g. by using me as *CURRENT-COMPONENT*, or by pushing
;; LAMBDAs onto my NEW-FUNCTIONALS, as in sbcl-0.pre7.115).
(info :no-ir2-yet :type (or ir2-component (member :no-ir2-yet :dead)))
- ;; the SOURCE-INFO structure describing where this component was
- ;; compiled from
- (source-info *source-info* :type source-info)
;; count of the number of inline expansions we have done while
;; compiling this component, to detect infinite or exponential
;; blowups
;; this is filled by physical environment analysis
(dx-lvars nil :type list)
;; The default LOOP in the component.
- (outer-loop (missing-arg) :type cloop))
+ (outer-loop (missing-arg) :type cloop)
+ ;; The current sset index
+ (sset-number 0 :type fixnum))
(defprinter (component :identity t)
name
#!+sb-show id
kind
mess-up
(info :test info))
-(defmacro cleanup-nlx-info (cleanup)
- `(cleanup-info ,cleanup))
;;; A PHYSENV represents the result of physical environment analysis.
;;;
;;; allows us to easily substitute one for the other without actually
;;; hacking the flow graph.
(def!struct (leaf (:make-load-form-fun ignore-it)
+ (:include sset-element (number (incf *compiler-sset-counter*)))
(:constructor nil))
;; unique ID for debugging
#!+sb-show (id (new-object-id) :read-only t)
:read-only t)
;; the type which values of this leaf must have
(type *universal-type* :type ctype)
+ ;; the type which values of this leaf have last been defined to have
+ ;; (but maybe won't have in future, in case of redefinition)
+ (defined-type *universal-type* :type ctype)
;; where the TYPE information came from:
;; :DECLARED, from a declaration.
;; :ASSUMED, from uses of the object.
;; :DEFINED, from examination of the definition.
+ ;; :DEFINED-METHOD, implicit, piecemeal declarations from CLOS.
;; FIXME: This should be a named type. (LEAF-WHERE-FROM? Or
;; perhaps just WHERE-FROM, since it's not just used in LEAF,
;; but also in various DEFINE-INFO-TYPEs in globaldb.lisp,
;; and very likely elsewhere too.)
- (where-from :assumed :type (member :declared :assumed :defined))
+ (where-from :assumed :type (member :declared :assumed :defined :defined-method))
;; list of the REF nodes for this leaf
(refs () :type list)
;; 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)
+ ;; is it declared dynamic-extent, or truly-dynamic-extent?
+ (dynamic-extent nil :type (member nil t :truly))
;; some kind of info used by the back end
(info nil))
;; it looks as though it's never interesting to get debug names
;; from them, so it's moot. -- WHN)
(leaf-source-name leaf)))
+(defun leaf-%debug-name (leaf)
+ (when (functional-p leaf)
+ (functional-%debug-name leaf)))
;;; The CONSTANT structure is used to represent known constant values.
-;;; If NAME is not null, then it is the name of the named constant
-;;; which this leaf corresponds to, otherwise this is an anonymous
-;;; constant.
-(def!struct (constant (:include leaf))
+;;; Since the same constant leaf may be shared between named and anonymous
+;;; constants, %SOURCE-NAME is never used.
+(def!struct (constant (:constructor make-constant (value
+ &aux
+ (type (ctype-of value))
+ (%source-name '.anonymous.)
+ (where-from :defined)))
+ (:include leaf))
;; the value of the constant
- (value nil :type t))
+ (value (missing-arg) :type t))
(defprinter (constant :identity t)
- (%source-name :test %source-name)
value)
;;; The BASIC-VAR structure represents information common to all
;; global environment.
(inlinep nil :type inlinep)
(inline-expansion nil :type (or cons null))
- ;; the block-local definition of this function (either because it
- ;; was semi-inline, or because it was defined in this block). If
- ;; this function is not an entry point, then this may be deleted or
- ;; LET-converted. Null if we haven't converted the expansion yet.
- (functional nil :type (or functional null)))
+ ;; List of functionals corresponding to this DEFINED-FUN: either from the
+ ;; conversion of a NAMED-LAMBDA, or from inline-expansion (see
+ ;; RECOGNIZE-KNOWN-CALL) - we need separate functionals for each policy in
+ ;; which the function is used.
+ (functionals nil :type list))
(defprinter (defined-fun :identity t)
%source-name
#!+sb-show id
inlinep
- (functional :test functional))
+ (functionals :test functionals))
\f
;;;; function stuff
;; sure that no closure is needed.
(allocator nil :type (or null combination))
;; various rare miscellaneous info that drives code generation & stuff
- (plist () :type list))
+ (plist () :type list)
+ ;; xref information for this functional (only used for functions with an
+ ;; XEP)
+ (xref () :type list)
+ ;; True if this functional was created from an inline expansion
+ (inline-expanded nil :type boolean))
(defprinter (functional :identity t)
%source-name
%debug-name
;; 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)
+ (calls-or-closes (make-sset) :type (or null sset))
;; 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
(call-lexenv nil :type (or lexenv null))
;; list of embedded lambdas
(children nil :type list)
- (parent nil :type (or clambda null)))
+ (parent nil :type (or clambda null))
+ (allow-instrumenting *allow-instrumenting* :type boolean)
+ ;; True if this is a system introduced lambda: it may contain user code, but
+ ;; the lambda itself is not, and the bindings introduced by it are considered
+ ;; transparent by the nested DX analysis.
+ (system-lambda-p nil :type boolean))
(defprinter (clambda :conc-name lambda- :identity t)
%source-name
%debug-name
;; propagation. This is left null by the lambda pre-pass if it
;; determine that this is a set closure variable, and is thus not a
;; good subject for flow analysis.
- (constraints nil :type (or sset null)))
+ (constraints nil :type (or null t #| FIXME: conset |#))
+ ;; Initial type of a LET variable as last seen by PROPAGATE-FROM-SETS.
+ (last-initial-type *universal-type* :type ctype)
+ ;; The FOP handle of the lexical variable represented by LAMBDA-VAR
+ ;; in the fopcompiler.
+ (fop-value nil))
(defprinter (lambda-var :identity t)
%source-name
#!+sb-show id
(def!struct (ref (:include valued-node (reoptimize nil))
(:constructor make-ref
(leaf
+ &optional (%source-name '.anonymous.)
&aux (leaf-type (leaf-type leaf))
(derived-type
(make-single-value-type leaf-type))))
(:copier nil))
;; The leaf referenced.
- (leaf nil :type leaf))
+ (leaf nil :type leaf)
+ ;; CONSTANT nodes are always anonymous, since we wish to coalesce named and
+ ;; unnamed constants that are equivalent, we need to keep track of the
+ ;; reference name for XREF.
+ (%source-name (missing-arg) :type symbol :read-only t))
(defprinter (ref :identity t)
#!+sb-show id
+ (%source-name :test (neq %source-name '.anonymous.))
leaf)
;;; Naturally, the IF node always appears at the end of a block.
;; the blocks that we execute next in true and false case,
;; respectively (may be the same)
(consequent (missing-arg) :type cblock)
- (consequent-constraints nil :type (or null sset))
+ (consequent-constraints nil :type (or null t #| FIXME: conset |#))
(alternative (missing-arg) :type cblock)
- (alternative-constraints nil :type (or null sset)))
+ (alternative-constraints nil :type (or null t #| FIXME: conset |#)))
(defprinter (cif :conc-name if- :identity t)
(test :prin1 (lvar-uses test))
consequent
;; 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))
+ (info nil)
+ (step-info))
;;; The COMBINATION node represents all normal function calls,
;;; including FUNCALL. This is distinct from BASIC-COMBINATION so that
projects / sbcl.git / blobdiff