gencgc: More precise conservatism for pointers to boxed pages.

[sbcl.git] / src / compiler / x86-64 / char.lisp

diff --git a/src/compiler/x86-64/char.lisp b/src/compiler/x86-64/char.lisp
index f7ef502..b70458c 100644 (file)
--- a/src/compiler/x86-64/char.lisp
+++ b/src/compiler/x86-64/char.lisp
@@ -110,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))
 
@@ -174,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))