(dolist (arg (basic-combination-args call))
(when arg
(flush-lvar-externally-checkable-type arg))))
- (pushnew fun (lambda-calls-or-closes (node-home-lambda call)))
+ (sset-adjoin fun (lambda-calls-or-closes (node-home-lambda call)))
(recognize-dynamic-extent-lvars call fun)
(merge-tail-sets call fun)
(change-ref-leaf ref fun)
(loop
(let ((did-something nil))
(dolist (clambda clambdas)
- (let* ((component (lambda-component clambda))
- (*all-components* (list component)))
+ (let ((component (lambda-component clambda)))
;; The original CMU CL code seemed to implicitly assume that
;; COMPONENT is the only one here. Let's make that explicit.
(aver (= 1 (length (functional-components clambda))))
(aver (= (optional-dispatch-min-args fun) 0))
(aver (not (functional-entry-fun fun)))
(setf (basic-combination-kind call) :local)
- (pushnew ep (lambda-calls-or-closes (node-home-lambda call)))
+ (sset-adjoin ep (lambda-calls-or-closes (node-home-lambda call)))
(merge-tail-sets call ep)
(change-ref-leaf ref ep)
;; HOME no longer calls CLAMBDA, and owns all of CLAMBDA's old
;; DFO dependencies.
- (setf (lambda-calls-or-closes home)
- (delete clambda
- (nunion (lambda-calls-or-closes clambda)
- (lambda-calls-or-closes home))))
+ (sset-union (lambda-calls-or-closes home)
+ (lambda-calls-or-closes clambda))
+ (sset-delete clambda (lambda-calls-or-closes home))
;; CLAMBDA no longer has an independent existence as an entity
;; which calls things or has DFO dependencies.
(setf (lambda-calls-or-closes clambda) nil)
;;; the RETURN-RESULT, because the return might have been deleted (if
;;; all calls were TR.)
(defun unconvert-tail-calls (fun call next-block)
- (dolist (called (lambda-calls-or-closes fun))
+ (do-sset-elements (called (lambda-calls-or-closes fun))
(when (lambda-p called)
(dolist (ref (leaf-refs called))
(let ((this-call (node-dest ref)))
;;; true if we converted.
(defun maybe-let-convert (clambda)
(declare (type clambda clambda))
- (unless (declarations-suppress-let-conversion-p clambda)
+ (unless (or (declarations-suppress-let-conversion-p clambda)
+ (functional-has-external-references-p clambda))
;; We only convert to a LET when the function is a normal local
;; function, has no XEP, and is referenced in exactly one local
;; call. Conversion is also inhibited if the only reference is in
(defun maybe-convert-to-assignment (clambda)
(declare (type clambda clambda))
(when (and (not (functional-kind clambda))
- (not (functional-entry-fun clambda)))
+ (not (functional-entry-fun clambda))
+ (not (functional-has-external-references-p clambda)))
(let ((outside-non-tail-call nil)
(outside-call nil))
(when (and (dolist (ref (leaf-refs clambda) t)