X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fdebug-int.lisp;h=5e7a1fc94d0d8e43169d5dcf4fb36d2fcbdb1048;hb=986ce2596822cc0871b609346aaf592348aca596;hp=140e90de8e9e3b454d5b16347fcad047a3f2f602;hpb=f143939b1dbaf38ebd4f92c851fbc4ecddf37af1;p=sbcl.git

diff --git a/src/code/debug-int.lisp b/src/code/debug-int.lisp
index 140e90d..5e7a1fc 100644
--- a/src/code/debug-int.lisp
+++ b/src/code/debug-int.lisp
@@ -105,13 +105,13 @@
 		     (invalid-value-debug-var condition)
 		     (invalid-value-frame condition)))))
 
-(define-condition ambiguous-variable-name (debug-condition)
-  ((name :reader ambiguous-variable-name-name :initarg :name)
-   (frame :reader ambiguous-variable-name-frame :initarg :frame))
+(define-condition ambiguous-var-name (debug-condition)
+  ((name :reader ambiguous-var-name-name :initarg :name)
+   (frame :reader ambiguous-var-name-frame :initarg :frame))
   (:report (lambda (condition stream)
 	     (format stream "~&~S names more than one valid variable in ~S."
-		     (ambiguous-variable-name-name condition)
-		     (ambiguous-variable-name-frame condition)))))
+		     (ambiguous-var-name-name condition)
+		     (ambiguous-var-name-frame condition)))))
 
 ;;;; errors and DEBUG-SIGNAL
 
@@ -195,10 +195,10 @@
 (defstruct (debug-var (:constructor nil)
 		      (:copier nil))
   ;; the name of the variable
-  (symbol (required-argument) :type symbol)
+  (symbol (missing-arg) :type symbol)
   ;; a unique integer identification relative to other variables with the same
   ;; symbol
-  (id 0 :type sb!c::index)
+  (id 0 :type index)
   ;; Does the variable always have a valid value?
   (alive-p nil :type boolean))
 (def!method print-object ((debug-var debug-var) stream)
@@ -219,9 +219,9 @@
 			  (symbol id alive-p sc-offset save-sc-offset))
 	    (:copier nil))
   ;; storage class and offset (unexported)
-  (sc-offset nil :type sb!c::sc-offset)
+  (sc-offset nil :type sb!c:sc-offset)
   ;; storage class and offset when saved somewhere
-  (save-sc-offset nil :type (or sb!c::sc-offset null)))
+  (save-sc-offset nil :type (or sb!c:sc-offset null)))
 
 ;;;; frames
 
@@ -349,7 +349,7 @@
   (elsewhere-p nil :type boolean))
 (def!method print-object ((obj debug-block) str)
   (print-unreadable-object (obj str :type t)
-    (prin1 (debug-block-function-name obj) str)))
+    (prin1 (debug-block-fun-name obj) str)))
 
 #!+sb-doc
 (setf (fdocumentation 'debug-block-successors 'function)
@@ -380,7 +380,7 @@
   ;; This is the component in which the breakpoint lies.
   component
   ;; This is the byte offset into the component.
-  (offset nil :type sb!c::index)
+  (offset nil :type index)
   ;; The original instruction replaced by the breakpoint.
   (instruction nil :type (or null (unsigned-byte 32)))
   ;; A list of user breakpoints at this location.
@@ -467,10 +467,10 @@
   (%debug-block :unparsed :type (or debug-block (member :unparsed)))
   ;; This is the number of forms processed by the compiler or loader
   ;; before the top-level form containing this code-location.
-  (%tlf-offset :unparsed :type (or sb!c::index (member :unparsed)))
+  (%tlf-offset :unparsed :type (or index (member :unparsed)))
   ;; This is the depth-first number of the node that begins
   ;; code-location within its top-level form.
-  (%form-number :unparsed :type (or sb!c::index (member :unparsed))))
+  (%form-number :unparsed :type (or index (member :unparsed))))
 (def!method print-object ((obj code-location) str)
   (print-unreadable-object (obj str :type t)
     (prin1 (debug-fun-name (code-location-debug-fun obj))
@@ -484,7 +484,7 @@
 	    (:constructor make-compiled-code-location (pc debug-fun))
 	    (:copier nil))
   ;; an index into DEBUG-FUN's component slot
-  (pc nil :type sb!c::index)
+  (pc nil :type index)
   ;; a bit-vector indexed by a variable's position in
   ;; DEBUG-FUN-DEBUG-VARS indicating whether the variable has a
   ;; valid value at this code-location. (unexported).
@@ -545,7 +545,7 @@
 (defun component-from-component-ptr (component-ptr)
   (declare (type system-area-pointer component-ptr))
   (make-lisp-obj (logior (sap-int component-ptr)
-			 sb!vm:other-pointer-type)))
+			 sb!vm:other-pointer-lowtag)))
 
 ;;;; X86 support
 
@@ -557,10 +557,10 @@
   (let ((component-ptr (component-ptr-from-pc pc)))
     (unless (sap= component-ptr (int-sap #x0))
        (let* ((code (component-from-component-ptr component-ptr))
-	      (code-header-len (* (get-header-data code) sb!vm:word-bytes))
+	      (code-header-len (* (get-header-data code) sb!vm:n-word-bytes))
 	      (pc-offset (- (sap-int pc)
 			    (- (get-lisp-obj-address code)
-			       sb!vm:other-pointer-type)
+			       sb!vm:other-pointer-lowtag)
 			    code-header-len)))
 ;	 (format t "c-lra-fpc ~A ~A ~A~%" pc code pc-offset)
 	 (values pc-offset code)))))
@@ -599,11 +599,11 @@
     nil)
    (t
     ;; Check the two possible frame pointers.
-    (let ((lisp-ocfp (sap-ref-sap fp (- (* (1+ sb!vm::ocfp-save-offset) 4))))
-	  (lisp-ra (sap-ref-sap fp (- (* (1+ sb!vm::return-pc-save-offset)
+    (let ((lisp-ocfp (sap-ref-sap fp (- (* (1+ ocfp-save-offset) 4))))
+	  (lisp-ra (sap-ref-sap fp (- (* (1+ return-pc-save-offset)
 					 4))))
-	  (c-ocfp (sap-ref-sap fp (* 0 sb!vm:word-bytes)))
-	  (c-ra (sap-ref-sap fp (* 1 sb!vm:word-bytes))))
+	  (c-ocfp (sap-ref-sap fp (* 0 sb!vm:n-word-bytes)))
+	  (c-ra (sap-ref-sap fp (* 1 sb!vm:n-word-bytes))))
       (cond ((and (sap> lisp-ocfp fp) (cstack-pointer-valid-p lisp-ocfp)
 		  (ra-pointer-valid-p lisp-ra)
 		  (sap> c-ocfp fp) (cstack-pointer-valid-p c-ocfp)
@@ -697,10 +697,10 @@
 		     (compute-calling-frame
 		      (descriptor-sap
 		       (get-context-value
-			frame sb!vm::ocfp-save-offset
+			frame ocfp-save-offset
 			(sb!c::compiled-debug-fun-old-fp c-d-f)))
 		      (get-context-value
-		       frame sb!vm::lra-save-offset
+		       frame lra-save-offset
 		       (sb!c::compiled-debug-fun-return-pc c-d-f))
 		      frame)))
 		  (bogus-debug-fun
@@ -712,14 +712,14 @@
 			#!-x86
 		       (compute-calling-frame
 			#!-alpha
-			(sap-ref-sap fp (* sb!vm::ocfp-save-offset
-					   sb!vm:word-bytes))
+			(sap-ref-sap fp (* ocfp-save-offset
+					   sb!vm:n-word-bytes))
 			#!+alpha
 			(int-sap
-			 (sap-ref-32 fp (* sb!vm::ocfp-save-offset
-					   sb!vm:word-bytes)))
+			 (sap-ref-32 fp (* ocfp-save-offset
+					   sb!vm:n-word-bytes)))
 
-			(stack-ref fp sb!vm::lra-save-offset)
+			(stack-ref fp lra-save-offset)
 
 			frame)))))))
 	down)))
@@ -730,7 +730,7 @@
 #!-x86
 (defun get-context-value (frame stack-slot loc)
   (declare (type compiled-frame frame) (type unsigned-byte stack-slot)
-	   (type sb!c::sc-offset loc))
+	   (type sb!c:sc-offset loc))
   (let ((pointer (frame-pointer frame))
 	(escaped (compiled-frame-escaped frame)))
     (if escaped
@@ -739,21 +739,21 @@
 #!+x86
 (defun get-context-value (frame stack-slot loc)
   (declare (type compiled-frame frame) (type unsigned-byte stack-slot)
-	   (type sb!c::sc-offset loc))
+	   (type sb!c:sc-offset loc))
   (let ((pointer (frame-pointer frame))
 	(escaped (compiled-frame-escaped frame)))
     (if escaped
 	(sub-access-debug-var-slot pointer loc escaped)
 	(ecase stack-slot
-	  (#.sb!vm::ocfp-save-offset
+	  (#.ocfp-save-offset
 	   (stack-ref pointer stack-slot))
-	  (#.sb!vm::lra-save-offset
+	  (#.lra-save-offset
 	   (sap-ref-sap pointer (- (* (1+ stack-slot) 4))))))))
 
 #!-x86
 (defun (setf get-context-value) (value frame stack-slot loc)
   (declare (type compiled-frame frame) (type unsigned-byte stack-slot)
-	   (type sb!c::sc-offset loc))
+	   (type sb!c:sc-offset loc))
   (let ((pointer (frame-pointer frame))
 	(escaped (compiled-frame-escaped frame)))
     (if escaped
@@ -763,15 +763,15 @@
 #!+x86
 (defun (setf get-context-value) (value frame stack-slot loc)
   (declare (type compiled-frame frame) (type unsigned-byte stack-slot)
-	   (type sb!c::sc-offset loc))
+	   (type sb!c:sc-offset loc))
   (let ((pointer (frame-pointer frame))
 	(escaped (compiled-frame-escaped frame)))
     (if escaped
 	(sub-set-debug-var-slot pointer loc value escaped)
 	(ecase stack-slot
-	  (#.sb!vm::ocfp-save-offset
+	  (#.ocfp-save-offset
 	   (setf (stack-ref pointer stack-slot) value))
-	  (#.sb!vm::lra-save-offset
+	  (#.lra-save-offset
 	   (setf (sap-ref-sap pointer (- (* (1+ stack-slot) 4))) value))))))
 
 ;;; This returns a frame for the one existing in time immediately
@@ -798,13 +798,13 @@
 		(if (fixnump lra)
 		    (let ((fp (frame-pointer up-frame)))
 		      (values lra
-			      (stack-ref fp (1+ sb!vm::lra-save-offset))))
+			      (stack-ref fp (1+ lra-save-offset))))
 		    (values (get-header-data lra)
 			    (lra-code-header lra)))
 	      (if code
 		  (values code
 			  (* (1+ (- word-offset (get-header-data code)))
-			     sb!vm:word-bytes)
+			     sb!vm:n-word-bytes)
 			  nil)
 		  (values :foreign-function
 			  0
@@ -902,16 +902,16 @@
 	     (when (null code)
 	       (return (values code 0 context)))
 	     (let* ((code-header-len (* (get-header-data code)
-					sb!vm:word-bytes))
+					sb!vm:n-word-bytes))
 		    (pc-offset
 		     (- (sap-int (sb!vm:context-pc context))
 			(- (get-lisp-obj-address code)
-			   sb!vm:other-pointer-type)
+			   sb!vm:other-pointer-lowtag)
 			code-header-len)))
 	       (/show "got PC-OFFSET")
 	       (unless (<= 0 pc-offset
 			   (* (code-header-ref code sb!vm:code-code-size-slot)
-			      sb!vm:word-bytes))
+			      sb!vm:n-word-bytes))
 		 ;; We were in an assembly routine. Therefore, use the
 		 ;; LRA as the pc.
 		 ;;
@@ -937,20 +937,20 @@
             (when (symbolp code)
               (return (values code 0 scp)))
             (let* ((code-header-len (* (get-header-data code)
-                                       sb!vm:word-bytes))
+                                       sb!vm:n-word-bytes))
                    (pc-offset
                     (- (sap-int (sb!vm:context-pc scp))
                        (- (get-lisp-obj-address code)
-                          sb!vm:other-pointer-type)
+                          sb!vm:other-pointer-lowtag)
                        code-header-len)))
               ;; Check to see whether we were executing in a branch
               ;; delay slot.
               #!+(or pmax sgi) ; pmax only (and broken anyway)
               (when (logbitp 31 (sb!alien:slot scp '%mips::sc-cause))
-                (incf pc-offset sb!vm:word-bytes))
+                (incf pc-offset sb!vm:n-word-bytes))
               (unless (<= 0 pc-offset
                           (* (code-header-ref code sb!vm:code-code-size-slot)
-                             sb!vm:word-bytes))
+                             sb!vm:n-word-bytes))
                 ;; We were in an assembly routine. Therefore, use the
                 ;; LRA as the pc.
                 (setf pc-offset
@@ -975,12 +975,12 @@
     (if (functionp object)
 	(or (fun-code-header object)
 	    :undefined-function)
-	(let ((lowtag (get-lowtag object)))
-	  (if (= lowtag sb!vm:other-pointer-type)
-	      (let ((type (get-type object)))
-		(cond ((= type sb!vm:code-header-type)
+	(let ((lowtag (lowtag-of object)))
+	  (if (= lowtag sb!vm:other-pointer-lowtag)
+	      (let ((widetag (widetag-of object)))
+		(cond ((= widetag sb!vm:code-header-widetag)
 		       object)
-		      ((= type sb!vm:return-pc-header-type)
+		      ((= widetag sb!vm:return-pc-header-widetag)
 		       (lra-code-header object))
 		      (t
 		       nil))))))))
@@ -1052,18 +1052,18 @@
 		  #!-alpha
 		  (sap-ref-sap catch
 				      (* sb!vm:catch-block-current-cont-slot
-					 sb!vm:word-bytes))
+					 sb!vm:n-word-bytes))
 		  #!+alpha
 		  (:int-sap
 		   (sap-ref-32 catch
 				      (* sb!vm:catch-block-current-cont-slot
-					 sb!vm:word-bytes))))
+					 sb!vm:n-word-bytes))))
 	(let* (#!-x86
 	       (lra (stack-ref catch sb!vm:catch-block-entry-pc-slot))
 	       #!+x86
 	       (ra (sap-ref-sap
 		    catch (* sb!vm:catch-block-entry-pc-slot
-			     sb!vm:word-bytes)))
+			     sb!vm:n-word-bytes)))
 	       #!-x86
 	       (component
 		(stack-ref catch sb!vm:catch-block-current-code-slot))
@@ -1074,18 +1074,18 @@
 		#!-x86
 		(* (- (1+ (get-header-data lra))
 		      (get-header-data component))
-		   sb!vm:word-bytes)
+		   sb!vm:n-word-bytes)
 		#!+x86
 		(- (sap-int ra)
 		   (- (get-lisp-obj-address component)
-		      sb!vm:other-pointer-type)
-		   (* (get-header-data component) sb!vm:word-bytes))))
+		      sb!vm:other-pointer-lowtag)
+		   (* (get-header-data component) sb!vm:n-word-bytes))))
 	  (push (cons #!-x86
 		      (stack-ref catch sb!vm:catch-block-tag-slot)
 		      #!+x86
 		      (make-lisp-obj
 		       (sap-ref-32 catch (* sb!vm:catch-block-tag-slot
-						   sb!vm:word-bytes)))
+						   sb!vm:n-word-bytes)))
 		      (make-compiled-code-location
 		       offset (frame-debug-fun frame)))
 		res)))
@@ -1093,12 +1093,12 @@
 	    #!-alpha
 	    (sap-ref-sap catch
 				(* sb!vm:catch-block-previous-catch-slot
-				   sb!vm:word-bytes))
+				   sb!vm:n-word-bytes))
 	    #!+alpha
 	    (:int-sap
 	     (sap-ref-32 catch
 				(* sb!vm:catch-block-previous-catch-slot
-				   sb!vm:word-bytes)))))))
+				   sb!vm:n-word-bytes)))))))
 
 ;;;; operations on DEBUG-FUNs
 
@@ -1173,13 +1173,13 @@
 ;;; Return a DEBUG-FUN that represents debug information for FUN.
 (defun fun-debug-fun (fun)
   (declare (type function fun))
-  (ecase (get-type fun)
-    (#.sb!vm:closure-header-type
+  (ecase (widetag-of fun)
+    (#.sb!vm:closure-header-widetag
      (fun-debug-fun (%closure-fun fun)))
-    (#.sb!vm:funcallable-instance-header-type
+    (#.sb!vm:funcallable-instance-header-widetag
      (fun-debug-fun (funcallable-instance-fun fun)))
-    ((#.sb!vm:simple-fun-header-type
-      #.sb!vm:closure-fun-header-type)
+    ((#.sb!vm:simple-fun-header-widetag
+      #.sb!vm:closure-fun-header-widetag)
       (let* ((name (%simple-fun-name fun))
 	     (component (fun-code-header fun))
 	     (res (find-if
@@ -1202,7 +1202,7 @@
 	    (debug-fun-from-pc component
 			       (* (- (fun-word-offset fun)
 				     (get-header-data component))
-				  sb!vm:word-bytes)))))))
+				  sb!vm:n-word-bytes)))))))
 
 ;;; Return the kind of the function, which is one of :OPTIONAL,
 ;;; :EXTERNAL, TOP-level, :CLEANUP, or NIL.
@@ -1475,8 +1475,8 @@
 	   (debug-signal 'no-debug-blocks
 			 :debug-fun debug-fun)))))
 
-;;; This returns a SIMPLE-VECTOR of DEBUG-BLOCKs or NIL. NIL indicates
-;;; there was no basic block information.
+;;; Return a SIMPLE-VECTOR of DEBUG-BLOCKs or NIL. NIL indicates there
+;;; was no basic block information.
 (defun parse-debug-blocks (debug-fun)
   (etypecase debug-fun
     (compiled-debug-fun
@@ -1486,16 +1486,17 @@
 
 ;;; This does some of the work of PARSE-DEBUG-BLOCKS.
 (defun parse-compiled-debug-blocks (debug-fun)
-  (let* ((debug-fun (compiled-debug-fun-compiler-debug-fun
-		     debug-fun))
-	 (var-count (length (debug-fun-debug-vars debug-fun)))
-	 (blocks (sb!c::compiled-debug-fun-blocks debug-fun))
+  (let* ((var-count (length (debug-fun-debug-vars debug-fun)))
+	 (compiler-debug-fun (compiled-debug-fun-compiler-debug-fun
+			      debug-fun))
+	 (blocks (sb!c::compiled-debug-fun-blocks compiler-debug-fun))
 	 ;; KLUDGE: 8 is a hard-wired constant in the compiler for the
 	 ;; element size of the packed binary representation of the
 	 ;; blocks data.
 	 (live-set-len (ceiling var-count 8))
-	 (tlf-number (sb!c::compiled-debug-fun-tlf-number debug-fun)))
-    (unless blocks (return-from parse-compiled-debug-blocks nil))
+	 (tlf-number (sb!c::compiled-debug-fun-tlf-number compiler-debug-fun)))
+    (unless blocks
+      (return-from parse-compiled-debug-blocks nil))
     (macrolet ((aref+ (a i) `(prog1 (aref ,a ,i) (incf ,i))))
       (with-parsing-buffer (blocks-buffer locations-buffer)
 	(let ((i 0)
@@ -1710,7 +1711,7 @@
 				  0)))
 		       (svref blocks (1- end)))
 		      (t last))))
-		(declare (type sb!c::index i end))
+		(declare (type index i end))
 		(when (< pc
 			 (compiled-code-location-pc
 			  (svref (compiled-debug-block-code-locations
@@ -1889,7 +1890,7 @@
 
 ;;; Return the name of the function represented by DEBUG-FUN.
 ;;; This may be a string or a cons; do not assume it is a symbol.
-(defun debug-block-function-name (debug-block)
+(defun debug-block-fun-name (debug-block)
   (etypecase debug-block
     (compiled-debug-block
      (let ((code-locs (compiled-debug-block-code-locations debug-block)))
@@ -1968,9 +1969,9 @@
        (zerop (logand val 3))
        ;; character
        (and (zerop (logand val #xffff0000)) ; Top bits zero
-	    (= (logand val #xff) sb!vm:base-char-type)) ; Char tag
+	    (= (logand val #xff) sb!vm:base-char-widetag)) ; char tag
        ;; unbound marker
-       (= val sb!vm:unbound-marker-type)
+       (= val sb!vm:unbound-marker-widetag)
        ;; pointer
        (and (logand val 1)
 	    ;; Check that the pointer is valid. XXX Could do a better
@@ -1978,10 +1979,10 @@
 	    ;; routine in the C runtime support code
 	    (or (< sb!vm:read-only-space-start val
 		   (* sb!vm:*read-only-space-free-pointer*
-		      sb!vm:word-bytes))
+		      sb!vm:n-word-bytes))
 		(< sb!vm:static-space-start val
 		   (* sb!vm:*static-space-free-pointer*
-		      sb!vm:word-bytes))
+		      sb!vm:n-word-bytes))
 		(< sb!vm:dynamic-space-start val
 		   (sap-int (dynamic-space-free-pointer))))))
       (make-lisp-obj val)
@@ -2009,12 +2010,12 @@
                                  (sb!vm:context-register escaped
                                                          sb!vm::nfp-offset))
                                 #!-alpha
-                                (sb!sys:sap-ref-sap fp (* sb!vm::nfp-save-offset
-                                                          sb!vm:word-bytes))
+                                (sb!sys:sap-ref-sap fp (* nfp-save-offset
+                                                          sb!vm:n-word-bytes))
                                 #!+alpha
                                 (sb!vm::make-number-stack-pointer
-                                 (sb!sys:sap-ref-32 fp (* sb!vm::nfp-save-offset
-                                                          sb!vm:word-bytes))))))
+                                 (sb!sys:sap-ref-32 fp (* nfp-save-offset
+                                                          sb!vm:n-word-bytes))))))
                   ,@body)))
     (ecase (sb!c:sc-offset-scn sc-offset)
       ((#.sb!vm:any-reg-sc-number
@@ -2031,8 +2032,8 @@
          (sb!sys:int-sap val)))
       (#.sb!vm:signed-reg-sc-number
        (with-escaped-value (val)
-         (if (logbitp (1- sb!vm:word-bits) val)
-             (logior val (ash -1 sb!vm:word-bits))
+         (if (logbitp (1- sb!vm:n-word-bits) val)
+             (logior val (ash -1 sb!vm:n-word-bits))
              val)))
       (#.sb!vm:unsigned-reg-sc-number
        (with-escaped-value (val)
@@ -2078,57 +2079,57 @@
       (#.sb!vm:single-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
-                                       sb!vm:word-bytes))))
+                                       sb!vm:n-word-bytes))))
       (#.sb!vm:double-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
-                                       sb!vm:word-bytes))))
+                                       sb!vm:n-word-bytes))))
       #!+long-float
       (#.sb!vm:long-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
-                                     sb!vm:word-bytes))))
+                                     sb!vm:n-word-bytes))))
       (#.sb!vm:complex-single-stack-sc-number
        (with-nfp (nfp)
          (complex
           (sb!sys:sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
-                                        sb!vm:word-bytes))
+                                        sb!vm:n-word-bytes))
           (sb!sys:sap-ref-single nfp (* (1+ (sb!c:sc-offset-offset sc-offset))
-                                        sb!vm:word-bytes)))))
+                                        sb!vm:n-word-bytes)))))
       (#.sb!vm:complex-double-stack-sc-number
        (with-nfp (nfp)
          (complex
           (sb!sys:sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
-                                        sb!vm:word-bytes))
+                                        sb!vm:n-word-bytes))
           (sb!sys:sap-ref-double nfp (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-                                        sb!vm:word-bytes)))))
+                                        sb!vm:n-word-bytes)))))
       #!+long-float
       (#.sb!vm:complex-long-stack-sc-number
        (with-nfp (nfp)
          (complex
           (sb!sys:sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
-                                      sb!vm:word-bytes))
+                                      sb!vm:n-word-bytes))
           (sb!sys:sap-ref-long nfp (* (+ (sb!c:sc-offset-offset sc-offset)
                                          #!+sparc 4)
-                                      sb!vm:word-bytes)))))
+                                      sb!vm:n-word-bytes)))))
       (#.sb!vm:control-stack-sc-number
        (sb!kernel:stack-ref fp (sb!c:sc-offset-offset sc-offset)))
       (#.sb!vm:base-char-stack-sc-number
        (with-nfp (nfp)
          (code-char (sb!sys:sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-                                              sb!vm:word-bytes)))))
+                                              sb!vm:n-word-bytes)))))
       (#.sb!vm:unsigned-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-                                   sb!vm:word-bytes))))
+                                   sb!vm:n-word-bytes))))
       (#.sb!vm:signed-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:signed-sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-                                          sb!vm:word-bytes))))
+                                          sb!vm:n-word-bytes))))
       (#.sb!vm:sap-stack-sc-number
        (with-nfp (nfp)
          (sb!sys:sap-ref-sap nfp (* (sb!c:sc-offset-offset sc-offset)
-                                    sb!vm:word-bytes)))))))
+                                    sb!vm:n-word-bytes)))))))
 
 #!+x86
 (defun sub-access-debug-var-slot (fp sc-offset &optional escaped)
@@ -2176,8 +2177,8 @@
       (#.sb!vm:signed-reg-sc-number
        (/show0 "case of SIGNED-REG-SC-NUMBER")
        (with-escaped-value (val)
-	 (if (logbitp (1- sb!vm:word-bits) val)
-	     (logior val (ash -1 sb!vm:word-bits))
+	 (if (logbitp (1- sb!vm:n-word-bits) val)
+	     (logior val (ash -1 sb!vm:n-word-bits))
 	     val)))
       (#.sb!vm:unsigned-reg-sc-number
        (/show0 "case of UNSIGNED-REG-SC-NUMBER")
@@ -2206,38 +2207,38 @@
       (#.sb!vm:single-stack-sc-number
        (/show0 "case of SINGLE-STACK-SC-NUMBER")
        (sap-ref-single fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-				sb!vm:word-bytes))))
+				sb!vm:n-word-bytes))))
       (#.sb!vm:double-stack-sc-number
        (/show0 "case of DOUBLE-STACK-SC-NUMBER")
        (sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-				sb!vm:word-bytes))))
+				sb!vm:n-word-bytes))))
       #!+long-float
       (#.sb!vm:long-stack-sc-number
        (/show0 "case of LONG-STACK-SC-NUMBER")
        (sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
-			      sb!vm:word-bytes))))
+			      sb!vm:n-word-bytes))))
       (#.sb!vm:complex-single-stack-sc-number
        (/show0 "case of COMPLEX-STACK-SC-NUMBER")
        (complex
 	(sap-ref-single fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-				 sb!vm:word-bytes)))
+				 sb!vm:n-word-bytes)))
 	(sap-ref-single fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-				 sb!vm:word-bytes)))))
+				 sb!vm:n-word-bytes)))))
       (#.sb!vm:complex-double-stack-sc-number
        (/show0 "case of COMPLEX-DOUBLE-STACK-SC-NUMBER")
        (complex
 	(sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-				 sb!vm:word-bytes)))
+				 sb!vm:n-word-bytes)))
 	(sap-ref-double fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 4)
-				 sb!vm:word-bytes)))))
+				 sb!vm:n-word-bytes)))))
       #!+long-float
       (#.sb!vm:complex-long-stack-sc-number
        (/show0 "case of COMPLEX-LONG-STACK-SC-NUMBER")
        (complex
 	(sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
-			       sb!vm:word-bytes)))
+			       sb!vm:n-word-bytes)))
 	(sap-ref-long fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 6)
-			       sb!vm:word-bytes)))))
+			       sb!vm:n-word-bytes)))))
       (#.sb!vm:control-stack-sc-number
        (/show0 "case of CONTROL-STACK-SC-NUMBER")
        (stack-ref fp (sb!c:sc-offset-offset sc-offset)))
@@ -2245,19 +2246,19 @@
        (/show0 "case of BASE-CHAR-STACK-SC-NUMBER")
        (code-char
 	(sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-			     sb!vm:word-bytes)))))
+			     sb!vm:n-word-bytes)))))
       (#.sb!vm:unsigned-stack-sc-number
        (/show0 "case of UNSIGNED-STACK-SC-NUMBER")
        (sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-			    sb!vm:word-bytes))))
+			    sb!vm:n-word-bytes))))
       (#.sb!vm:signed-stack-sc-number
        (/show0 "case of SIGNED-STACK-SC-NUMBER")
        (signed-sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-				   sb!vm:word-bytes))))
+				   sb!vm:n-word-bytes))))
       (#.sb!vm:sap-stack-sc-number
        (/show0 "case of SAP-STACK-SC-NUMBER")
        (sap-ref-sap fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-			     sb!vm:word-bytes)))))))
+			     sb!vm:n-word-bytes)))))))
 
 ;;; This stores value as the value of DEBUG-VAR in FRAME. In the
 ;;; COMPILED-DEBUG-VAR case, access the current value to determine if
@@ -2311,13 +2312,13 @@
 							 sb!vm::nfp-offset))
 				#!-alpha
 				(sap-ref-sap fp
-					     (* sb!vm::nfp-save-offset
-						sb!vm:word-bytes))
+					     (* nfp-save-offset
+						sb!vm:n-word-bytes))
 				#!+alpha
 				(sb!vm::make-number-stack-pointer
 				 (sap-ref-32 fp
-					     (* sb!vm::nfp-save-offset
-						sb!vm:word-bytes))))))
+					     (* nfp-save-offset
+						sb!vm:n-word-bytes))))))
 		  ,@body)))
     (ecase (sb!c:sc-offset-scn sc-offset)
       ((#.sb!vm:any-reg-sc-number
@@ -2331,7 +2332,7 @@
       (#.sb!vm:sap-reg-sc-number
        (set-escaped-value (sap-int value)))
       (#.sb!vm:signed-reg-sc-number
-       (set-escaped-value (logand value (1- (ash 1 sb!vm:word-bits)))))
+       (set-escaped-value (logand value (1- (ash 1 sb!vm:n-word-bits)))))
       (#.sb!vm:unsigned-reg-sc-number
        (set-escaped-value value))
       (#.sb!vm:non-descriptor-reg-sc-number
@@ -2382,68 +2383,68 @@
       (#.sb!vm:single-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-single nfp (* (sb!c:sc-offset-offset sc-offset)
-				      sb!vm:word-bytes))
+				      sb!vm:n-word-bytes))
 	       (the single-float value))))
       (#.sb!vm:double-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-double nfp (* (sb!c:sc-offset-offset sc-offset)
-				      sb!vm:word-bytes))
+				      sb!vm:n-word-bytes))
 	       (the double-float value))))
       #!+long-float
       (#.sb!vm:long-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-long nfp (* (sb!c:sc-offset-offset sc-offset)
-				    sb!vm:word-bytes))
+				    sb!vm:n-word-bytes))
 	       (the long-float value))))
       (#.sb!vm:complex-single-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-single
-		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
 	       (the single-float (realpart value)))
 	 (setf (sap-ref-single
 		nfp (* (1+ (sb!c:sc-offset-offset sc-offset))
-		       sb!vm:word-bytes))
+		       sb!vm:n-word-bytes))
 	       (the single-float (realpart value)))))
       (#.sb!vm:complex-double-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-double
-		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
 	       (the double-float (realpart value)))
 	 (setf (sap-ref-double
 		nfp (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-		       sb!vm:word-bytes))
+		       sb!vm:n-word-bytes))
 	       (the double-float (realpart value)))))
       #!+long-float
       (#.sb!vm:complex-long-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-long
-		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:word-bytes))
+		nfp (* (sb!c:sc-offset-offset sc-offset) sb!vm:n-word-bytes))
 	       (the long-float (realpart value)))
 	 (setf (sap-ref-long
 		nfp (* (+ (sb!c:sc-offset-offset sc-offset) #!+sparc 4)
-		       sb!vm:word-bytes))
+		       sb!vm:n-word-bytes))
 	       (the long-float (realpart value)))))
       (#.sb!vm:control-stack-sc-number
        (setf (stack-ref fp (sb!c:sc-offset-offset sc-offset)) value))
       (#.sb!vm:base-char-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-					 sb!vm:word-bytes))
+					 sb!vm:n-word-bytes))
 	       (char-code (the character value)))))
       (#.sb!vm:unsigned-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-				  sb!vm:word-bytes))
+				  sb!vm:n-word-bytes))
 	       (the (unsigned-byte 32) value))))
       (#.sb!vm:signed-stack-sc-number
        (with-nfp (nfp)
 	 (setf (signed-sap-ref-32 nfp (* (sb!c:sc-offset-offset sc-offset)
-					 sb!vm:word-bytes))
+					 sb!vm:n-word-bytes))
 	       (the (signed-byte 32) value))))
       (#.sb!vm:sap-stack-sc-number
        (with-nfp (nfp)
 	 (setf (sap-ref-sap nfp (* (sb!c:sc-offset-offset sc-offset)
-				   sb!vm:word-bytes))
+				   sb!vm:n-word-bytes))
 	       (the system-area-pointer value)))))))
 
 #!+x86
@@ -2465,7 +2466,7 @@
       (#.sb!vm:sap-reg-sc-number
        (set-escaped-value (sap-int value)))
       (#.sb!vm:signed-reg-sc-number
-       (set-escaped-value (logand value (1- (ash 1 sb!vm:word-bits)))))
+       (set-escaped-value (logand value (1- (ash 1 sb!vm:n-word-bits)))))
       (#.sb!vm:unsigned-reg-sc-number
        (set-escaped-value value))
       (#.sb!vm:single-reg-sc-number
@@ -2481,72 +2482,73 @@
       (#.sb!vm:single-stack-sc-number
        (setf (sap-ref-single
 	      fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (the single-float value)))
       (#.sb!vm:double-stack-sc-number
        (setf (sap-ref-double
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (the double-float value)))
       #!+long-float
       (#.sb!vm:long-stack-sc-number
        (setf (sap-ref-long
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (the long-float value)))
       (#.sb!vm:complex-single-stack-sc-number
        (setf (sap-ref-single
 	      fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (realpart (the (complex single-float) value)))
        (setf (sap-ref-single
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (imagpart (the (complex single-float) value))))
       (#.sb!vm:complex-double-stack-sc-number
        (setf (sap-ref-double
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 2)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (realpart (the (complex double-float) value)))
        (setf (sap-ref-double
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 4)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (imagpart (the (complex double-float) value))))
       #!+long-float
       (#.sb!vm:complex-long-stack-sc-number
        (setf (sap-ref-long
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 3)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (realpart (the (complex long-float) value)))
        (setf (sap-ref-long
 	      fp (- (* (+ (sb!c:sc-offset-offset sc-offset) 6)
-		       sb!vm:word-bytes)))
+		       sb!vm:n-word-bytes)))
 	     (imagpart (the (complex long-float) value))))
       (#.sb!vm:control-stack-sc-number
        (setf (stack-ref fp (sb!c:sc-offset-offset sc-offset)) value))
       (#.sb!vm:base-char-stack-sc-number
        (setf (sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-					 sb!vm:word-bytes)))
+					 sb!vm:n-word-bytes)))
 	     (char-code (the character value))))
       (#.sb!vm:unsigned-stack-sc-number
        (setf (sap-ref-32 fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-					 sb!vm:word-bytes)))
+					 sb!vm:n-word-bytes)))
 	     (the (unsigned-byte 32) value)))
       (#.sb!vm:signed-stack-sc-number
        (setf (signed-sap-ref-32
-	      fp (- (* (1+ (sb!c:sc-offset-offset sc-offset)) sb!vm:word-bytes)))
+	      fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
+		       sb!vm:n-word-bytes)))
 	     (the (signed-byte 32) value)))
       (#.sb!vm:sap-stack-sc-number
        (setf (sap-ref-sap fp (- (* (1+ (sb!c:sc-offset-offset sc-offset))
-					  sb!vm:word-bytes)))
+					  sb!vm:n-word-bytes)))
 	     (the system-area-pointer value))))))
 
 ;;; The method for setting and accessing COMPILED-DEBUG-VAR values use
 ;;; this to determine if the value stored is the actual value or an
 ;;; indirection cell.
 (defun indirect-value-cell-p (x)
-  (and (= (get-lowtag x) sb!vm:other-pointer-type)
-       (= (get-type x) sb!vm:value-cell-header-type)))
+  (and (= (lowtag-of x) sb!vm:other-pointer-lowtag)
+       (= (widetag-of x) sb!vm:value-cell-header-widetag)))
 
 ;;; Return three values reflecting the validity of DEBUG-VAR's value
 ;;; at BASIC-CODE-LOCATION:
@@ -2702,7 +2704,7 @@
 ;;; The returned function takes the frame to get values from as its
 ;;; argument, and it returns the values of FORM. The returned function
 ;;; can signal the following conditions: INVALID-VALUE,
-;;; AMBIGUOUS-VARIABLE-NAME, and FRAME-FUN-MISMATCH.
+;;; AMBIGUOUS-VAR-NAME, and FRAME-FUN-MISMATCH.
 (defun preprocess-for-eval (form loc)
   (declare (type code-location loc))
   (let ((n-frame (gensym))
@@ -2726,10 +2728,12 @@
 	    (:valid
 	     (specs `(,name (debug-var-value ',var ,n-frame))))
 	    (:unknown
-	     (specs `(,name (debug-signal 'invalid-value :debug-var ',var
+	     (specs `(,name (debug-signal 'invalid-value
+					  :debug-var ',var
 					  :frame ,n-frame))))
 	    (:ambiguous
-	     (specs `(,name (debug-signal 'ambiguous-variable-name :name ',name
+	     (specs `(,name (debug-signal 'ambiguous-var-name
+					  :name ',name
 					  :frame ,n-frame)))))))
       (let ((res (coerce `(lambda (,n-frame)
 			    (declare (ignorable ,n-frame))
@@ -2863,10 +2867,10 @@
 	(multiple-value-bind (lra component offset)
 	    (make-bogus-lra
 	     (get-context-value frame
-				sb!vm::lra-save-offset
+				lra-save-offset
 				lra-sc-offset))
 	  (setf (get-context-value frame
-				   sb!vm::lra-save-offset
+				   lra-save-offset
 				   lra-sc-offset)
 		lra)
 	  (let ((end-bpts (breakpoint-%info starter-bpt)))
@@ -2898,10 +2902,9 @@
     (do ((frame frame (frame-down frame)))
 	((not frame) nil)
       (when (and (compiled-frame-p frame)
-		 (eq lra
-		     (get-context-value frame
-					sb!vm::lra-save-offset
-					lra-sc-offset)))
+                 (#-x86 eq #+x86 sap=
+		  lra
+		  (get-context-value frame lra-save-offset lra-sc-offset)))
 	(return t)))))
 
 ;;;; ACTIVATE-BREAKPOINT
@@ -3223,7 +3226,7 @@
 	 (frame (do ((cfp (sb!vm:context-register scp sb!vm::cfp-offset))
 		     (f (top-frame) (frame-down f)))
 		    ((= cfp (sap-int (frame-pointer f))) f)
-		  (declare (type (unsigned-byte #.sb!vm:word-bits) cfp))))
+		  (declare (type (unsigned-byte #.sb!vm:n-word-bits) cfp))))
 	 (component (breakpoint-data-component data))
 	 (cookie (gethash component *fun-end-cookies*)))
     (remhash component *fun-end-cookies*)
@@ -3290,13 +3293,13 @@
        (setf (code-header-ref code-object (1+ real-lra-slot)) offset))
      (setf (code-header-ref code-object known-return-p-slot)
 	   known-return-p)
-     (system-area-copy src-start 0 dst-start 0 (* length sb!vm:byte-bits))
+     (system-area-copy src-start 0 dst-start 0 (* length sb!vm:n-byte-bits))
      (sb!vm:sanctify-for-execution code-object)
      #!+x86
      (values dst-start code-object (sap- trap-loc src-start))
      #!-x86
      (let ((new-lra (make-lisp-obj (+ (sap-int dst-start)
-				      sb!vm:other-pointer-type))))
+				      sb!vm:other-pointer-lowtag))))
        (set-header-data
 	new-lra
 	(logandc2 (+ sb!vm:code-constants-offset bogus-lra-constants 1)