X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcompiler%2Fltn.lisp;h=80f112a648a104973f5a0b9124a1d15b79eaa253;hb=e3113504fca73ebd1b992930315386d9d3ae5d18;hp=b790f42a5bdf382fefc5626b3782f162fe249742;hpb=d604a358d8e5eb5587989e0a4f1d31dbe6ac5ffe;p=sbcl.git

diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp
index b790f42..80f112a 100644
--- a/src/compiler/ltn.lisp
+++ b/src/compiler/ltn.lisp
@@ -64,39 +64,18 @@
   (declare (type lvar lvar))
   (ir2-lvar-primitive-type (lvar-info lvar)))
 
-;;; Return true if a constant LEAF is of a type which we can legally
-;;; directly reference in code. Named constants with arbitrary pointer
-;;; values cannot, since we must preserve EQLness.
-;;;
-;;; FIXME: why not?  The values in a function's constant vector are
-;;; subject to being moved by the garbage collector.  Having arbitrary
-;;; values in said vector doesn't seem like a problem.
-(defun legal-immediate-constant-p (leaf)
-  (declare (type constant leaf))
-  (or (not (leaf-has-source-name-p leaf))
-      ;; Specialized arrays are legal, too.  KLUDGE: this would be
-      ;; *much* cleaner if SIMPLE-UNBOXED-ARRAY was defined on the host.
-      #.(loop for saetp across sb!vm:*specialized-array-element-type-properties*
-              unless (eq t (sb!vm:saetp-specifier saetp))
-              collect `((simple-array ,(sb!vm:saetp-specifier saetp) (*)) t) into cases
-              finally (return
-                        `(typecase (constant-value leaf)
-                           ((or number character) t)
-                           (symbol (symbol-package (constant-value leaf)))
-                           ,@cases
-                           (t nil))))))
-
 ;;; If LVAR is used only by a REF to a leaf that can be delayed, then
 ;;; return the leaf, otherwise return NIL.
 (defun lvar-delayed-leaf (lvar)
   (declare (type lvar lvar))
-  (let ((use (lvar-uses lvar)))
-    (and (ref-p use)
-         (let ((leaf (ref-leaf use)))
-           (etypecase leaf
-             (lambda-var (if (null (lambda-var-sets leaf)) leaf nil))
-             (constant (if (legal-immediate-constant-p leaf) leaf nil))
-             ((or functional global-var) nil))))))
+  (unless (lvar-dynamic-extent lvar)
+    (let ((use (lvar-uses lvar)))
+      (and (ref-p use)
+           (let ((leaf (ref-leaf use)))
+             (etypecase leaf
+               (lambda-var (if (null (lambda-var-sets leaf)) leaf nil))
+               (constant leaf)
+               ((or functional global-var) nil)))))))
 
 ;;; Annotate a normal single-value lvar. If its only use is a ref that
 ;;; we are allowed to delay the evaluation of, then we mark the lvar