anchor.diff:             (let ((memset-fun ',%memset-name))
                `(,memset-fun ,ptr ,index ,n-words ,fill-word ,scale ,offset)))))))
   
  +
  +
   (define-fast-memset :memset-name fast-memset/4 :type (unsigned-byte 32) :size :dword)
   
   #+x86-64
  
positive.code:            (:translate ,%memset-name)
             (:args (sap       :scs (sb-vm::sap-reg))
                    (index     :scs (sb-vm::any-reg))
                    (n-words   :scs (sb-vm::unsigned-reg) :target rcx)
                    (fill-word :scs (sb-vm::unsigned-reg) :target rax))
             (:info scale offset)
             (:arg-types sb-sys:system-area-pointer sb-vm::tagged-num
                         sb-vm::unsigned-num
                         sb-vm::unsigned-num
                         (:constant x86-fixnum-scale)
                         (:constant (signed-byte 32)))
             (:temporary (:sc sb-vm::unsigned-reg :offset sb-vm::rax-offset) rax)
             (:temporary (:sc sb-vm::unsigned-reg :offset sb-vm::rcx-offset) rcx)
             (:temporary (:sc sb-vm::sap-reg      :offset sb-vm::rdi-offset) rdi)
             (:generator
              20
              (sb-assem:inst lea rdi
                             (sb-vm::make-ea #+x86 :dword #-x86 :qword
                                             :base sap :index index
                                             :scale (ash (the fixnum scale)
                                                         (- +n-fixnum-tag-bits+))
                                             :disp offset))
              (sb-c::move rcx n-words)
              (sb-c::move rax fill-word)
              ;; (sb-assem:inst std) ; not needed
              (sb-assem:inst rep)
              (sb-assem:inst stos
                             #+x86 rax
                             #-x86 (sb-vm::reg-in-size rax ,size)))))
                
         (eval-always
           (defmacro ,memset-name (ptr index n-words fill-word
  
negative.code:                        (:constant (signed-byte 32))
                         (:constant x86-fixnum-scale)
                         (:constant (signed-byte 32)))
  
             #-x86 (:temporary (:sc sb-vm::unsigned-reg :offset sb-vm::rcx-offset) rcx)
             #-x86 (:temporary (:sc sb-vm::sap-reg      :offset sb-vm::rsi-offset) rsi)
             #-x86 (:temporary (:sc sb-vm::sap-reg      :offset sb-vm::rdi-offset) rdi)
  
             ;; x86 is register starved... save ECX, ESI and EDI on the stack before using them
             (:generator 20
              (let #+x86 ((rcx sb-vm::ecx-tn)
                          (rsi sb-vm::esi-tn)
                          (rdi sb-vm::edi-tn))
                #+x86
                (progn
                  (unless (sb-vm::location= n-words rcx)
                    (sb-assem:inst push rcx))
                  (sb-assem:inst push rsi)
                  (sb-assem:inst push rdi)
                  (check-location-not-member dst       rsi)
                  (check-location-not-member dst-index rsi)
                  (check-location-not-member n-words   rsi rdi))
  
                (sb-assem:inst lea rsi
                               (sb-vm::make-ea #+x86 :dword #-x86 :qword
                                               :base src :index src-index
                                               :scale (ash (the fixnum src-scale)
                                                           (- +n-fixnum-tag-bits+))
                                               :disp src-offset))
                (sb-assem:inst lea rdi
                               (sb-vm::make-ea #+x86 :dword #-x86 :qword
                                               :base dst :index dst-index
                                               :scale (ash (the fixnum dst-scale)
                                                           (- +n-fixnum-tag-bits+))
                                               :disp dst-offset))
                (sb-c::move rcx n-words)
                ;; (sb-assem:inst std) ; not needed
                (sb-assem:inst rep)
                (sb-assem:inst movs ,size)
  
                #+x86
                (progn
                  (sb-assem:inst pop rdi)
                  (sb-assem:inst pop rsi)
                  (unless (sb-vm::location= n-words rcx)
                    (sb-assem:inst pop rcx)))))))
                
         (eval-always
           (defmacro ,memcpy-name (dst dst-index src src-index n-words
  