(!def-boolean-attribute block
reoptimize flush-p type-check delete-p type-asserted test-modified)
-;;; FIXME: Tweak so that definitions of e.g. BLOCK-DELETE-P is
-;;; findable by grep for 'def.*block-delete-p'.
-(macrolet ((frob (slot)
- `(defmacro ,(symbolicate "BLOCK-" slot) (block)
- `(block-attributep (block-flags ,block) ,',slot))))
- (frob reoptimize)
- (frob flush-p)
- (frob type-check)
- (frob delete-p)
- (frob type-asserted)
- (frob test-modified))
+(macrolet ((defattr (block-slot)
+ `(defmacro ,block-slot (block)
+ `(block-attributep
+ (block-flags ,block)
+ ,(symbolicate (subseq (string ',block-slot) 6))))))
+ (defattr block-reoptimize)
+ (defattr block-flush-p)
+ (defattr block-type-check)
+ (defattr block-delete-p)
+ (defattr block-type-asserted)
+ (defattr block-test-modified))
;;; The CBLOCK structure represents a basic block. We include
;;; SSET-ELEMENT so that we can have sets of blocks. Initially the
(flag nil)
;; some kind of info used by the back end
(info nil)
- ;; what macroexpansions happened "in" this block, used for xref
- (macroexpands nil :type list)
+ ;; what macroexpansions and source transforms happened "in" this block, used
+ ;; for xref
+ (xrefs 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))))
kind
mess-up
(info :test info))
-(defmacro cleanup-nlx-info (cleanup)
- `(cleanup-info ,cleanup))
;;; A PHYSENV represents the result of physical environment analysis.
;;;
:read-only t)
;; the type which values of this leaf must have
(type *universal-type* :type ctype)
- ;; where the TYPE information came from:
+ ;; 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 (in order, from strongest to weakest):
;; :DECLARED, from a declaration.
+ ;; :DEFINED-HERE, from examination of the definition in the same file.
+ ;; :DEFINED, from examination of the definition elsewhere.
+ ;; :DEFINED-METHOD, implicit, piecemeal declarations from CLOS.
;; :ASSUMED, from uses of the object.
- ;; :DEFINED, from examination of the definition.
- ;; 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-here :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?
+ (extent nil :type (member nil :maybe-dynamic :always-dynamic :indefinite))
;; some kind of info used by the back end
(info nil))
+(defun leaf-dynamic-extent (leaf)
+ (let ((extent (leaf-extent leaf)))
+ (unless (member extent '(nil :indefinite))
+ extent)))
+
;;; LEAF name operations
;;;
;;; KLUDGE: wants CLOS..
(where-from :defined)))
(:include leaf))
;; the value of the constant
- (value (missing-arg) :type t))
+ (value (missing-arg) :type t)
+ ;; Boxed TN for this constant, if any.
+ (boxed-tn nil :type (or null tn)))
(defprinter (constant :identity t)
value)
(def!struct (global-var (:include basic-var))
;; kind of variable described
(kind (missing-arg)
- :type (member :special :global-function :global)))
+ :type (member :special :global-function :global :unknown)))
(defprinter (global-var :identity t)
%source-name
#!+sb-show id
(type :test (not (eq type *universal-type*)))
+ (defined-type :test (not (eq defined-type *universal-type*)))
(where-from :test (not (eq where-from :assumed)))
kind)
;; 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
;; the original function or macro lambda list, or :UNSPECIFIED if
;; this is a compiler created function
(arg-documentation nil :type (or list (member :unspecified)))
+ ;; the documentation string for the lambda
+ (documentation nil :type (or null string))
;; Node, allocating closure for this lambda. May be NIL when we are
;; sure that no closure is needed.
(allocator nil :type (or null combination))
;; 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))
+ ;; True if this functional was created from an inline expansion. This
+ ;; is either T, or the GLOBAL-VAR for which it is an expansion.
+ (inline-expanded nil))
(defprinter (functional :identity t)
%source-name
%debug-name
;; list of embedded lambdas
(children nil :type list)
(parent nil :type (or clambda null))
- (allow-instrumenting *allow-instrumenting* :type boolean))
+ (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
;; the default for a keyword or optional, represented as the
;; original Lisp code. This is set to NIL in &KEY arguments that are
;; defaulted using the SUPPLIED-P arg.
+ ;;
+ ;; For &REST arguments this may contain information about more context
+ ;; the rest list comes from.
(default nil :type t)
;; the actual key for a &KEY argument. Note that in ANSI CL this is
;; not necessarily a keyword: (DEFUN FOO (&KEY ((BAR BAR))) ...).
;; This is set by physical environment analysis if it chooses an
;; indirect (value cell) representation for this variable because it
;; is both set and closed over.
- indirect)
+ indirect
+ ;; true if the last reference has been deleted (and new references
+ ;; should not be made)
+ deleted
+ ;; This is set by physical environment analysis if, should it be an
+ ;; indirect lambda-var, an actual value cell object must be
+ ;; allocated for this variable because one or more of the closures
+ ;; that refer to it are not dynamic-extent. Note that both
+ ;; attributes must be set for the value-cell object to be created.
+ explicit-value-cell
+ )
(def!struct (lambda-var (:include basic-var))
(flags (lambda-var-attributes)
;; 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 |#))
+ ;; Content-addressed indices for the CONSTRAINTs on this variable.
+ ;; These are solely used by FIND-CONSTRAINT
+ (ctype-constraints nil :type (or null hash-table))
+ (eq-constraints nil :type (or null hash-table))
+ ;; sorted sets of constraints we like to iterate over
+ (eql-var-constraints nil :type (or null (array t 1)))
+ (inheritable-constraints nil :type (or null (array t 1)))
+ (private-constraints nil :type (or null (array t 1)))
;; 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
`(lambda-var-attributep (lambda-var-flags ,var) ignore))
(defmacro lambda-var-indirect (var)
`(lambda-var-attributep (lambda-var-flags ,var) indirect))
+(defmacro lambda-var-deleted (var)
+ `(lambda-var-attributep (lambda-var-flags ,var) deleted))
+(defmacro lambda-var-explicit-value-cell (var)
+ `(lambda-var-attributep (lambda-var-flags ,var) explicit-value-cell))
\f
;;;; basic node types
(%source-name (missing-arg) :type symbol :read-only t))
(defprinter (ref :identity t)
#!+sb-show id
- %source-name
+ (%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
(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))
+ ;; Untrusted type we have asserted for this combination.
+ (type-validated-for-leaf nil)
;; some kind of information attached to this node by the back end
(info nil)
(step-info))
projects / sbcl.git / blobdiff