[Sbcl-commits] CVS: sbcl/src/compiler/x86-64 alloc.lisp, 1.11, 1.12 arith.lisp, 1.19, 1.20 call.lisp, 1.11, 1.12 cell.lisp, 1.16, 1.17 move.lisp, 1.7, 1.8 subprim.lisp, 1.2, 1.3

[Nathan F. <nf...@us...>]

Update of /cvsroot/sbcl/sbcl/src/compiler/x86-64
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv5287/src/compiler/x86-64

Modified Files:
	alloc.lisp arith.lisp call.lisp cell.lisp move.lisp 
	subprim.lisp 
Log Message:
0.9.18.52:
	If possible, use a shorter XOR instruction on x86-64 when we zero
	  a register.


Index: alloc.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/alloc.lisp,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- alloc.lisp	6 Oct 2006 10:54:16 -0000	1.11
+++ alloc.lisp	14 Nov 2006 22:15:21 -0000	1.12
@@ -124,7 +124,7 @@
     (inst lea result (make-ea :byte :base result :disp other-pointer-lowtag))
     (storew type result 0 other-pointer-lowtag)
     (storew length result vector-length-slot other-pointer-lowtag)
-    (inst xor zero zero)
+    (zeroize zero)
     (inst rep)
     (inst stos zero)))
 

Index: arith.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/arith.lisp,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- arith.lisp	28 Jul 2006 01:08:41 -0000	1.19
+++ arith.lisp	14 Nov 2006 22:15:21 -0000	1.20
@@ -694,7 +694,7 @@
                       (inst shl result amount)
                       (inst shr result (- amount))))
                  (t (if (sc-is result unsigned-reg)
-                        (inst xor result result)
+                        (zeroize result)
                         (inst mov result 0))))))))
 
 (define-vop (fast-ash-left/signed=>signed)
@@ -786,7 +786,7 @@
     (inst neg ecx)
     (inst cmp ecx 63)
     (inst jmp :be OKAY)
-    (inst xor result result)
+    (zeroize result)
     (inst jmp DONE)
     OKAY
     (inst shr result :cl)
@@ -896,7 +896,7 @@
     (inst or ecx ecx)
     (inst jmp :ns POSITIVE)
     (inst neg ecx)
-    (inst xor zero zero)
+    (zeroize zero)
     (inst shr result :cl)
     (inst cmp ecx 63)
     (inst cmov :nbe result zero)
@@ -927,7 +927,7 @@
     (inst inc res)
     (inst jmp DONE)
     ZERO
-    (inst xor res res)
+    (zeroize res)
     DONE))
 
 (define-vop (unsigned-byte-64-len)
@@ -944,7 +944,7 @@
     (inst inc res)
     (inst jmp DONE)
     ZERO
-    (inst xor res res)
+    (zeroize res)
     DONE))
 
 (define-vop (unsigned-byte-64-count)

Index: call.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/call.lisp,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- call.lisp	13 Nov 2006 06:10:16 -0000	1.11
+++ call.lisp	14 Nov 2006 22:15:22 -0000	1.12
@@ -797,7 +797,7 @@
                                do (noise `(loadw ,name new-fp ,index)))
                               (noise))
                    '((if (zerop nargs)
-                         (inst xor rcx rcx)
+                         (zeroize rcx)
                        (inst mov rcx (fixnumize nargs)))))
                ,@(cond ((eq return :tail)
                         '(;; Python has figured out what frame we should
@@ -1032,7 +1032,7 @@
     ;; Establish the values pointer and values count.
     (move rbx rbp-tn)
     (if (zerop nvals)
-        (inst xor rcx rcx) ; smaller
+        (zeroize rcx) ; smaller
       (inst mov rcx (fixnumize nvals)))
     ;; Restore the frame pointer.
     (move rbp-tn old-fp)
@@ -1194,7 +1194,7 @@
     ;; We need to copy from downwards up to avoid overwriting some of
     ;; the yet uncopied args. So we need to use R9 as the copy index
     ;; and RCX as the loop counter, rather than using RCX for both.
-    (inst xor copy-index copy-index)
+    (zeroize copy-index)
 
     ;; We used to use REP MOVS here, but on modern x86 it performs
     ;; much worse than an explicit loop for small blocks.

Index: cell.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/cell.lisp,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -d -r1.16 -r1.17
--- cell.lisp	19 Oct 2006 02:06:12 -0000	1.16
+++ cell.lisp	14 Nov 2006 22:15:22 -0000	1.17
@@ -289,7 +289,7 @@
       (pseudo-atomic
        (emit-label get-tls-index-lock)
        (inst mov temp 1)
-       (inst xor rax rax)
+       (zeroize rax)
        (inst lock)
        (inst cmpxchg (make-ea-for-symbol-value *tls-index-lock*) temp)
        (inst jmp :ne get-tls-index-lock)

Index: move.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/move.lisp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- move.lisp	20 Jul 2006 17:45:53 -0000	1.7
+++ move.lisp	14 Nov 2006 22:15:24 -0000	1.8
@@ -11,6 +11,17 @@
 
 (in-package "SB!VM")
 
+(defun zeroize (tn)
+  (let ((offset (tn-offset tn)))
+    ;; Using the 32-bit instruction accomplishes the same thing and is
+    ;; one byte shorter.
+    (if (<= offset edi-offset)
+        (let ((tn (make-random-tn :kind :normal
+                                  :sc (sc-or-lose 'dword-reg)
+                                  :offset offset)))
+          (inst xor tn tn))
+        (inst xor tn tn))))
+
 (define-move-fun (load-immediate 1) (vop x y)
   ((immediate)
    (any-reg descriptor-reg))
@@ -18,7 +29,7 @@
     (etypecase val
       (integer
        (if (zerop val)
-           (inst xor y y)
+           (zeroize y)
          (inst mov y (fixnumize val))))
       (symbol
        (load-symbol y val))
@@ -30,7 +41,7 @@
   ((immediate) (signed-reg unsigned-reg))
   (let ((val (tn-value x)))
     (if (zerop val)
-        (inst xor y y)
+        (zeroize y)
         (inst mov y val))))
 
 (define-move-fun (load-character 1) (vop x y)
@@ -80,7 +91,7 @@
           (etypecase val
             (integer
              (if (and (zerop val) (sc-is y any-reg descriptor-reg))
-                 (inst xor y y)
+                 (zeroize y)
                  (move-immediate y (fixnumize val) temp)))
             (symbol
              (inst mov y (+ nil-value (static-symbol-offset val))))
@@ -134,7 +145,7 @@
            (let ((val (tn-value x)))
              (etypecase val
                ((integer 0 0)
-                (inst xor y y))
+                (zeroize y))
                ((or (signed-byte 29) (unsigned-byte 29))
                 (inst mov y (fixnumize val)))
                (integer

Index: subprim.lisp
===================================================================
RCS file: /cvsroot/sbcl/sbcl/src/compiler/x86-64/subprim.lisp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- subprim.lisp	29 Apr 2005 14:37:40 -0000	1.2
+++ subprim.lisp	14 Nov 2006 22:15:24 -0000	1.3
@@ -28,7 +28,7 @@
   (:generator 40
     ;; Move OBJECT into a temp we can bash on, and initialize the count.
     (move ptr object)
-    (inst xor count count)
+    (zeroize count)
     ;; If we are starting with NIL, then it's really easy.
     (inst cmp ptr nil-value)
     (inst jmp :e DONE)
@@ -66,7 +66,7 @@
     ;; Get a copy of OBJECT in a register we can bash on, and
     ;; initialize COUNT.
     (move ptr object)
-    (inst xor count count)
+    (zeroize count)
     ;; If we are starting with NIL, we be done.
     (inst cmp ptr nil-value)
     (inst jmp :e DONE)