X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fnode.lisp;h=2e5fd521046174c98b15c91e433dbddcc32df32a;hb=HEAD;hp=ed0676e5c81bf095cf96730a1236763df9e02bb0;hpb=e3113504fca73ebd1b992930315386d9d3ae5d18;p=sbcl.git diff --git a/src/compiler/node.lisp b/src/compiler/node.lisp index ed0676e..2e5fd52 100644 --- a/src/compiler/node.lisp +++ b/src/compiler/node.lisp @@ -173,17 +173,17 @@ (!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 @@ -248,8 +248,9 @@ (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)))) @@ -465,8 +466,6 @@ kind mess-up (info :test info)) -(defmacro cleanup-nlx-info (cleanup) - `(cleanup-info ,cleanup)) ;;; A PHYSENV represents the result of physical environment analysis. ;;; @@ -620,26 +619,28 @@ ;; 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: + ;; where the TYPE information came from (in order, from strongest to weakest): ;; :DECLARED, from a declaration. - ;; :ASSUMED, from uses of the object. - ;; :DEFINED, from examination of the definition. + ;; :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. - ;; 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 :defined-method)) + ;; :ASSUMED, from uses of the object. + (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, or truly-dynamic-extent? - (dynamic-extent nil :type (member nil t :truly)) + (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.. @@ -675,7 +676,9 @@ (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) @@ -691,11 +694,12 @@ (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) @@ -711,16 +715,16 @@ ;; 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)) ;;;; function stuff @@ -863,6 +867,8 @@ ;; 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)) @@ -871,8 +877,9 @@ ;; 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 @@ -1073,6 +1080,9 @@ ;; 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))) ...). @@ -1100,7 +1110,17 @@ ;; 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) @@ -1122,6 +1142,14 @@ ;; determine that this is a set closure variable, and is thus not a ;; good subject for flow analysis. (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 @@ -1141,6 +1169,10 @@ `(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)) ;;;; basic node types @@ -1163,7 +1195,7 @@ (%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. @@ -1225,6 +1257,8 @@ (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))