[Sbcl-commits] CVS: sbcl/src/compiler/alpha subprim.lisp,1.4,1.5 system.lisp,1.11,1.12 type-vops.lisp,1.13,1.14 values.lisp,1.8,1.9 vm.lisp,1.12,1.13

[William H. N. <wn...@us...>]

Update of /cvsroot/sbcl/sbcl/src/compiler/alpha
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv10506/src/compiler/alpha

Modified Files:
	subprim.lisp system.lisp type-vops.lisp values.lisp vm.lisp 
Log Message:
0.9.2.44:
	another slice of whitespace canonicalization
	(Anyone who ends up here with "cvs annotate" probably
		wants to look at the "tabby" tagged version.)


Index: subprim.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/alpha/subprim.lisp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- subprim.lisp	1 Nov 2001 21:53:28 -0000	1.4
+++ subprim.lisp	14 Jul 2005 18:35:33 -0000	1.5
@@ -20,7 +20,7 @@
   (:temporary (:scs (descriptor-reg) :from (:argument 0)) ptr)
   (:temporary (:scs (non-descriptor-reg)) temp)
   (:temporary (:scs (any-reg) :type fixnum :to (:result 0) :target result)
-	      count)
+              count)
   (:results (result :scs (any-reg descriptor-reg)))
   (:policy :fast-safe)
   (:vop-var vop)
@@ -28,24 +28,24 @@
   (:generator 50
     (move object ptr)
     (move zero-tn count)
-    
+
     LOOP
-    
+
     (inst cmpeq ptr null-tn temp)
     (inst bne temp done)
-    
+
     (inst and ptr lowtag-mask temp)
     (inst xor temp list-pointer-lowtag temp)
     (inst bne temp not-list)
-    
+
     (loadw ptr ptr cons-cdr-slot list-pointer-lowtag)
     (inst addq count (fixnumize 1) count)
     (inst br zero-tn loop)
-    
+
     NOT-LIST
     (cerror-call vop done object-not-list-error ptr)
-    
+
     DONE
     (move count result)))
-       
+
 (define-static-fun length (object) :translate length)

Index: system.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/alpha/system.lisp,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- system.lisp	3 Aug 2004 17:28:48 -0000	1.11
+++ system.lisp	14 Jul 2005 18:35:34 -0000	1.12
@@ -54,7 +54,7 @@
 
     OTHER-PTR
     (load-type result object (- other-pointer-lowtag))
-      
+
     DONE))
 
 (define-vop (fun-subtype)
@@ -70,7 +70,7 @@
   (:translate (setf fun-subtype))
   (:policy :fast-safe)
   (:args (type :scs (unsigned-reg) :target result)
-	 (function :scs (descriptor-reg)))
+         (function :scs (descriptor-reg)))
   (:arg-types positive-fixnum *)
   (:temporary (:scs (non-descriptor-reg)) temp)
   (:results (result :scs (unsigned-reg)))
@@ -107,7 +107,7 @@
   (:translate set-header-data)
   (:policy :fast-safe)
   (:args (x :scs (descriptor-reg) :target res)
-	 (data :scs (any-reg immediate zero)))
+         (data :scs (any-reg immediate zero)))
   (:arg-types * positive-fixnum)
   (:results (res :scs (descriptor-reg)))
   (:temporary (:scs (non-descriptor-reg)) t1 t2)
@@ -120,11 +120,11 @@
        (inst bis t1 t2 t1))
       (immediate
        (let ((c (ash (tn-value data) n-widetag-bits)))
-	 (cond ((<= 0 c (1- (ash 1 8)))
-		(inst bis t1 c t1))
-	       (t
-		(inst li c t2)
-		(inst bis t1 t2 t1)))))
+         (cond ((<= 0 c (1- (ash 1 8)))
+                (inst bis t1 c t1))
+               (t
+                (inst li c t2)
+                (inst bis t1 t2 t1)))))
       (zero))
     (storew t1 x 0 other-pointer-lowtag)
     (move x res)))
@@ -141,8 +141,8 @@
 
 (define-vop (make-other-immediate-type)
   (:args (val :scs (any-reg descriptor-reg))
-	 (type :scs (any-reg descriptor-reg immediate)
-	       :target temp))
+         (type :scs (any-reg descriptor-reg immediate)
+               :target temp))
   (:results (res :scs (any-reg descriptor-reg)))
   (:temporary (:scs (non-descriptor-reg)) temp)
   (:generator 2
@@ -201,7 +201,7 @@
 
 (define-vop (compute-fun)
   (:args (code :scs (descriptor-reg))
-	 (offset :scs (signed-reg unsigned-reg)))
+         (offset :scs (signed-reg unsigned-reg)))
   (:arg-types * positive-fixnum)
   (:results (func :scs (descriptor-reg)))
   (:temporary (:scs (non-descriptor-reg)) ndescr)
@@ -239,8 +239,8 @@
   (:temporary (:scs (non-descriptor-reg)) count)
   (:generator 1
     (let ((offset
-	   (- (* (+ index vector-data-offset) n-word-bytes)
-	      other-pointer-lowtag)))
+           (- (* (+ index vector-data-offset) n-word-bytes)
+              other-pointer-lowtag)))
       (inst ldl count offset count-vector)
       (inst addq count 1 count)
       (inst stl count offset count-vector))))

Index: type-vops.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/alpha/type-vops.lisp,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- type-vops.lisp	3 Aug 2004 17:28:48 -0000	1.13
+++ type-vops.lisp	14 Jul 2005 18:35:34 -0000	1.14
@@ -24,66 +24,66 @@
       (inst and value fixnum-tag-mask temp)
       (inst beq temp (if not-p drop-through target)))
     (%test-headers value target not-p nil headers
-		   :drop-through drop-through :temp temp)))
+                   :drop-through drop-through :temp temp)))
 
 (defun %test-immediate (value target not-p immediate &key temp)
   (assemble ()
     (inst and value 255 temp)
     (inst xor temp immediate temp)
     (if not-p
-	(inst bne temp target)
-	(inst beq temp target))))
+        (inst bne temp target)
+        (inst beq temp target))))
 
 (defun %test-lowtag (value target not-p lowtag &key temp)
   (assemble ()
     (inst and value lowtag-mask temp)
     (inst xor temp lowtag temp)
     (if not-p
-	(inst bne temp target)
-	(inst beq temp target))))
+        (inst bne temp target)
+        (inst beq temp target))))
 
 (defun %test-headers (value target not-p function-p headers
-		      &key (drop-through (gen-label)) temp)
+                      &key (drop-through (gen-label)) temp)
   (let ((lowtag (if function-p fun-pointer-lowtag other-pointer-lowtag)))
     (multiple-value-bind
-	(when-true when-false)
-	;; WHEN-TRUE and WHEN-FALSE are the labels to branch to when
-	;; we know it's true and when we know it's false respectively.
-	(if not-p
-	    (values drop-through target)
-	    (values target drop-through))
+        (when-true when-false)
+        ;; WHEN-TRUE and WHEN-FALSE are the labels to branch to when
+        ;; we know it's true and when we know it's false respectively.
+        (if not-p
+            (values drop-through target)
+            (values target drop-through))
       (assemble ()
-	(%test-lowtag value when-false t lowtag :temp temp)
-	(load-type temp value (- lowtag))
-	(let ((delta 0))
-	  (do ((remaining headers (cdr remaining)))
-	      ((null remaining))
-	    (let ((header (car remaining))
-		  (last (null (cdr remaining))))
-	      (cond
-	       ((atom header)
-		(inst subq temp (- header delta) temp)
-		(setf delta header)
-		(if last
-		    (if not-p
-			(inst bne temp target)
-			(inst beq temp target))
-		    (inst beq temp when-true)))
-	       (t
-		(let ((start (car header))
-		      (end (cdr header)))
-		  (unless (= start bignum-widetag)
-		    (inst subq temp (- start delta) temp)
-		    (setf delta start)
-		    (inst blt temp when-false))
-		  (inst subq temp (- end delta) temp)
-		  (setf delta end)
-		  (if last
-		      (if not-p
-			  (inst bgt temp target)
-			  (inst ble temp target))
-		      (inst ble temp when-true))))))))
-	(emit-label drop-through)))))
+        (%test-lowtag value when-false t lowtag :temp temp)
+        (load-type temp value (- lowtag))
+        (let ((delta 0))
+          (do ((remaining headers (cdr remaining)))
+              ((null remaining))
+            (let ((header (car remaining))
+                  (last (null (cdr remaining))))
+              (cond
+               ((atom header)
+                (inst subq temp (- header delta) temp)
+                (setf delta header)
+                (if last
+                    (if not-p
+                        (inst bne temp target)
+                        (inst beq temp target))
+                    (inst beq temp when-true)))
+               (t
+                (let ((start (car header))
+                      (end (cdr header)))
+                  (unless (= start bignum-widetag)
+                    (inst subq temp (- start delta) temp)
+                    (setf delta start)
+                    (inst blt temp when-false))
+                  (inst subq temp (- end delta) temp)
+                  (setf delta end)
+                  (if last
+                      (if not-p
+                          (inst bgt temp target)
+                          (inst ble temp target))
+                      (inst ble temp when-true))))))))
+        (emit-label drop-through)))))
 
 ;;;; Type checking and testing:
 
@@ -106,24 +106,24 @@
      (if (> (apply #'max type-codes) lowtag-limit) 7 2)))
 
 (defmacro !define-type-vops (pred-name check-name ptype error-code
-			     (&rest type-codes)
-			     &key &allow-other-keys)
+                             (&rest type-codes)
+                             &key &allow-other-keys)
   (let ((cost (cost-to-test-types (mapcar #'eval type-codes))))
     `(progn
        ,@(when pred-name
-	   `((define-vop (,pred-name type-predicate)
-	       (:translate ,pred-name)
-	       (:generator ,cost
-		 (test-type value target not-p (,@type-codes) :temp temp)))))
+           `((define-vop (,pred-name type-predicate)
+               (:translate ,pred-name)
+               (:generator ,cost
+                 (test-type value target not-p (,@type-codes) :temp temp)))))
        ,@(when check-name
-	   `((define-vop (,check-name check-type)
-	       (:generator ,cost
-		 (let ((err-lab
-			(generate-error-code vop ,error-code value)))
-		   (test-type value err-lab t (,@type-codes) :temp temp)
-		   (move value result))))))
+           `((define-vop (,check-name check-type)
+               (:generator ,cost
+                 (let ((err-lab
+                        (generate-error-code vop ,error-code value)))
+                   (test-type value err-lab t (,@type-codes) :temp temp)
+                   (move value result))))))
        ,@(when ptype
-	   `((primitive-type-vop ,check-name (:check) ,ptype))))))
+           `((primitive-type-vop ,check-name (:check) ,ptype))))))
 
 ;;;; Other integer ranges.
 
@@ -134,8 +134,8 @@
   (multiple-value-bind
       (yep nope)
       (if not-p
-	  (values not-target target)
-	  (values target not-target))
+          (values not-target target)
+          (values target not-target))
     (assemble ()
       (inst and value fixnum-tag-mask temp)
       (inst beq temp yep)
@@ -146,8 +146,8 @@
       (inst li (+ (ash 1 n-widetag-bits) bignum-widetag) temp1)
       (inst xor temp temp1 temp)
       (if not-p
-	  (inst bne temp target)
-	  (inst beq temp target))))
+          (inst bne temp target)
+          (inst beq temp target))))
   (values))
 
 (define-vop (signed-byte-32-p type-predicate)
@@ -161,7 +161,7 @@
   (:temporary (:scs (non-descriptor-reg)) temp1)
   (:generator 45
     (let ((loose (generate-error-code vop object-not-signed-byte-32-error
-				      value)))
+                                      value)))
       (signed-byte-32-test value temp temp1 t loose okay))
     OKAY
     (move value result)))
@@ -172,9 +172,9 @@
 
 (defun unsigned-byte-32-test (value temp temp1 not-p target not-target)
   (multiple-value-bind (yep nope)
-		       (if not-p
-			   (values not-target target)
-			   (values target not-target))
+                       (if not-p
+                           (values not-target target)
+                           (values target not-target))
     (assemble ()
       ;; Is it a fixnum?
       (inst and value fixnum-tag-mask temp1)
@@ -193,8 +193,8 @@
       (inst beq temp single-word)
       ;; If it's other than two, we can't be an (unsigned-byte 32)
       (inst li (logxor (+ (ash 1 n-widetag-bits) bignum-widetag)
-		       (+ (ash 2 n-widetag-bits) bignum-widetag))
-	    temp1)
+                       (+ (ash 2 n-widetag-bits) bignum-widetag))
+            temp1)
       (inst xor temp temp1 temp)
       (inst bne temp nope)
       ;; Get the second digit.
@@ -202,7 +202,7 @@
       ;; All zeros, its an (unsigned-byte 32).
       (inst beq temp yep)
       (inst br zero-tn nope)
-	
+
       SINGLE-WORD
       ;; Get the single digit.
       (loadw temp value bignum-digits-offset other-pointer-lowtag)
@@ -210,8 +210,8 @@
       ;; positive implies (unsigned-byte 32).
       FIXNUM
       (if not-p
-	  (inst blt temp target)
-	  (inst bge temp target))))
+          (inst blt temp target)
+          (inst bge temp target))))
   (values))
 
 (define-vop (unsigned-byte-32-p type-predicate)
@@ -225,7 +225,7 @@
   (:temporary (:scs (non-descriptor-reg)) temp1)
   (:generator 45
     (let ((loose (generate-error-code vop object-not-unsigned-byte-32-error
-				      value)))
+                                      value)))
       (unsigned-byte-32-test value temp temp1 t loose okay))
     OKAY
     (move value result)))
@@ -233,7 +233,7 @@
 
 
 ;;;; List/symbol types:
-;;; 
+;;;
 ;;; symbolp (or symbol (eq nil))
 ;;; consp (and list (not (eq nil)))
 
@@ -255,7 +255,7 @@
       (test-type value error t (symbol-header-widetag) :temp temp))
     DROP-THRU
     (move value result)))
-  
+
 (define-vop (consp type-predicate)
   (:translate consp)
   (:temporary (:scs (non-descriptor-reg)) temp)

Index: values.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/alpha/values.lisp,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- values.lisp	19 Jun 2005 06:30:52 -0000	1.8
+++ values.lisp	14 Jul 2005 18:35:34 -0000	1.9
@@ -18,8 +18,8 @@
 
 (define-vop (%%nip-values)
   (:args (last-nipped-ptr :scs (any-reg) :target dest)
-	 (last-preserved-ptr :scs (any-reg) :target src)
-	 (moved-ptrs :scs (any-reg) :more t))
+         (last-preserved-ptr :scs (any-reg) :target src)
+         (moved-ptrs :scs (any-reg) :more t))
   (:results (r-moved-ptrs :scs (any-reg) :more t))
   (:temporary (:sc any-reg) src)
   (:temporary (:sc any-reg) dest)
@@ -41,14 +41,14 @@
     (inst lda csp-tn 0 dest)
     (inst subq src dest src)
     (loop for moved = moved-ptrs then (tn-ref-across moved)
-	  while moved
-	  do (sc-case (tn-ref-tn moved)
+          while moved
+          do (sc-case (tn-ref-tn moved)
                ((descriptor-reg any-reg)
-		(inst subq (tn-ref-tn moved) src (tn-ref-tn moved)))
-	       ((control-stack)
-		(load-stack-tn temp (tn-ref-tn moved))
-		(inst subq temp src temp)
-		(store-stack-tn (tn-ref-tn moved) temp))))))
+                (inst subq (tn-ref-tn moved) src (tn-ref-tn moved)))
+               ((control-stack)
+                (load-stack-tn temp (tn-ref-tn moved))
+                (inst subq temp src temp)
+                (store-stack-tn (tn-ref-tn moved) temp))))))
 
 ;;; Push some values onto the stack, returning the start and number of
 ;;; values pushed as results. It is assumed that the Vals are wired to
@@ -68,22 +68,22 @@
   (:info nvals)
   (:temporary (:scs (descriptor-reg)) temp)
   (:temporary (:scs (descriptor-reg)
-	       :to (:result 0)
-	       :target start)
-	      start-temp)
+               :to (:result 0)
+               :target start)
+              start-temp)
   (:generator 20
     (move csp-tn start-temp)
     (inst lda csp-tn (* nvals n-word-bytes) csp-tn)
     (do ((val vals (tn-ref-across val))
-	 (i 0 (1+ i)))
-	((null val))
+         (i 0 (1+ i)))
+        ((null val))
       (let ((tn (tn-ref-tn val)))
-	(sc-case tn
-	  (descriptor-reg
-	   (storew tn start-temp i))
-	  (control-stack
-	   (load-stack-tn temp tn)
-	   (storew temp start-temp i)))))
+        (sc-case tn
+          (descriptor-reg
+           (storew tn start-temp i))
+          (control-stack
+           (load-stack-tn temp tn)
+           (storew temp start-temp i)))))
     (move start-temp start)
     (inst li (fixnumize nvals) count)))
 
@@ -94,7 +94,7 @@
   (:arg-types list)
   (:policy :fast-safe)
   (:results (start :scs (any-reg))
-	    (count :scs (any-reg)))
+            (count :scs (any-reg)))
   (:temporary (:scs (descriptor-reg) :type list :from (:argument 0)) list)
   (:temporary (:scs (non-descriptor-reg)) temp)
   (:temporary (:scs (non-descriptor-reg)) ndescr)
@@ -103,7 +103,7 @@
   (:generator 0
     (move arg list)
     (move csp-tn start)
-    
+
     LOOP
     (inst cmpeq list null-tn temp)
     (inst bne temp done)
@@ -115,7 +115,7 @@
     (inst xor ndescr list-pointer-lowtag ndescr)
     (inst beq ndescr loop)
     (error-call vop bogus-arg-to-values-list-error list)
-    
+
     DONE
     (inst subq csp-tn start count)))
 

Index: vm.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/alpha/vm.lisp,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- vm.lisp	9 Apr 2005 06:37:05 -0000	1.12
+++ vm.lisp	14 Jul 2005 18:35:34 -0000	1.13
@@ -21,15 +21,15 @@
                `(eval-when (:compile-toplevel :load-toplevel :execute)
                   (def!constant ,offset-sym ,offset)
                   (setf (svref *register-names* ,offset-sym)
-			,(symbol-name name)))))
+                        ,(symbol-name name)))))
            (defregset (name &rest regs)
              `(eval-when  (:compile-toplevel :load-toplevel :execute)
                 (defparameter ,name
                   (list ,@(mapcar (lambda (name)
-				    (symbolicate name "-OFFSET"))
+                                    (symbolicate name "-OFFSET"))
                                   regs))))))
   ;; c.f. src/runtime/alpha-lispregs.h
-  
+
   ;; Ra
   (defreg lip 0)
   ;; Caller saved 0-7
@@ -73,13 +73,13 @@
   (defreg nsp 30)
   ;; Wired zero
   (defreg zero 31)
-  
+
   (defregset non-descriptor-regs
     nl0 nl1 nl2 nl3 nl4 nl5 nfp cfunc)
-  
+
   (defregset descriptor-regs
     fdefn lexenv nargs ocfp lra a0 a1 a2 a3 a4 a5 l0 l1 l2)
-  
+
   (defregset *register-arg-offsets*
     a0 a1 a2 a3 a4 a5)
   (defparameter register-arg-names '(a0 a1 a2 a3 a4 a5)))
@@ -96,22 +96,22 @@
 
 (defmacro !define-storage-classes (&rest classes)
   (do ((forms (list 'progn)
-	      (let* ((class (car classes))
-		     (sc-name (car class))
-		     (constant-name (intern (concatenate 'simple-string
-							 (string sc-name)
-							 "-SC-NUMBER"))))
-		(list* `(define-storage-class ,sc-name ,index
-			  ,@(cdr class))
-		       `(def!constant ,constant-name ,index)
-		       ;; (The CMU CL version of this macro did
-		       ;;   `(EXPORT ',CONSTANT-NAME)
-		       ;; here, but in SBCL we try to have package
-		       ;; structure described statically in one
-		       ;; master source file, instead of building it
-		       ;; dynamically by letting all the system code
-		       ;; modify it as the system boots.)
-		       forms)))
+              (let* ((class (car classes))
+                     (sc-name (car class))
+                     (constant-name (intern (concatenate 'simple-string
+                                                         (string sc-name)
+                                                         "-SC-NUMBER"))))
+                (list* `(define-storage-class ,sc-name ,index
+                          ,@(cdr class))
+                       `(def!constant ,constant-name ,index)
+                       ;; (The CMU CL version of this macro did
+                       ;;   `(EXPORT ',CONSTANT-NAME)
+                       ;; here, but in SBCL we try to have package
+                       ;; structure described statically in one
+                       ;; master source file, instead of building it
+                       ;; dynamically by letting all the system code
+                       ;; modify it as the system boots.)
+                       forms)))
        (index 0 (1+ index))
        (classes classes (cdr classes)))
       ((null classes)
@@ -141,15 +141,15 @@
 
   ;; The non-descriptor stacks.
   (signed-stack non-descriptor-stack
-		:element-size 2 :alignment 2) ; (signed-byte 64)
+                :element-size 2 :alignment 2) ; (signed-byte 64)
   (unsigned-stack non-descriptor-stack
-		  :element-size 2 :alignment 2) ; (unsigned-byte 64)
+                  :element-size 2 :alignment 2) ; (unsigned-byte 64)
   (character-stack non-descriptor-stack) ; non-descriptor characters.
   (sap-stack non-descriptor-stack
-	     :element-size 2 :alignment 2) ; System area pointers.
+             :element-size 2 :alignment 2) ; System area pointers.
   (single-stack non-descriptor-stack) ; single-floats
   (double-stack non-descriptor-stack
-		:element-size 2 :alignment 2) ; double floats.
+                :element-size 2 :alignment 2) ; double floats.
   (complex-single-stack non-descriptor-stack :element-size 2)
   (complex-double-stack non-descriptor-stack :element-size 4 :alignment 2)
 
@@ -248,8 +248,8 @@
                    (tn-sym (symbolicate name "-TN")))
                `(defparameter ,tn-sym
                   (make-random-tn :kind :normal
-		       :sc (sc-or-lose ',sc)
-		       :offset ,offset-sym)))))
+                       :sc (sc-or-lose ',sc)
+                       :offset ,offset-sym)))))
 
   ;; These, we access by foo-TN only
 
@@ -271,12 +271,12 @@
 ;; and some floating point values..
 (defparameter fp-single-zero-tn
   (make-random-tn :kind :normal
-		  :sc (sc-or-lose 'single-reg)
-		  :offset 31))
+                  :sc (sc-or-lose 'single-reg)
+                  :offset 31))
 (defparameter fp-double-zero-tn
   (make-random-tn :kind :normal
-		  :sc (sc-or-lose 'double-reg)
-		  :offset 31))
+                  :sc (sc-or-lose 'double-reg)
+                  :offset 31))
 
 ;;; If value can be represented as an immediate constant, then return
 ;;; the appropriate SC number, otherwise return NIL.
@@ -287,20 +287,20 @@
     (null
      (sc-number-or-lose 'null ))
     ((or (integer #.sb!xc:most-negative-fixnum #.sb!xc:most-positive-fixnum)
-	 system-area-pointer character)
+         system-area-pointer character)
      (sc-number-or-lose 'immediate ))
     (symbol
      (if (static-symbol-p value)
-	 (sc-number-or-lose 'immediate )
-	 nil))
+         (sc-number-or-lose 'immediate )
+         nil))
     (single-float
      (if (eql value 0f0)
-	 (sc-number-or-lose 'fp-single-zero )
-	 nil))
+         (sc-number-or-lose 'fp-single-zero )
+         nil))
     (double-float
      (if (eql value 0d0)
-	 (sc-number-or-lose 'fp-double-zero )
-	 nil))))
+         (sc-number-or-lose 'fp-double-zero )
+         nil))))
 
 ;;;; function call parameters
 
@@ -327,10 +327,10 @@
 ;;; a list of TN's describing the register arguments
 (defparameter *register-arg-tns*
   (mapcar (lambda (n)
-	    (make-random-tn :kind :normal
-			    :sc (sc-or-lose 'descriptor-reg)
-			    :offset n))
-	  *register-arg-offsets*))
+            (make-random-tn :kind :normal
+                            :sc (sc-or-lose 'descriptor-reg)
+                            :offset n))
+          *register-arg-offsets*))
 
 ;;; This is used by the debugger.
 (def!constant single-value-return-byte-offset 4)
@@ -341,10 +341,10 @@
 (!def-vm-support-routine location-print-name (tn)
 ;  (declare (type tn tn))
   (let ((sb (sb-name (sc-sb (tn-sc tn))))
-	(offset (tn-offset tn)))
+        (offset (tn-offset tn)))
     (ecase sb
       (registers (or (svref *register-names* offset)
-		     (format nil "R~D" offset)))
+                     (format nil "R~D" offset)))
       (float-registers (format nil "F~D" offset))
       (control-stack (format nil "CS~D" offset))
       (non-descriptor-stack (format nil "NS~D" offset))