X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fir2tran.lisp;h=8fa72f4a82cad48f27679075f746c98648aed822;hb=683874b497a99cd2c11b6c5d9b47e2785b1ede5f;hp=0c8e6960f5cada4338d85168c2c833284a1542c4;hpb=212ef8043aeaceaa627f2924e04554fbc37b8ee1;p=sbcl.git

diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp
index 0c8e696..8fa72f4 100644
--- a/src/compiler/ir2tran.lisp
+++ b/src/compiler/ir2tran.lisp
@@ -54,16 +54,28 @@
 ;;;; leaf reference
 
 ;;; Return the TN that holds the value of THING in the environment ENV.
-(defun find-in-environment (thing env)
-  (declare (type (or nlx-info lambda-var) thing) (type environment env)
-	   (values tn))
-  (or (cdr (assoc thing (ir2-environment-environment (environment-info env))))
+(declaim (ftype (function ((or nlx-info lambda-var) physenv) tn)
+		find-in-physenv))
+(defun find-in-physenv (thing physenv)
+  (or (cdr (assoc thing (ir2-physenv-closure (physenv-info physenv))))
       (etypecase thing
 	(lambda-var
-	 (assert (eq env (lambda-environment (lambda-var-home thing))))
+	 ;; I think that a failure of this assertion means that we're
+	 ;; trying to access a variable which was improperly closed
+	 ;; over. The PHYSENV describes a physical environment. Every
+	 ;; variable that a form refers to should either be in its
+	 ;; physical environment directly, or grabbed from a
+	 ;; surrounding physical environment when it was closed over.
+	 ;; The ASSOC expression above finds closed-over variables, so
+	 ;; if we fell through the ASSOC expression, it wasn't closed
+	 ;; over. Therefore, it must be in our physical environment
+	 ;; directly. If instead it is in some other physical
+	 ;; environment, then it's bogus for us to reference it here
+	 ;; without it being closed over. -- WHN 2001-09-29
+	 (aver (eq physenv (lambda-physenv (lambda-var-home thing))))
 	 (leaf-info thing))
 	(nlx-info
-	 (assert (eq env (block-environment (nlx-info-target thing))))
+	 (aver (eq physenv (block-physenv (nlx-info-target thing))))
 	 (ir2-nlx-info-home (nlx-info-info thing))))))
 
 ;;; If LEAF already has a constant TN, return that, otherwise make a
@@ -78,11 +90,11 @@
 ;;; isn't directly represented by a TN. ENV is the environment that
 ;;; the reference is done in.
 (defun leaf-tn (leaf env)
-  (declare (type leaf leaf) (type environment env))
+  (declare (type leaf leaf) (type physenv env))
   (typecase leaf
     (lambda-var
      (unless (lambda-var-indirect leaf)
-       (find-in-environment leaf env)))
+       (find-in-physenv leaf env)))
     (constant (constant-tn leaf))
     (t nil)))
 
@@ -97,30 +109,31 @@
   (declare (type ref node) (type ir2-block block))
   (let* ((cont (node-cont node))
 	 (leaf (ref-leaf node))
-	 (name (leaf-name leaf))
 	 (locs (continuation-result-tns
 		cont (list (primitive-type (leaf-type leaf)))))
 	 (res (first locs)))
     (etypecase leaf
       (lambda-var
-       (let ((tn (find-in-environment leaf (node-environment node))))
+       (let ((tn (find-in-physenv leaf (node-physenv node))))
 	 (if (lambda-var-indirect leaf)
 	     (vop value-cell-ref node block tn res)
 	     (emit-move node block tn res))))
       (constant
        (if (legal-immediate-constant-p leaf)
 	   (emit-move node block (constant-tn leaf) res)
-	   (let ((name-tn (emit-constant name)))
+	   (let* ((name (leaf-source-name leaf))
+		  (name-tn (emit-constant name)))
 	     (if (policy node (zerop safety))
 		 (vop fast-symbol-value node block name-tn res)
 		 (vop symbol-value node block name-tn res)))))
       (functional
        (ir2-convert-closure node block leaf res))
       (global-var
-       (let ((unsafe (policy node (zerop safety))))
+       (let ((unsafe (policy node (zerop safety)))
+	     (name (leaf-source-name leaf)))
 	 (ecase (global-var-kind leaf)
-	   ((:special :global :constant)
-	    (assert (symbolp name))
+	   ((:special :global)
+	    (aver (symbolp name))
 	    (let ((name-tn (emit-constant name)))
 	      (if unsafe
 		  (vop fast-symbol-value node block name-tn res)
@@ -128,8 +141,8 @@
 	   (:global-function
 	    (let ((fdefn-tn (make-load-time-constant-tn :fdefinition name)))
 	      (if unsafe
-		  (vop fdefn-function node block fdefn-tn res)
-		  (vop safe-fdefn-function node block fdefn-tn res))))))))
+		  (vop fdefn-fun node block fdefn-tn res)
+		  (vop safe-fdefn-fun node block fdefn-tn res))))))))
     (move-continuation-result node block locs cont))
   (values))
 
@@ -137,15 +150,15 @@
 ;;; This gets interesting when the referenced function is a closure:
 ;;; we must make the closure and move the closed over values into it.
 ;;;
-;;; LEAF is either a :TOP-LEVEL-XEP functional or the XEP lambda for
+;;; LEAF is either a :TOPLEVEL-XEP functional or the XEP lambda for
 ;;; the called function, since local call analysis converts all
 ;;; closure references. If a TL-XEP, we know it is not a closure.
 ;;;
-;;; If a closed-over lambda-var has no refs (is deleted), then we
+;;; If a closed-over LAMBDA-VAR has no refs (is deleted), then we
 ;;; don't initialize that slot. This can happen with closures over
-;;; top-level variables, where optimization of the closure deleted the
+;;; top level variables, where optimization of the closure deleted the
 ;;; variable. Since we committed to the closure format when we
-;;; pre-analyzed the top-level code, we just leave an empty slot.
+;;; pre-analyzed the top level code, we just leave an empty slot.
 (defun ir2-convert-closure (node block leaf res)
   (declare (type ref node) (type ir2-block block)
 	   (type functional leaf) (type tn res))
@@ -154,19 +167,19 @@
   (let ((entry (make-load-time-constant-tn :entry leaf))
 	(closure (etypecase leaf
 		   (clambda
-		    (environment-closure (get-lambda-environment leaf)))
+		    (physenv-closure (get-lambda-physenv leaf)))
 		   (functional
-		    (assert (eq (functional-kind leaf) :top-level-xep))
+		    (aver (eq (functional-kind leaf) :toplevel-xep))
 		    nil))))
     (cond (closure
-	   (let ((this-env (node-environment node)))
+	   (let ((this-env (node-physenv node)))
 	     (vop make-closure node block entry (length closure) res)
 	     (loop for what in closure and n from 0 do
 	       (unless (and (lambda-var-p what)
 			    (null (leaf-refs what)))
 		 (vop closure-init node block
 		      res
-		      (find-in-environment what this-env)
+		      (find-in-physenv what this-env)
 		      n)))))
 	  (t
 	   (emit-move node block entry res))))
@@ -188,15 +201,15 @@
     (etypecase leaf
       (lambda-var
        (when (leaf-refs leaf)
-	 (let ((tn (find-in-environment leaf (node-environment node))))
+	 (let ((tn (find-in-physenv leaf (node-physenv node))))
 	   (if (lambda-var-indirect leaf)
 	       (vop value-cell-set node block tn val)
 	       (emit-move node block val tn)))))
       (global-var
        (ecase (global-var-kind leaf)
 	 ((:special :global)
-	  (assert (symbolp (leaf-name leaf)))
-	  (vop set node block (emit-constant (leaf-name leaf)) val)))))
+	  (aver (symbolp (leaf-source-name leaf)))
+	  (vop set node block (emit-constant (leaf-source-name leaf)) val)))))
     (when locs
       (emit-move node block val (first locs))
       (move-continuation-result node block locs cont)))
@@ -222,16 +235,16 @@
 	  (ecase (ir2-continuation-kind 2cont)
 	    (:delayed
 	     (let ((ref (continuation-use cont)))
-	       (leaf-tn (ref-leaf ref) (node-environment ref))))
+	       (leaf-tn (ref-leaf ref) (node-physenv ref))))
 	    (:fixed
-	     (assert (= (length (ir2-continuation-locs 2cont)) 1))
+	     (aver (= (length (ir2-continuation-locs 2cont)) 1))
 	     (first (ir2-continuation-locs 2cont)))))
 	 (ptype (ir2-continuation-primitive-type 2cont)))
 
     (cond ((and (eq (continuation-type-check cont) t)
 		(multiple-value-bind (check types)
 		    (continuation-check-types cont)
-		  (assert (eq check :simple))
+		  (aver (eq check :simple))
 		  ;; If the proven type is a subtype of the possibly
 		  ;; weakened type check then it's always true and is
 		  ;; flushed.
@@ -260,10 +273,10 @@
 	   (type continuation cont) (list ptypes))
   (let* ((locs (ir2-continuation-locs (continuation-info cont)))
 	 (nlocs (length locs)))
-    (assert (= nlocs (length ptypes)))
+    (aver (= nlocs (length ptypes)))
     (if (eq (continuation-type-check cont) t)
 	(multiple-value-bind (check types) (continuation-check-types cont)
-	  (assert (eq check :simple))
+	  (aver (eq check :simple))
 	  (let ((ntypes (length types)))
 	    (mapcar #'(lambda (from to-type assertion)
 			(let ((temp (make-normal-tn to-type)))
@@ -377,7 +390,7 @@
 	  dest))
   (values))
 
-;;; If necessary, emit coercion code needed to deliver the Results to
+;;; If necessary, emit coercion code needed to deliver the RESULTS to
 ;;; the specified continuation. NODE and BLOCK provide context for
 ;;; emitting code. Although usually obtained from STANDARD-RESULT-TNs
 ;;; or CONTINUATION-RESULT-TNs, RESULTS my be a list of any type or
@@ -443,7 +456,7 @@
   (declare (type node node) (type ir2-block block)
 	   (type template template) (type (or tn-ref null) args)
 	   (list info-args) (type cif if) (type boolean not-p))
-  (assert (= (template-info-arg-count template) (+ (length info-args) 2)))
+  (aver (= (template-info-arg-count template) (+ (length info-args) 2)))
   (let ((consequent (if-consequent if))
 	(alternative (if-alternative if)))
     (cond ((drop-thru-p if consequent)
@@ -476,7 +489,7 @@
   (declare (type combination call) (type continuation cont)
 	   (type template template) (list rtypes))
   (let* ((dtype (node-derived-type call))
-	 (type (if (and (or (eq (template-policy template) :safe)
+	 (type (if (and (or (eq (template-ltn-policy template) :safe)
 			    (policy call (= safety 0)))
 			(continuation-type-check cont))
 		   (values-type-intersection
@@ -536,14 +549,14 @@
 	 (rtypes (template-result-types template)))
     (multiple-value-bind (args info-args)
 	(reference-arguments call block (combination-args call) template)
-      (assert (not (template-more-results-type template)))
+      (aver (not (template-more-results-type template)))
       (if (eq rtypes :conditional)
 	  (ir2-convert-conditional call block template args info-args
 				   (continuation-dest cont) nil)
 	  (let* ((results (make-template-result-tns call cont template rtypes))
 		 (r-refs (reference-tn-list results t)))
-	    (assert (= (length info-args)
-		       (template-info-arg-count template)))
+	    (aver (= (length info-args)
+		     (template-info-arg-count template)))
 	    (if info-args
 		(emit-template call block template args r-refs info-args)
 		(emit-template call block template args r-refs))
@@ -564,9 +577,9 @@
     (multiple-value-bind (args info-args)
 	(reference-arguments call block (cddr (combination-args call))
 			     template)
-      (assert (not (template-more-results-type template)))
-      (assert (not (eq rtypes :conditional)))
-      (assert (null info-args))
+      (aver (not (template-more-results-type template)))
+      (aver (not (eq rtypes :conditional)))
+      (aver (null info-args))
 
       (if info
 	  (emit-template call block template args r-refs info)
@@ -609,8 +622,8 @@
 (defun emit-psetq-moves (node block fun old-fp)
   (declare (type combination node) (type ir2-block block) (type clambda fun)
 	   (type (or tn null) old-fp))
-  (let* ((called-env (environment-info (lambda-environment fun)))
-	 (this-1env (node-environment node))
+  (let* ((called-env (physenv-info (lambda-physenv fun)))
+	 (this-1env (node-physenv node))
 	 (actuals (mapcar #'(lambda (x)
 			     (when x
 			       (continuation-tn node block x)))
@@ -636,12 +649,12 @@
 	    (locs loc))))
 
       (when old-fp
-	(dolist (thing (ir2-environment-environment called-env))
-	  (temps (find-in-environment (car thing) this-1env))
+	(dolist (thing (ir2-physenv-closure called-env))
+	  (temps (find-in-physenv (car thing) this-1env))
 	  (locs (cdr thing)))
 	
 	(temps old-fp)
-	(locs (ir2-environment-old-fp called-env)))
+	(locs (ir2-physenv-old-fp called-env)))
 
       (values (temps) (locs)))))
 
@@ -651,19 +664,19 @@
 ;;; function's passing location.
 (defun ir2-convert-tail-local-call (node block fun)
   (declare (type combination node) (type ir2-block block) (type clambda fun))
-  (let ((this-env (environment-info (node-environment node))))
+  (let ((this-env (physenv-info (node-physenv node))))
     (multiple-value-bind (temps locs)
-	(emit-psetq-moves node block fun (ir2-environment-old-fp this-env))
+	(emit-psetq-moves node block fun (ir2-physenv-old-fp this-env))
 
       (mapc #'(lambda (temp loc)
 		(emit-move node block temp loc))
 	    temps locs))
 
     (emit-move node block
-	       (ir2-environment-return-pc this-env)
-	       (ir2-environment-return-pc-pass
-		(environment-info
-		 (lambda-environment fun)))))
+	       (ir2-physenv-return-pc this-env)
+	       (ir2-physenv-return-pc-pass
+		(physenv-info
+		 (lambda-physenv fun)))))
 
   (values))
 
@@ -692,7 +705,7 @@
 	(emit-psetq-moves node block fun old-fp)
       (vop current-fp node block old-fp)
       (vop allocate-frame node block
-	   (environment-info (lambda-environment fun))
+	   (physenv-info (lambda-physenv fun))
 	   fp nfp)
       (values fp nfp temps (mapcar #'make-alias-tn locs)))))
 
@@ -708,7 +721,7 @@
       (vop* known-call-local node block
 	    (fp nfp (reference-tn-list temps nil))
 	    ((reference-tn-list locs t))
-	    arg-locs (environment-info (lambda-environment fun)) start)
+	    arg-locs (physenv-info (lambda-physenv fun)) start)
       (move-continuation-result node block locs cont)))
   (values))
 
@@ -728,7 +741,7 @@
   (multiple-value-bind (fp nfp temps arg-locs)
       (ir2-convert-local-call-args node block fun)
     (let ((2cont (continuation-info cont))
-	  (env (environment-info (lambda-environment fun)))
+	  (env (physenv-info (lambda-physenv fun)))
 	  (temp-refs (reference-tn-list temps nil)))
       (if (and 2cont (eq (ir2-continuation-kind 2cont) :unknown))
 	  (vop* multiple-call-local node block (fp nfp temp-refs)
@@ -757,7 +770,7 @@
 	  ((node-tail-p node)
 	   (ir2-convert-tail-local-call node block fun))
 	  (t
-	   (let ((start (block-label (node-block (lambda-bind fun))))
+	   (let ((start (block-label (lambda-block fun)))
 		 (returns (tail-set-info (lambda-tail-set fun)))
 		 (cont (node-cont node)))
 	     (ecase (if returns
@@ -772,32 +785,33 @@
 
 ;;;; full call
 
-;;; Given a function continuation Fun, return as values a TN holding
+;;; Given a function continuation FUN, return as values a TN holding
 ;;; the thing that we call and true if the thing is named (false if it
 ;;; is a function). There are two interesting non-named cases:
-;;; -- Known to be a function, no check needed: return the continuation loc.
-;;; -- Not known what it is.
+;;;   -- Known to be a function, no check needed: return the
+;;;      continuation loc.
+;;;   -- Not known what it is.
 (defun function-continuation-tn (node block cont)
   (declare (type continuation cont))
   (let ((2cont (continuation-info cont)))
     (if (eq (ir2-continuation-kind 2cont) :delayed)
-	(let ((name (continuation-function-name cont t)))
-	  (assert name)
+	(let ((name (continuation-fun-name cont t)))
+	  (aver name)
 	  (values (make-load-time-constant-tn :fdefinition name) t))
 	(let* ((locs (ir2-continuation-locs 2cont))
 	       (loc (first locs))
 	       (check (continuation-type-check cont))
 	       (function-ptype (primitive-type-or-lose 'function)))
-	  (assert (and (eq (ir2-continuation-kind 2cont) :fixed)
-		       (= (length locs) 1)))
+	  (aver (and (eq (ir2-continuation-kind 2cont) :fixed)
+		     (= (length locs) 1)))
 	  (cond ((eq (tn-primitive-type loc) function-ptype)
-		 (assert (not (eq check t)))
+		 (aver (not (eq check t)))
 		 (values loc nil))
 		(t
 		 (let ((temp (make-normal-tn function-ptype)))
-		   (assert (and (eq (ir2-continuation-primitive-type 2cont)
-				    function-ptype)
-				(eq check t)))
+		   (aver (and (eq (ir2-continuation-primitive-type 2cont)
+				  function-ptype)
+			      (eq check t)))
 		   (emit-type-check node block loc temp
 				    (specifier-type 'function))
 		   (values temp nil))))))))
@@ -823,12 +837,12 @@
 ;;; named) tail call.
 (defun ir2-convert-tail-full-call (node block)
   (declare (type combination node) (type ir2-block block))
-  (let* ((env (environment-info (node-environment node)))
+  (let* ((env (physenv-info (node-physenv node)))
 	 (args (basic-combination-args node))
 	 (nargs (length args))
 	 (pass-refs (move-tail-full-call-args node block))
-	 (old-fp (ir2-environment-old-fp env))
-	 (return-pc (ir2-environment-return-pc env)))
+	 (old-fp (ir2-physenv-old-fp env))
+	 (return-pc (ir2-physenv-return-pc env)))
 
     (multiple-value-bind (fun-tn named)
 	(function-continuation-tn node block (basic-combination-fun node))
@@ -904,6 +918,29 @@
 		  arg-locs nargs)))))
   (values))
 
+;;; stuff to check in CHECK-FULL-CALL
+;;;
+;;; There are some things which are intended always to be optimized
+;;; away by DEFTRANSFORMs and such, and so never compiled into full
+;;; calls. This has been a source of bugs so many times that it seems
+;;; worth listing some of them here so that we can check the list
+;;; whenever we compile a full call.
+;;;
+;;; FIXME: It might be better to represent this property by setting a
+;;; flag in DEFKNOWN, instead of representing it by membership in this
+;;; list.
+(defvar *always-optimized-away*
+  '(;; This should always be DEFTRANSFORMed away, but wasn't in a bug
+    ;; reported to cmucl-imp@cons.org 2000-06-20.
+    %instance-ref
+    ;; These should always turn into VOPs, but wasn't in a bug which
+    ;; appeared when LTN-POLICY stuff was being tweaked in
+    ;; sbcl-0.6.9.16. in sbcl-0.6.0
+    data-vector-set
+    data-vector-ref))
+
+;;; more stuff to check in CHECK-FULL-CALL
+;;;
 ;;; These came in handy when troubleshooting cold boot after making
 ;;; major changes in the package structure: various transforms and
 ;;; VOPs and stuff got attached to the wrong symbol, so that
@@ -914,15 +951,14 @@
 #!+sb-show (defvar *show-full-called-fnames-p* nil)
 #!+sb-show (defvar *full-called-fnames* (make-hash-table :test 'equal))
 
-;;; If the call is in a tail recursive position and the return
-;;; convention is standard, then do a tail full call. If one or fewer
-;;; values are desired, then use a single-value call, otherwise use a
-;;; multiple-values call.
-(defun ir2-convert-full-call (node block)
-  (declare (type combination node) (type ir2-block block))
-
+;;; Do some checks on a full call:
+;;;   * Is this a full call to something we have reason to know should
+;;;     never be full called?
+;;;   * Is this a full call to (SETF FOO) which might conflict with
+;;;     a DEFSETF or some such thing elsewhere in the program?
+(defun check-full-call (node)
   (let* ((cont (basic-combination-fun node))
-	 (fname (continuation-function-name cont t)))
+	 (fname (continuation-fun-name cont t)))
     (declare (type (or symbol cons) fname))
 
     #!+sb-show (unless (gethash fname *full-called-fnames*)
@@ -930,6 +966,8 @@
     #!+sb-show (when *show-full-called-fnames-p*
 		 (/show "converting full call to named function" fname)
 		 (/show (basic-combination-args node))
+		 (/show (policy node speed) (policy node safety))
+		 (/show (policy node compilation-speed))
 		 (let ((arg-types (mapcar (lambda (maybe-continuation)
 					    (when maybe-continuation
 					      (type-specifier
@@ -938,11 +976,23 @@
 					  (basic-combination-args node))))
 		   (/show arg-types)))
 
+    (when (memq fname *always-optimized-away*)
+      (/show (policy node speed) (policy node safety))
+      (/show (policy node compilation-speed))
+      (error "internal error: full call to ~S" fname))
+
     (when (consp fname)
       (destructuring-bind (setf stem) fname
-	(assert (eq setf 'setf))
-	(setf (gethash stem *setf-assumed-fboundp*) t))))
+	(aver (eq setf 'setf))
+	(setf (gethash stem *setf-assumed-fboundp*) t)))))
 
+;;; If the call is in a tail recursive position and the return
+;;; convention is standard, then do a tail full call. If one or fewer
+;;; values are desired, then use a single-value call, otherwise use a
+;;; multiple-values call.
+(defun ir2-convert-full-call (node block)
+  (declare (type combination node) (type ir2-block block))
+  (check-full-call node)
   (let ((2cont (continuation-info (node-cont node))))
     (cond ((node-tail-p node)
 	   (ir2-convert-tail-full-call node block))
@@ -951,7 +1001,6 @@
 	   (ir2-convert-multiple-full-call node block))
 	  (t
 	   (ir2-convert-fixed-full-call node block))))
-
   (values))
 
 ;;;; entering functions
@@ -965,8 +1014,8 @@
 (defun init-xep-environment (node block fun)
   (declare (type bind node) (type ir2-block block) (type clambda fun))
   (let ((start-label (entry-info-offset (leaf-info fun)))
-	(env (environment-info (node-environment node))))
-    (let ((ef (functional-entry-function fun)))
+	(env (physenv-info (node-physenv node))))
+    (let ((ef (functional-entry-fun fun)))
       (cond ((and (optional-dispatch-p ef) (optional-dispatch-more-entry ef))
 	     ;; Special case the xep-allocate-frame + copy-more-arg case.
 	     (vop xep-allocate-frame node block start-label t)
@@ -974,17 +1023,17 @@
 	    (t
 	     ;; No more args, so normal entry.
 	     (vop xep-allocate-frame node block start-label nil)))
-      (if (ir2-environment-environment env)
+      (if (ir2-physenv-closure env)
 	  (let ((closure (make-normal-tn *backend-t-primitive-type*)))
 	    (vop setup-closure-environment node block start-label closure)
 	    (when (getf (functional-plist ef) :fin-function)
 	      (vop funcallable-instance-lexenv node block closure closure))
 	    (let ((n -1))
-	      (dolist (loc (ir2-environment-environment env))
+	      (dolist (loc (ir2-physenv-closure env))
 		(vop closure-ref node block closure (incf n) (cdr loc)))))
 	  (vop setup-environment node block start-label)))
 
-    (unless (eq (functional-kind fun) :top-level)
+    (unless (eq (functional-kind fun) :toplevel)
       (let ((vars (lambda-vars fun))
 	    (n 0))
 	(when (leaf-refs (first vars))
@@ -1000,13 +1049,13 @@
 	  (incf n))))
 
     (emit-move node block (make-old-fp-passing-location t)
-	       (ir2-environment-old-fp env)))
+	       (ir2-physenv-old-fp env)))
 
   (values))
 
 ;;; Emit function prolog code. This is only called on bind nodes for
 ;;; functions that allocate environments. All semantics of let calls
-;;; are handled by IR2-Convert-Let.
+;;; are handled by IR2-CONVERT-LET.
 ;;;
 ;;; If not an XEP, all we do is move the return PC from its passing
 ;;; location, since in a local call, the caller allocates the frame
@@ -1014,9 +1063,9 @@
 (defun ir2-convert-bind (node block)
   (declare (type bind node) (type ir2-block block))
   (let* ((fun (bind-lambda node))
-	 (env (environment-info (lambda-environment fun))))
-    (assert (member (functional-kind fun)
-		    '(nil :external :optional :top-level :cleanup)))
+	 (env (physenv-info (lambda-physenv fun))))
+    (aver (member (functional-kind fun)
+		  '(nil :external :optional :toplevel :cleanup)))
 
     (when (external-entry-point-p fun)
       (init-xep-environment node block fun)
@@ -1025,11 +1074,13 @@
 	(vop count-me node block *dynamic-counts-tn*
 	     (block-number (ir2-block-block block)))))
 
-    (emit-move node block (ir2-environment-return-pc-pass env)
-	       (ir2-environment-return-pc env))
+    (emit-move node
+	       block
+	       (ir2-physenv-return-pc-pass env)
+	       (ir2-physenv-return-pc env))
 
     (let ((lab (gen-label)))
-      (setf (ir2-environment-environment-start env) lab)
+      (setf (ir2-physenv-environment-start env) lab)
       (vop note-environment-start node block lab)))
 
   (values))
@@ -1049,9 +1100,9 @@
 	 (2cont (continuation-info cont))
 	 (cont-kind (ir2-continuation-kind 2cont))
 	 (fun (return-lambda node))
-	 (env (environment-info (lambda-environment fun)))
-	 (old-fp (ir2-environment-old-fp env))
-	 (return-pc (ir2-environment-return-pc env))
+	 (env (physenv-info (lambda-physenv fun)))
+	 (old-fp (ir2-physenv-old-fp env))
+	 (return-pc (ir2-physenv-return-pc env))
 	 (returns (tail-set-info (lambda-tail-set fun))))
     (cond
      ((and (eq (return-info-kind returns) :fixed)
@@ -1078,7 +1129,7 @@
 		  (nil)
 		  nvals))))
      (t
-      (assert (eq cont-kind :unknown))
+      (aver (eq cont-kind :unknown))
       (vop* return-multiple node block
 	    (old-fp return-pc
 		    (reference-tn-list (ir2-continuation-locs 2cont) nil))
@@ -1092,10 +1143,10 @@
 ;;; stack. It returns the OLD-FP and RETURN-PC for the current
 ;;; function as multiple values.
 (defoptimizer (sb!kernel:%caller-frame-and-pc ir2-convert) (() node block)
-  (let ((env (environment-info (node-environment node))))
+  (let ((ir2-physenv (physenv-info (node-physenv node))))
     (move-continuation-result node block
-			      (list (ir2-environment-old-fp env)
-				    (ir2-environment-return-pc env))
+			      (list (ir2-physenv-old-fp ir2-physenv)
+				    (ir2-physenv-return-pc ir2-physenv))
 			      (node-cont node))))
 
 ;;;; multiple values
@@ -1109,7 +1160,7 @@
   (let* ((cont (first (basic-combination-args node)))
 	 (fun (ref-leaf (continuation-use (basic-combination-fun node))))
 	 (vars (lambda-vars fun)))
-    (assert (eq (functional-kind fun) :mv-let))
+    (aver (eq (functional-kind fun) :mv-let))
     (mapc #'(lambda (src var)
 	      (when (leaf-refs var)
 		(let ((dest (leaf-info var)))
@@ -1130,7 +1181,7 @@
 ;;; contiguous and on stack top.
 (defun ir2-convert-mv-call (node block)
   (declare (type mv-combination node) (type ir2-block block))
-  (assert (basic-combination-args node))
+  (aver (basic-combination-args node))
   (let* ((start-cont (continuation-info (first (basic-combination-args node))))
 	 (start (first (ir2-continuation-locs start-cont)))
 	 (tails (and (node-tail-p node)
@@ -1139,14 +1190,14 @@
 	 (2cont (continuation-info cont)))
     (multiple-value-bind (fun named)
 	(function-continuation-tn node block (basic-combination-fun node))
-      (assert (and (not named)
-		   (eq (ir2-continuation-kind start-cont) :unknown)))
+      (aver (and (not named)
+		 (eq (ir2-continuation-kind start-cont) :unknown)))
       (cond
        (tails
-	(let ((env (environment-info (node-environment node))))
+	(let ((env (physenv-info (node-physenv node))))
 	  (vop tail-call-variable node block start fun
-	       (ir2-environment-old-fp env)
-	       (ir2-environment-return-pc env))))
+	       (ir2-physenv-old-fp env)
+	       (ir2-physenv-return-pc env))))
        ((and 2cont
 	     (eq (ir2-continuation-kind 2cont) :unknown))
 	(vop* multiple-call-variable node block (start fun nil)
@@ -1162,7 +1213,7 @@
 ;;; top of it.)
 (defoptimizer (%pop-values ir2-convert) ((continuation) node block)
   (let ((2cont (continuation-info (continuation-value continuation))))
-    (assert (eq (ir2-continuation-kind 2cont) :unknown))
+    (aver (eq (ir2-continuation-kind 2cont) :unknown))
     (vop reset-stack-pointer node block
 	 (first (ir2-continuation-locs 2cont)))))
 
@@ -1211,30 +1262,28 @@
 ;;; This is trivial, given our assumption of a shallow-binding
 ;;; implementation.
 (defoptimizer (%special-bind ir2-convert) ((var value) node block)
-  (let ((name (leaf-name (continuation-value var))))
+  (let ((name (leaf-source-name (continuation-value var))))
     (vop bind node block (continuation-tn node block value)
 	 (emit-constant name))))
 (defoptimizer (%special-unbind ir2-convert) ((var) node block)
   (vop unbind node block))
 
-;;; ### Not clear that this really belongs in this file, or should
-;;; really be done this way, but this is the least violation of
+;;; ### It's not clear that this really belongs in this file, or
+;;; should really be done this way, but this is the least violation of
 ;;; abstraction in the current setup. We don't want to wire
 ;;; shallow-binding assumptions into IR1tran.
 (def-ir1-translator progv ((vars vals &body body) start cont)
   (ir1-convert
    start cont
-   (if (or *converting-for-interpreter* (byte-compiling))
-       `(%progv ,vars ,vals #'(lambda () ,@body))
-       (once-only ((n-save-bs '(%primitive current-binding-pointer)))
-	 `(unwind-protect
-	      (progn
-		(mapc #'(lambda (var val)
-			  (%primitive bind val var))
-		      ,vars
-		      ,vals)
-		,@body)
-	    (%primitive unbind-to-here ,n-save-bs))))))
+   (once-only ((n-save-bs '(%primitive current-binding-pointer)))
+     `(unwind-protect
+	  (progn
+	    (mapc #'(lambda (var val)
+		      (%primitive bind val var))
+		  ,vars
+		  ,vals)
+	    ,@body)
+	(%primitive unbind-to-here ,n-save-bs)))))
 
 ;;;; non-local exit
 
@@ -1244,9 +1293,9 @@
 ;;; IR2 converted.
 (defun ir2-convert-exit (node block)
   (declare (type exit node) (type ir2-block block))
-  (let ((loc (find-in-environment (find-nlx-info (exit-entry node)
-						 (node-cont node))
-				  (node-environment node)))
+  (let ((loc (find-in-physenv (find-nlx-info (exit-entry node)
+					     (node-cont node))
+			      (node-physenv node)))
 	(temp (make-stack-pointer-tn))
 	(value (exit-value node)))
     (vop value-cell-ref node block loc temp)
@@ -1267,7 +1316,7 @@
 ;;; cell that holds the closed unwind block.
 (defoptimizer (%lexical-exit-breakup ir2-convert) ((info) node block)
   (vop value-cell-set node block
-       (find-in-environment (continuation-value info) (node-environment node))
+       (find-in-physenv (continuation-value info) (node-physenv node))
        (emit-constant 0)))
 
 ;;; We have to do a spurious move of no values to the result
@@ -1281,7 +1330,6 @@
 	    (ir2-continuation-locs (continuation-info (second args)))
 	    nil))
 	  (nil)))
-
   (move-continuation-result node block () (node-cont node))
   (values))
 
@@ -1294,9 +1342,9 @@
 	   (type (or continuation null) tag))
   (let* ((2info (nlx-info-info info))
 	 (kind (cleanup-kind (nlx-info-cleanup info)))
-	 (block-tn (environment-live-tn
+	 (block-tn (physenv-live-tn
 		    (make-normal-tn (primitive-type-or-lose 'catch-block))
-		    (node-environment node)))
+		    (node-physenv node)))
 	 (res (make-stack-pointer-tn))
 	 (target-label (ir2-nlx-info-target 2info)))
 
@@ -1405,7 +1453,7 @@
 
 ;;;; n-argument functions
 
-(macrolet ((frob (name)
+(macrolet ((def-frob (name)
 	     `(defoptimizer (,name ir2-convert) ((&rest args) node block)
 		(let* ((refs (move-tail-full-call-args node block))
 		       (cont (node-cont node))
@@ -1415,8 +1463,8 @@
 		  (vop* ,name node block (refs) ((first res) nil)
 			(length args))
 		  (move-continuation-result node block res cont)))))
-  (frob list)
-  (frob list*))
+  (def-frob list)
+  (def-frob list*))
 
 ;;;; structure accessors
 ;;;;
@@ -1483,7 +1531,7 @@
 		(unless (or (and (bind-p first-node)
 				 (external-entry-point-p
 				  (bind-lambda first-node)))
-			    (eq (continuation-function-name
+			    (eq (continuation-fun-name
 				 (node-cont first-node))
 				'%nlx-entry))
 		  (vop count-me
@@ -1506,14 +1554,16 @@
 	 (last (block-last block))
 	 (succ (block-succ block)))
     (unless (if-p last)
-      (assert (and succ (null (rest succ))))
+      (aver (and succ (null (rest succ))))
       (let ((target (first succ)))
 	(cond ((eq target (component-tail (block-component block)))
 	       (when (and (basic-combination-p last)
 			  (eq (basic-combination-kind last) :full))
 		 (let* ((fun (basic-combination-fun last))
 			(use (continuation-use fun))
-			(name (and (ref-p use) (leaf-name (ref-leaf use)))))
+			(name (and (ref-p use)
+				   (leaf-has-source-name-p (ref-leaf use))
+				   (leaf-source-name (ref-leaf use)))))
 		   (unless (or (node-tail-p last)
 			       (info :function :info name)
 			       (policy last (zerop safety)))
@@ -1522,7 +1572,7 @@
 			      (emit-constant name)
 			      (multiple-value-bind (tn named)
 				  (function-continuation-tn last 2block fun)
-				(assert (not named))
+				(aver (not named))
 				tn)))))))
 	      ((not (eq (ir2-block-next 2block) (block-info target)))
 	       (vop branch last 2block (block-label target)))))))
@@ -1570,7 +1620,7 @@
 	 (cond
 	  ((eq (basic-combination-kind node) :local)
 	   (ir2-convert-mv-bind node 2block))
-	  ((eq (continuation-function-name (basic-combination-fun node))
+	  ((eq (continuation-fun-name (basic-combination-fun node))
 	       '%throw)
 	   (ir2-convert-throw node 2block))
 	  (t