X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fx86-64%2Fchar.lisp;h=b70458c3af85d118ecb681987cd1f7cf634a3bcc;hb=b83353d9f998e5c0e34604b5593df70c66d2c510;hp=68657ac6bff90a692d925d001bcadbd213f117be;hpb=0d871fd7a98fc4af92a8b942a1154761466ad8c9;p=sbcl.git

diff --git a/src/compiler/x86-64/char.lisp b/src/compiler/x86-64/char.lisp
index 68657ac..b70458c 100644
--- a/src/compiler/x86-64/char.lisp
+++ b/src/compiler/x86-64/char.lisp
@@ -1,4 +1,4 @@
-;;;; x86 definition of character operations
+;;;; x86-64 definition of character operations
 
 ;;;; This software is part of the SBCL system. See the README file for
 ;;;; more information.
@@ -11,6 +11,11 @@
 
 (in-package "SB!VM")
 
+;;; Space optimization: As the upper 32 bits of (tagged or untagged)
+;;; characters are always zero many operations can be done on 32-bit
+;;; registers. This often leads to smaller encodings as the REX prefix
+;;; is then only needed if registers R8 - R15 are used.
+
 ;;;; moves and coercions
 
 ;;; Move a tagged char to an untagged representation.
@@ -22,8 +27,14 @@
                :load-if (not (location= x y))))
   (:note "character untagging")
   (:generator 1
-    (move y x)
-    (inst shr y n-widetag-bits)))
+    (cond ((and (sc-is y character-reg) (sc-is x any-reg descriptor-reg))
+           (let ((y-dword (make-dword-tn y)))
+             (unless (location= x y)
+               (inst mov y-dword (make-dword-tn x)))
+             (inst shr y-dword n-widetag-bits)))
+          (t
+           (move y x)
+           (inst shr y n-widetag-bits)))))
 #!-sb-unicode
 (define-vop (move-to-character)
   (:args (x :scs (any-reg control-stack)))
@@ -44,12 +55,15 @@
 ;;; Move an untagged char to a tagged representation.
 #!+sb-unicode
 (define-vop (move-from-character)
-  (:args (x :scs (character-reg)))
+  (:args (x :scs (character-reg) :target y))
   (:results (y :scs (any-reg descriptor-reg)))
   (:note "character tagging")
   (:generator 1
-    (inst imul y x (ash 1 n-widetag-bits))
-    (inst or y character-widetag)))
+    (let ((y-dword (make-dword-tn y)))
+      (unless (location= x y)
+        (inst mov y-dword (make-dword-tn x)))
+      (inst shl y-dword n-widetag-bits)
+      (inst or y-dword character-widetag))))
 #!-sb-unicode
 (define-vop (move-from-character)
   (:args (x :scs (character-reg character-stack)))
@@ -96,14 +110,14 @@
       (character-stack
        #!-sb-unicode
        (inst mov
-             ;; FIXME: naked 8 (should be... what?  n-register-bytes?
-             ;; n-word-bytes?  Dunno.
-             (make-ea :byte :base fp :disp (- (* (1+ (tn-offset y)) 8)))
+             ;; XXX: If the sb-unicode case needs to handle c-call,
+             ;; why does the non-unicode case not need to?
+             (make-ea :byte :base fp :disp (frame-byte-offset (tn-offset y)))
              x)
        #!+sb-unicode
        (if (= (tn-offset fp) esp-offset)
-           (storew x fp (tn-offset y)) ; c-call
-           (storew x fp (- (1+ (tn-offset y)))))))))
+           (storew x fp (tn-offset y))  ; c-call
+           (storew x fp (frame-word-offset (tn-offset y))))))))
 (define-move-vop move-character-arg :move-arg
   (any-reg character-reg) (character-reg))
 
@@ -117,7 +131,8 @@
 (define-vop (char-code)
   (:translate char-code)
   (:policy :fast-safe)
-  (:args (ch :scs (character-reg character-stack)))
+  (:args #!-sb-unicode (ch :scs (character-reg character-stack))
+         #!+sb-unicode (ch :scs (character-reg character-stack) :target res))
   (:arg-types character)
   (:results (res :scs (unsigned-reg)))
   (:result-types positive-fixnum)
@@ -125,18 +140,18 @@
     #!-sb-unicode
     (inst movzx res ch)
     #!+sb-unicode
-    (inst mov res ch)))
+    (move res ch)))
 
 #!+sb-unicode
 (define-vop (code-char)
   (:translate code-char)
   (:policy :fast-safe)
-  (:args (code :scs (unsigned-reg unsigned-stack)))
+  (:args (code :scs (unsigned-reg unsigned-stack) :target res))
   (:arg-types positive-fixnum)
   (:results (res :scs (character-reg)))
   (:result-types character)
   (:generator 1
-    (inst mov res code)))
+    (move res code)))
 #!-sb-unicode
 (define-vop (code-char)
   (:translate code-char)
@@ -159,47 +174,41 @@
             :load-if (not (and (sc-is x character-reg)
                                (sc-is y character-stack)))))
   (:arg-types character character)
-  (:conditional)
-  (:info target not-p)
+  (:info)
   (:policy :fast-safe)
   (:note "inline comparison")
-  (:variant-vars condition not-condition)
   (:generator 3
-    (inst cmp x y)
-    (inst jmp (if not-p not-condition condition) target)))
+    (inst cmp x y)))
 
 (define-vop (fast-char=/character character-compare)
   (:translate char=)
-  (:variant :e :ne))
+  (:conditional :e))
 
 (define-vop (fast-char</character character-compare)
   (:translate char<)
-  (:variant :b :nb))
+  (:conditional :b))
 
 (define-vop (fast-char>/character character-compare)
   (:translate char>)
-  (:variant :a :na))
+  (:conditional :a))
 
 (define-vop (character-compare/c)
   (:args (x :scs (character-reg character-stack)))
   (:arg-types character (:constant character))
-  (:conditional)
-  (:info target not-p y)
+  (:info y)
   (:policy :fast-safe)
   (:note "inline constant comparison")
-  (:variant-vars condition not-condition)
   (:generator 2
-    (inst cmp x (sb!xc:char-code y))
-    (inst jmp (if not-p not-condition condition) target)))
+    (inst cmp x (sb!xc:char-code y))))
 
 (define-vop (fast-char=/character/c character-compare/c)
   (:translate char=)
-  (:variant :e :ne))
+  (:conditional :e))
 
 (define-vop (fast-char</character/c character-compare/c)
   (:translate char<)
-  (:variant :b :nb))
+  (:conditional :b))
 
 (define-vop (fast-char>/character/c character-compare/c)
   (:translate char>)
-  (:variant :a :na))
+  (:conditional :a))