(setq did-something t)
(close-over var ref-physenv physenv))))
(dolist (set (basic-var-sets var))
- (let ((set-physenv (get-node-physenv set)))
- (unless (eq set-physenv physenv)
- (setq did-something t)
- (setf (lambda-var-indirect var) t)
- (close-over var set-physenv physenv)))))
+
+ ;; Variables which are set but never referenced can be
+ ;; optimized away, and closing over them here would just
+ ;; interfere with that. (In bug 147, it *did* interfere with
+ ;; that, causing confusion later. This UNLESS solves that
+ ;; problem, but I (WHN) am not 100% sure it's best to solve
+ ;; the problem this way instead of somehow solving it
+ ;; somewhere upstream and just doing (AVER (LEAF-REFS VAR))
+ ;; here.)
+ (unless (null (leaf-refs var))
+
+ (let ((set-physenv (get-node-physenv set)))
+ (unless (eq set-physenv physenv)
+ (setf did-something t
+ (lambda-var-indirect var) t)
+ (close-over var set-physenv physenv))))))
did-something))
;;; Find any variables in CLAMBDA -- either directly in LAMBDA-VARS or
;;; -- If there isn't any NLX-Info entry in the environment, make
;;; an entry stub, otherwise just move the exit block link to
;;; the component tail.
-;;; -- Close over the NLX-Info in the exit environment.
-;;; -- If the exit is from an :Escape function, then substitute a
+;;; -- Close over the NLX-INFO in the exit environment.
+;;; -- If the exit is from an :ESCAPE function, then substitute a
;;; constant reference to NLX-Info structure for the escape
;;; function reference. This will cause the escape function to
;;; be deleted (although not removed from the DFO.) The escape
(let ((entry (exit-entry exit))
(cont (node-cont exit))
(exit-fun (node-home-lambda exit)))
-
(if (find-nlx-info entry cont)
(let ((block (node-block exit)))
(aver (= (length (block-succ block)) 1))
(unlink-blocks block (first (block-succ block)))
(link-blocks block (component-tail (block-component block))))
(insert-nlx-entry-stub exit env))
-
(let ((info (find-nlx-info entry cont)))
(aver info)
(close-over info (node-physenv exit) env)
(when (eq (functional-kind exit-fun) :escape)
- (mapc #'(lambda (x)
- (setf (node-derived-type x) *wild-type*))
+ (mapc (lambda (x)
+ (setf (node-derived-type x) *wild-type*))
(leaf-refs exit-fun))
(substitute-leaf (find-constant info) exit-fun)
(let ((node (block-last (nlx-info-target info))))
(delete-continuation-use node)
(add-continuation-use node (nlx-info-continuation info))))))
-
(values))
;;; Iterate over the EXITs in COMPONENT, calling NOTE-NON-LOCAL-EXIT
(dolist (lambda (component-lambdas component))
(dolist (entry (lambda-entries lambda))
(dolist (exit (entry-exits entry))
- (let ((target-env (node-physenv entry)))
- (if (eq (node-physenv exit) target-env)
+ (let ((target-physenv (node-physenv entry)))
+ (if (eq (node-physenv exit) target-physenv)
(maybe-delete-exit exit)
- (note-non-local-exit target-env exit))))))
-
+ (note-non-local-exit target-physenv exit))))))
(values))
\f
;;;; cleanup emission
;;; in an implicit MV-PROG1. We have to force local call analysis of
;;; new references to UNWIND-PROTECT cleanup functions. If we don't
;;; actually have to do anything, then we don't insert any cleanup
-;;; code.
+;;; code. (FIXME: There's some confusion here, left over from CMU CL
+;;; comments. CLEANUP1 isn't mentioned in the code of this function.
+;;; It is in code elsewhere, but if the comments for this function
+;;; mention it they should explain the relationship to the other code.)
;;;
;;; If we do insert cleanup code, we check that BLOCK1 doesn't end in
;;; a "tail" local call.
(let ((result (return-result ret)))
(do-uses (use result)
(when (and (immediately-used-p result use)
- (or (not (eq (node-derived-type use) *empty-type*))
- (not (basic-combination-p use))
- (eq (basic-combination-kind use) :local)))
+ (or (not (eq (node-derived-type use) *empty-type*))
+ (not (basic-combination-p use))
+ (eq (basic-combination-kind use) :local)))
(setf (node-tail-p use) t)))))))
(values))
projects / sbcl.git / blobdiff