X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcompiler%2Fir1opt.lisp;h=2ffc3850318564710acea8063412b4b8a6425330;hb=5d0643d3b70aade43037e8b7cdf39b7e12f5d3fd;hp=e4c633b9e178d6258ba2f71090224e236eb442f5;hpb=7ce2c42adf3d62f03086de940adaee48e6161a40;p=sbcl.git diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp index e4c633b..2ffc385 100644 --- a/src/compiler/ir1opt.lisp +++ b/src/compiler/ir1opt.lisp @@ -134,6 +134,7 @@ (let* ((fun (combination-fun dest)) (args (combination-args dest)) (fun-type (continuation-type fun))) + (setf (continuation-%externally-checkable-type fun) *wild-type*) (if (or (not (fun-type-p fun-type)) ;; FUN-TYPE might be (AND FUNCTION (SATISFIES ...)). (fun-type-wild-args fun-type)) @@ -159,7 +160,7 @@ ;;;; interface routines used by optimizers ;;; This function is called by optimizers to indicate that something -;;; interesting has happened to the value of Cont. Optimizers must +;;; interesting has happened to the value of CONT. Optimizers must ;;; make sure that they don't call for reoptimization when nothing has ;;; happened, since optimization will fail to terminate. ;;; @@ -168,7 +169,7 @@ ;;; is deleted (in which case we do nothing.) ;;; ;;; Since this can get called during IR1 conversion, we have to be -;;; careful not to fly into space when the Dest's Prev is missing. +;;; careful not to fly into space when the DEST's PREV is missing. (defun reoptimize-continuation (cont) (declare (type continuation cont)) (unless (member (continuation-kind cont) '(:deleted :unused)) @@ -213,6 +214,11 @@ ~% ~S~%*** possible internal error? Please report this." (type-specifier rtype) (type-specifier node-type)))) (setf (node-derived-type node) int) + (when (and (ref-p node) + (member-type-p int) + (null (rest (member-type-members int))) + (lambda-var-p (ref-leaf node))) + (change-ref-leaf node (find-constant (first (member-type-members int))))) (reoptimize-continuation (node-cont node)))))) (values)) @@ -288,53 +294,53 @@ (setf (component-reoptimize component) nil) (do-blocks (block component) (cond - ((or (block-delete-p block) - (null (block-pred block))) - (delete-block block)) - ((eq (functional-kind (block-home-lambda block)) :deleted) - ;; Preserve the BLOCK-SUCC invariant that almost every block has - ;; one successor (and a block with DELETE-P set is an acceptable - ;; exception). - (labels ((mark-blocks (block) - (dolist (pred (block-pred block)) - (unless (or (block-delete-p pred) - (eq (component-head (block-component pred)) - pred)) - (setf (block-delete-p pred) t) - (mark-blocks pred))))) - (mark-blocks block) - (delete-block block))) - (t - (loop - (let ((succ (block-succ block))) - (unless (and succ (null (rest succ))) - (return))) - - (let ((last (block-last block))) - (typecase last - (cif - (flush-dest (if-test last)) - (when (unlink-node last) - (return))) - (exit - (when (maybe-delete-exit last) - (return))))) - - (unless (join-successor-if-possible block) - (return))) - - (when (and (block-reoptimize block) (block-component block)) - (aver (not (block-delete-p block))) - (ir1-optimize-block block)) - ;; We delete blocks when there is either no predecessor or the ;; block is in a lambda that has been deleted. These blocks ;; would eventually be deleted by DFO recomputation, but doing ;; it here immediately makes the effect available to IR1 ;; optimization. - (when (and (block-flush-p block) (block-component block)) - (aver (not (block-delete-p block))) - (flush-dead-code block))))) + ((or (block-delete-p block) + (null (block-pred block))) + (delete-block block)) + ((eq (functional-kind (block-home-lambda block)) :deleted) + ;; Preserve the BLOCK-SUCC invariant that almost every block has + ;; one successor (and a block with DELETE-P set is an acceptable + ;; exception). + (mark-for-deletion block) + (delete-block block)) + (t + (loop + (let ((succ (block-succ block))) + (unless (and succ (null (rest succ))) + (return))) + + (let ((last (block-last block))) + (typecase last + (cif + (if (memq (continuation-type-check (if-test last)) + '(nil :deleted)) + ;; FIXME: Remove the test above when the bug 203 + ;; will be fixed. + (progn + (flush-dest (if-test last)) + (when (unlink-node last) + (return))) + (return))) + (exit + (when (maybe-delete-exit last) + (return))))) + + (unless (join-successor-if-possible block) + (return))) + + (when (and (block-reoptimize block) (block-component block)) + (aver (not (block-delete-p block))) + (ir1-optimize-block block)) + + (cond ((block-delete-p block) + (delete-block block)) + ((and (block-flush-p block) (block-component block)) + (flush-dead-code block)))))) (values)) @@ -384,6 +390,7 @@ (derive-node-type node (continuation-derived-type value))))) (cset (ir1-optimize-set node))))) + (values)) ;;; Try to join with a successor block. If we succeed, we return true, @@ -585,7 +592,7 @@ ;;; all functions in the tail set to be equivalent, this amounts to ;;; bringing the entire tail set up to date. We iterate over the ;;; returns for all the functions in the tail set, reanalyzing them -;;; all (not treating Node specially.) +;;; all (not treating NODE specially.) ;;; ;;; When we are done, we check whether the new type is different from ;;; the old TAIL-SET-TYPE. If so, we set the type and also reoptimize @@ -632,22 +639,25 @@ (convert-if-if use node) (when (continuation-use test) (return))))) - (let* ((type (continuation-type test)) - (victim - (cond ((constant-continuation-p test) - (if (continuation-value test) - (if-alternative node) - (if-consequent node))) - ((not (types-equal-or-intersect type (specifier-type 'null))) - (if-alternative node)) - ((type= type (specifier-type 'null)) - (if-consequent node))))) - (when victim - (flush-dest test) - (when (rest (block-succ block)) - (unlink-blocks block victim)) - (setf (component-reanalyze (node-component node)) t) - (unlink-node node)))) + (when (memq (continuation-type-check test) + '(nil :deleted)) + ;; FIXME: Remove the test above when the bug 203 will be fixed. + (let* ((type (continuation-type test)) + (victim + (cond ((constant-continuation-p test) + (if (continuation-value test) + (if-alternative node) + (if-consequent node))) + ((not (types-equal-or-intersect type (specifier-type 'null))) + (if-alternative node)) + ((type= type (specifier-type 'null)) + (if-consequent node))))) + (when victim + (flush-dest test) + (when (rest (block-succ block)) + (unlink-blocks block victim)) + (setf (component-reanalyze (node-component node)) t) + (unlink-node node))))) (values)) ;;; Create a new copy of an IF node that tests the value of the node @@ -1172,33 +1182,42 @@ ;;; possible to do this starting from debug names as well as source ;;; names, but as of sbcl-0.7.1.5, there was no need for this ;;; generality, since source names are always known to our callers.) -(defun transform-call (node res source-name) - (declare (type combination node) (list res)) +(defun transform-call (call res source-name) + (declare (type combination call) (list res)) (aver (and (legal-fun-name-p source-name) (not (eql source-name '.anonymous.)))) - (with-ir1-environment-from-node node + (node-ends-block call) + (with-ir1-environment-from-node call + (with-component-last-block (*current-component* + (block-next (node-block call))) (let ((new-fun (ir1-convert-inline-lambda res :debug-name (debug-namify "LAMBDA-inlined ~A" (as-debug-name source-name "")))) - (ref (continuation-use (combination-fun node)))) + (ref (continuation-use (combination-fun call)))) (change-ref-leaf ref new-fun) - (setf (combination-kind node) :full) - (locall-analyze-component *current-component*))) + (setf (combination-kind call) :full) + (locall-analyze-component *current-component*)))) (values)) ;;; Replace a call to a foldable function of constant arguments with -;;; the result of evaluating the form. We insert the resulting -;;; constant node after the call, stealing the call's continuation. We -;;; give the call a continuation with no DEST, which should cause it -;;; and its arguments to go away. If there is an error during the +;;; the result of evaluating the form. If there is an error during the ;;; evaluation, we give a warning and leave the call alone, making the ;;; call a :ERROR call. ;;; ;;; If there is more than one value, then we transform the call into a ;;; VALUES form. +;;; +;;; An old commentary also said: +;;; +;;; We insert the resulting constant node after the call, stealing +;;; the call's continuation. We give the call a continuation with no +;;; DEST, which should cause it and its arguments to go away. +;;; +;;; This seems to be more efficient, than the current code. Maybe we +;;; should really implement it? -- APD, 2002-12-23 (defun constant-fold-call (call) (let ((args (mapcar #'continuation-value (combination-args call))) (fun-name (combination-fun-source-name call))) @@ -1232,22 +1251,35 @@ ;; when the compiler tries to constant-fold (<= ;; END SIZE). ;; - ;; So, with or without bug 173, it'd be + ;; So, with or without bug 173, it'd be ;; unnecessarily evil to do a full ;; COMPILER-WARNING (and thus return FAILURE-P=T ;; from COMPILE-FILE) for legal code, so we we ;; use a wimpier COMPILE-STYLE-WARNING instead. #'compiler-style-warn "constant folding") - (if (not win) - (setf (combination-kind call) :error) - (let ((dummies (make-gensym-list (length args)))) - (transform-call - call - `(lambda ,dummies - (declare (ignore ,@dummies)) - (values ,@(mapcar (lambda (x) `',x) values))) - fun-name))))) + (cond ((not win) + (setf (combination-kind call) :error)) + ((and (proper-list-of-length-p values 1) + (eq (continuation-kind (node-cont call)) :inside-block)) + (with-ir1-environment-from-node call + (let* ((cont (node-cont call)) + (next (continuation-next cont)) + (prev (make-continuation))) + (delete-continuation-use call) + (add-continuation-use call prev) + (reference-constant prev cont (first values)) + (setf (continuation-next cont) next) + ;; FIXME: type checking? + (reoptimize-continuation cont) + (reoptimize-continuation prev)))) + (t (let ((dummies (make-gensym-list (length args)))) + (transform-call + call + `(lambda ,dummies + (declare (ignore ,@dummies)) + (values ,@(mapcar (lambda (x) `',x) values))) + fun-name)))))) (values)) ;;;; local call optimization @@ -1268,13 +1300,16 @@ (values)))) ;;; Figure out the type of a LET variable that has sets. We compute -;;; the union of the initial value Type and the types of all the set +;;; the union of the initial value TYPE and the types of all the set ;;; values and to a PROPAGATE-TO-REFS with this type. (defun propagate-from-sets (var type) (collect ((res type type-union)) (dolist (set (basic-var-sets var)) - (res (continuation-type (set-value set))) - (setf (node-reoptimize set) nil)) + (let ((type (continuation-type (set-value set)))) + (res type) + (when (node-reoptimize set) + (derive-node-type set type) + (setf (node-reoptimize set) nil)))) (propagate-to-refs var (res))) (values)) @@ -1307,7 +1342,12 @@ (not (eq (defined-fun-inlinep leaf) :notinline))) (global-var (case (global-var-kind leaf) - (:global-function t)))))) + (:global-function + (let ((name (leaf-source-name leaf))) + (or #-sb-xc-host + (eq (symbol-package (fun-name-block-name name)) + *cl-package*) + (info :function :info name))))))))) ;;; If we have a non-set LET var with a single use, then (if possible) ;;; replace the variable reference's CONT with the arg continuation. @@ -1318,7 +1358,7 @@ ;;; -- either continuation has a funky TYPE-CHECK annotation. ;;; -- the continuations have incompatible assertions, so the new asserted type ;;; would be NIL. -;;; -- the var's DEST has a different policy than the ARG's (think safety). +;;; -- the VAR's DEST has a different policy than the ARG's (think safety). ;;; ;;; We change the REF to be a reference to NIL with unused value, and ;;; let it be flushed as dead code. A side effect of this substitution @@ -1332,7 +1372,7 @@ (dest (continuation-dest cont))) (when (and (eq (continuation-use cont) ref) dest - (not (typep dest '(or creturn exit mv-combination))) + (continuation-single-value-p cont) (eq (node-home-lambda ref) (lambda-home (lambda-var-home var))) (member (continuation-type-check arg) '(t nil)) @@ -1433,9 +1473,9 @@ ;;; If the function has an XEP, then we don't do anything, since we ;;; won't discover anything. ;;; -;;; We can clear the Continuation-Reoptimize flags for arguments in -;;; all calls corresponding to changed arguments in Call, since the -;;; only use in IR1 optimization of the Reoptimize flag for local call +;;; We can clear the CONTINUATION-REOPTIMIZE flags for arguments in +;;; all calls corresponding to changed arguments in CALL, since the +;;; only use in IR1 optimization of the REOPTIMIZE flag for local call ;;; args is right here. (defun propagate-local-call-args (call fun) (declare (type combination call) (type clambda fun)) @@ -1604,7 +1644,7 @@ (return-from ir1-optimize-mv-call))) (let ((count (cond (total-nvals) - ((and (policy node (zerop safety)) + ((and (policy node (zerop verify-arg-count)) (eql min max)) min) (t nil)))) @@ -1658,7 +1698,7 @@ (setf (node-prev use) nil) (setf (continuation-next node-prev) nil) (collect ((res vals)) - (loop as cont = (make-continuation use) + (loop for cont = (make-continuation use) and prev = node-prev then cont repeat (- nvars nvals) do (reference-constant prev cont nil) @@ -1678,7 +1718,8 @@ (unlink-node call) (when vals (reoptimize-continuation (first vals))) - (propagate-to-args use fun)) + (propagate-to-args use fun) + (reoptimize-call use)) t))) ;;; If we see: @@ -1691,6 +1732,8 @@ ;;; CONVERT-MV-BIND-TO-LET. We grab the args of LIST and make them ;;; args of the VALUES-LIST call, flushing the old argument ;;; continuation (allowing the LIST to be flushed.) +;;; +;;; FIXME: Thus we lose possible type assertions on (LIST ...). (defoptimizer (values-list optimizer) ((list) node) (let ((use (continuation-use list))) (when (and (combination-p use) @@ -1712,8 +1755,7 @@ ;;; to a PROG1. This allows the computation of the additional values ;;; to become dead code. (deftransform values ((&rest vals) * * :node node) - (when (typep (continuation-dest (node-cont node)) - '(or creturn exit mv-combination)) + (unless (continuation-single-value-p (node-cont node)) (give-up-ir1-transform)) (setf (node-derived-type node) *wild-type*) (if vals