0.pre7.117:

[sbcl.git] / src / compiler / ir1opt.lisp

diff --git a/src/compiler/ir1opt.lisp b/src/compiler/ir1opt.lisp
index c9188e3..b25a775 100644 (file)
--- a/src/compiler/ir1opt.lisp
+++ b/src/compiler/ir1opt.lisp
@@ -347,7 +347,7 @@
                 ;; If next-cont does have a dest, it must be
                 ;; unreachable, since there are no uses.
                 ;; DELETE-CONTINUATION will mark the dest block as
-                ;; delete-p [and also this block, unless it is no
+                ;; DELETE-P [and also this block, unless it is no
                 ;; longer backward reachable from the dest block.]
                 (delete-continuation next-cont)
                 (setf (node-prev next-node) last-cont)
@@ -548,13 +548,13 @@
        (flush-dest test)
        (when (rest (block-succ block))
          (unlink-blocks block victim))
-       (setf (component-reanalyze (block-component (node-block node))) t)
+       (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
-;;; Use. The test must have >1 use, and must be immediately used by
-;;; Use. Node must be the only node in its block (implying that
+;;; Create a new copy of an IF node that tests the value of the node
+;;; USE. The test must have >1 use, and must be immediately used by
+;;; USE. NODE must be the only node in its block (implying that
 ;;; block-start = if-test).
 ;;;
 ;;; This optimization has an effect semantically similar to the
@@ -568,7 +568,7 @@
 ;;; become unreachable, resulting in a spurious note.
 (defun convert-if-if (use node)
   (declare (type node use) (type cif node))
-  (with-belated-ir1-environment node
+  (with-ir1-environment-from-node node
     (let* ((block (node-block node))
           (test (if-test node))
           (cblock (if-consequent node))
@@ -818,7 +818,7 @@
                 (change-ref-leaf ref res))))
        (if ir1-p
            (frob)
-           (with-belated-ir1-environment call
+           (with-ir1-environment-from-node call
              (frob)
              (locall-analyze-component *current-component*))))
 
@@ -1083,10 +1083,10 @@
 ;;; integrated into the control flow.
 (defun transform-call (node res)
   (declare (type combination node) (list res))
-  (with-belated-ir1-environment node
+  (with-ir1-environment-from-node node
     (let ((new-fun (ir1-convert-inline-lambda
                    res
-                   :debug-name "<something inlined in TRANSFORM-CALL>"))
+                   :debug-name "something inlined in TRANSFORM-CALL"))
          (ref (continuation-use (combination-fun node))))
       (change-ref-leaf ref new-fun)
       (setf (combination-kind node) :full)
@@ -1276,11 +1276,10 @@
                         (values-subtypep (leaf-type leaf)
                                          (continuation-asserted-type arg)))
                (propagate-to-refs var (continuation-type arg))
-               (let ((this-comp (block-component (node-block use))))
+               (let ((use-component (node-component use)))
                  (substitute-leaf-if
                   #'(lambda (ref)
-                      (cond ((eq (block-component (node-block ref))
-                                 this-comp)
+                      (cond ((eq (node-component ref) use-component)
                              t)
                             (t
                              (aver (lambda-toplevelish-p (lambda-home fun)))
@@ -1481,7 +1480,7 @@
                            min)
                           (t nil))))
          (when count
-           (with-belated-ir1-environment node
+           (with-ir1-environment-from-node node
              (let* ((dums (make-gensym-list count))
                     (ignore (gensym))
                     (fun (ir1-convert-lambda
@@ -1525,7 +1524,7 @@
               (mapc #'flush-dest (subseq vals nvars))
               (setq vals (subseq vals 0 nvars)))
              ((< nvals nvars)
-              (with-belated-ir1-environment use
+              (with-ir1-environment-from-node use
                 (let ((node-prev (node-prev use)))
                   (setf (node-prev use) nil)
                   (setf (continuation-next node-prev) nil)