X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Flocall.lisp;h=aa84315a06280270f1c50bd64944f42e0ca50b84;hb=5745b5a5b2e3b967bf3876b4306f31b3c78495fa;hp=e758d67ba6aeede9e606662276dfaa38f00780a6;hpb=332e4d9a78b7af76d0c8da2a7cafda5a3c556036;p=sbcl.git

diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp
index e758d67..aa84315 100644
--- a/src/compiler/locall.lisp
+++ b/src/compiler/locall.lisp
@@ -43,31 +43,6 @@
              (setf (car args) nil)))
   (values))
 
-(defun handle-nested-dynamic-extent-lvars (dx lvar)
-  (let ((uses (lvar-uses lvar)))
-    ;; DX value generators must end their blocks: see UPDATE-UVL-LIVE-SETS.
-    ;; Uses of mupltiple-use LVARs already end their blocks, so we just need
-    ;; to process uses of single-use LVARs.
-    (when (node-p uses)
-      (node-ends-block uses))
-    ;; If this LVAR's USE is good for DX, it is either a CAST, or it
-    ;; must be a regular combination whose arguments are potentially DX as well.
-    (flet ((recurse (use)
-             (etypecase use
-               (cast
-                (handle-nested-dynamic-extent-lvars dx (cast-value use)))
-               (combination
-                (loop for arg in (combination-args use)
-                      when (lvar-good-for-dx-p arg dx)
-                      append (handle-nested-dynamic-extent-lvars dx arg))))))
-      (cons lvar
-            (if (listp uses)
-                (loop for use in uses
-                      when (use-good-for-dx-p use dx)
-                      nconc (recurse use))
-                (when (use-good-for-dx-p uses dx)
-                  (recurse uses)))))))
-
 (defun recognize-dynamic-extent-lvars (call fun)
   (declare (type combination call) (type clambda fun))
   (loop for arg in (basic-combination-args call)
@@ -90,8 +65,8 @@
                           (make-lexenv :default (node-lexenv call)
                                        :cleanup cleanup))
                     (push entry (lambda-entries (node-home-lambda entry)))
-                    (dolist (lvar dx-lvars)
-                      (setf (lvar-dynamic-extent lvar) cleanup)))))
+                    (dolist (cell dx-lvars)
+                      (setf (lvar-dynamic-extent (cdr cell)) cleanup)))))
   (values))
 
 ;;; This function handles merging the tail sets if CALL is potentially
@@ -205,9 +180,6 @@
                do (entries `((eql ,n-supplied ,n)
                              (%funcall ,(force ep) ,@(subseq temps 0 n)))))
          `(lambda (,n-supplied ,@temps)
-            ;; FIXME: Make sure that INDEX type distinguishes between
-            ;; target and host. (Probably just make the SB!XC:DEFTYPE
-            ;; different from CL:DEFTYPE.)
             (declare (type index ,n-supplied))
             (cond
              ,@(if more (butlast (entries)) (entries))
@@ -215,8 +187,7 @@
                  ;; KLUDGE: (NOT (< ...)) instead of >= avoids one round of
                  ;; deftransforms and lambda-conversion.
                  `((,(if (zerop min) t `(not (< ,n-supplied ,max)))
-                    ,(let ((n-context (gensym))
-                           (n-count (gensym)))
+                    ,(with-unique-names (n-context n-count)
                        `(multiple-value-bind (,n-context ,n-count)
                             (%more-arg-context ,n-supplied ,max)
                           (locally
@@ -240,7 +211,8 @@
   (with-ir1-environment-from-node (lambda-bind (main-entry fun))
     (let ((res (ir1-convert-lambda (make-xep-lambda-expression fun)
                                    :debug-name (debug-name
-                                                'xep (leaf-debug-name fun)))))
+                                                'xep (leaf-debug-name fun))
+                                   :system-lambda t)))
       (setf (functional-kind res) :external
             (leaf-ever-used res) t
             (functional-entry-fun res) fun
@@ -500,13 +472,13 @@
   (declare (type ref ref) (type mv-combination call) (type functional fun))
   (when (and (looks-like-an-mv-bind fun)
              (singleton-p (leaf-refs fun))
-             (singleton-p (basic-combination-args call)))
+             (singleton-p (basic-combination-args call))
+             (not (functional-entry-fun fun)))
     (let* ((*current-component* (node-component ref))
            (ep (optional-dispatch-entry-point-fun
                 fun (optional-dispatch-max-args fun))))
       (when (null (leaf-refs ep))
         (aver (= (optional-dispatch-min-args fun) 0))
-        (aver (not (functional-entry-fun fun)))
         (setf (basic-combination-kind call) :local)
         (sset-adjoin ep (lambda-calls-or-closes (node-home-lambda call)))
         (merge-tail-sets call ep)
@@ -595,7 +567,8 @@
                (%funcall ,entry ,@args))
             :debug-name (debug-name 'hairy-function-entry
                                     (lvar-fun-debug-name
-                                     (basic-combination-fun call)))))))
+                                     (basic-combination-fun call)))
+            :system-lambda t))))
     (convert-call ref call new-fun)
     (dolist (ref (leaf-refs entry))
       (convert-call-if-possible ref (lvar-dest (node-lvar ref))))))