1.0.12.18: faster member-type operations
[sbcl.git] / src / compiler / x86-64 / call.lisp
index da925b3..bd61005 100644 (file)
           (count-okay (gen-label)))
       (note-this-location vop :unknown-return)
       ;; Branch off to the MV case.
-      (inst nop)
-      (inst jmp-short regs-defaulted)
+      (inst jmp :c regs-defaulted)
 
       ;; Default the register args, and set up the stack as if we
       ;; entered the MV return point.
                                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
     ;; 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)
     ;; 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.
       ;; Check to see whether there are no args, and just return NIL if so.
       (inst mov result nil-value)
       (inst jecxz done)
-      (inst lea dst (make-ea :qword :index rcx :scale 2))
+      (inst lea dst (make-ea :qword :base rcx :index rcx))
       (maybe-pseudo-atomic stack-allocate-p
        (allocation dst dst node stack-allocate-p)
        (inst lea dst (make-ea :byte :base dst :disp list-pointer-lowtag))