|
|
title "Memory functions";++;; Copyright (c) 2000 Microsoft Corporation;; Module Name:;; movemem.asm;; Abstract:;; This module implements functions to fill, copy , and compare blocks of; memory.;; Author:;; David N. Cutler (davec) 6-Jul-2000;; Environment:;; Any mode.;;--
include ksamd64.inc
altentry RtlCopyMemoryAlternate
subttl "Compare Memory";++;; SIZE_T; RtlCompareMemory (; IN PVOID Source1,; IN PVOID Source2,; IN SIZE_T Length; );; Routine Description:;; This function compares two unaligned blocks of memory and returns the; number of bytes that compared equal.;; Arguments:;; Source1 (rcx) - Supplies a pointer to the first block of memory to; compare.;; Source2 (rdx) - Supplies a pointer to the second block of memory to; compare.;; Length (r8) - Supplies the Length, in bytes, of the memory to be; compared.;; Return Value:;; The number of bytes that compared equal is returned as the function; value. If all bytes compared equal, then the length of the orginal; block of memory is returned.;;--
CmFrame struct Fill dq ? ; fill to 8 mod 16 SavedRsi dq ? ; saved nonvolatile registers SavedRdi dq ? ;CmFrame ends
NESTED_ENTRY RtlCompareMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers push_reg rsi ; alloc_stack (sizeof CmFrame - (2 * 8)) ; allocate stack frame
END_PROLOGUE
mov rsi, rcx ; set address of first string mov rdi, rdx ; set address of second string xor edx, ecx ; check if compatible alignment and edx, 07h ; jnz short RlCM50 ; if nz, incompatible alignment cmp r8, 8 ; check if length to align jb short RlCM50 ; if b, insufficient alignment length
;; Buffer alignment is compatible and there are enough bytes for alignment.;
mov r9, rdi ; copy destination address neg ecx ; compute alignment length and ecx, 07h ; jz short RlCM10 ; if z, buffers already aligned sub r8, rcx ; reduce count by align length repe cmpsb ; compare bytes to alignment jnz short RlCM30 ; if nz, not all bytes matchedRlCM10: mov rcx, r8 ; and rcx, 0fffffff8h ; check if and quarwords to compare jz short RlCM20 ; if z, no quadwords to compare sub r8, rcx ; reduce length by compare count shr rcx, 3 ; compute number of quadwords repe cmpsq ; compare quadwords jz short RlCM20 ; if z, all quadwords compared inc rcx ; increment remaining count sub rsi, 8 ; back up source address sub rdi, 8 ; back up destination address shl rcx, 3 ; compute uncompared bytesRlCM20: add r8, rcx ; compute residual bytes to compare jz short RlCM40 ; if z, all bytes compared equal mov rcx, r8 ; set remaining bytes to compare repe cmpsb ; compare bytes jz short RlCM40 ; if z, all byte compared equalRlCM30: dec rdi ; back up destination addressRlCM40: sub rdi, r9 ; compute number of bytes matched mov rax, rdi ; add rsp, sizeof CmFrame - (2 * 8) ; deallocate stack frame pop rsi ; restore nonvolatile register pop rdi ; ret ; return
;; Buffer alignment is incompatible or there is less than 8 bytes to compare.;
RlCM50: test r8, r8 ; test if any bytes to compare jz short RlCM60 ; if z, no bytes to compare mov rcx, r8 ; set number of bytes to compare repe cmpsb ; compare bytes jz short RlCM60 ; if z, all bytes compared equal inc rcx ; increment remaining count sub r8, rcx ; compute number of bytes matchedRlCM60: mov rax, r8 ; add rsp, sizeof CmFrame - (2 * 8) ; deallocate stack frame pop rsi ; restore nonvolatile register pop rdi ; ret ; return
NESTED_END RtlCompareMemory, _TEXT$00
subttl "Compare Memory 32-bits";++;; SIZE_T; RtlCompareMemoryUlong (; IN PVOID Source,; IN SIZE_T Length,; IN ULONG Pattern; );; Routine Description:;; This function compares a block of dword aligned memory with a specified; pattern 32-bits at a time.;; N.B. The low two bits of the length are assumed to be zero and are; ignored.;; Arguments:;; Source (rcx) - Supplies a pointer to the block of memory to compare.;; Length (rdx) - Supplies the length, in bytes, of the memory to compare. compare.;; Pattern (r8d) - Supplies the pattern to be compared against.;; Return Value:;; The number of bytes that compared equal is returned as the function; value. If all bytes compared equal, then the length of the orginal; block of memory is returned.;;--
NESTED_ENTRY RtlCompareMemoryUlong, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address shr rdx, 2 ; compute number of dwords jz short RlCU10 ; if z, no dwords to compare mov rcx, rdx ; set length of compare in dwords mov eax, r8d ; set comparison pattern repe scasd ; compare memory with pattern jz short RlCU10 ; if z, all dwords compared inc rcx ; increment remaining count sub rdx, rcx ; compute number of bytes matchedRlCU10: lea rax, [rdx*4] ; compute successful compare in bytes pop rdi ; restore nonvolatile register ret ; return
NESTED_END RtlCompareMemoryUlong, _TEXT$00
subttl "Copy Memory";++;; VOID; RtlCopyMemory (; OUT VOID UNALIGNED *Destination,; IN CONST VOID UNALIGNED * Sources,; IN SIZE_T Length; );; Routine Description:;; This function copies nonoverlapping from one unaligned buffer to another.;; Arguments:;; Destination (rcx) - Supplies a pointer to the destination buffer.;; Sources (rdx) - Supplies a pointer to the source buffer.;; Length (r8) - Supplies the length, in bytes, of the copy operation.;; Return Value:;; None.;;--
CpFrame struct Fill dq ? ; fill to 8 mod 16 SavedRsi dq ? ; saved nonvolatile registers SavedRdi dq ? ;CpFrame ends
NESTED_ENTRY RtlCopyMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers push_reg rsi ; alloc_stack (sizeof CpFrame - (2 * 8)) ; allocate stack frame
END_PROLOGUE
ALTERNATE_ENTRY RtlCopyMemoryAlternate
mov rdi, rcx ; set destination address mov rsi, rdx ; set source address xor edx, ecx ; check if compatible alignment and edx, 07h ; jnz short RlCP20 ; if nz, incompatible alignment cmp r8, 8 ; check if 8 bytes to move jb short RlCP20 ; if b, less than 8 bytes to move
;; Buffer alignment is compatible and there are enough bytes for alignment.;
neg ecx ; compute alignment length and ecx, 07h ; jz short RlCP10 ; if z, buffers already aligned sub r8, rcx ; reduce count by align length rep movsb ; move bytes to alignment
;; Move 8-byte blocks.;
RlCP10: mov rcx, r8 ; compute number of 8-byte blocks and rcx, 0fffffff8h ; jz short RlCP20 ; if z, no 8-byte blocks sub r8, rcx ; subtract 8-byte blocks from count shr rcx, 3 ; compute number of 8-byte blocks rep movsq ; move 8-byte blocks
;; Move residual bytes.;
RlCP20: test r8, r8 ; test if any bytes to move jz short RlCP30 ; if z, no bytes to move mov rcx, r8 ; set remaining byte to move rep movsb ; move bytes to destinationRlCP30: add rsp, sizeof CpFrame - (2 * 8) ; deallocate stack frame pop rsi ; restore nonvolatile registers pop rdi ; ret ; return
NESTED_END RtlCopyMemory, _TEXT$00
subttl "Copy Memory NonTemporal";++;; VOID; RtlCopyMemoryNonTemporal (; OUT VOID UNALIGNED *Destination,; IN CONST VOID UNALIGNED * Sources,; IN SIZE_T Length; );; Routine Description:;; This function copies nonoverlapping from one buffer to another using; nontemporal moves that do not polute the cache.;; Arguments:;; Destination (rcx) - Supplies a pointer to the destination buffer.;; Sources (rdx) - Supplies a pointer to the source buffer.;; Length (r8) - Supplies the length, in bytes, of the copy operation.;; Return Value:;; None.;;--
NtFrame struct Fill dq ? ; fill to 8 mod 16 SavedRsi dq ? ; saved nonvolatile registers SavedRdi dq ? ;NtFrame ends
NESTED_ENTRY RtlCopyMemoryNonTemporal, _TEXT$00
push_reg rdi ; save nonvolatile registers push_reg rsi ; alloc_stack (sizeof NtFrame - (2 * 8)) ; allocate stack frame
END_PROLOGUE
mov rdi, rcx ; set destination address mov rsi, rdx ; set source address cmp r8, 16 ; check if 16 bytes to move jb RlNT50 ; if b, less than 16 bytes to move
;; Align the destination to a 16-byte boundary.;
neg ecx ; compute alignment length and ecx, 0fh ; jz short RlNT10 ; if z, destination already aligned sub r8, rcx ; reduce count by align length rep movsb ; move bytes to alignment
;; Move 64-byte blocks.;
RlNT10: mov rax, r8 ; compute number of 64-byte blocks and rax, 0ffffffc0h ; jz short RlNT30 ; if z, no 64-byte blocks to move sub r8, rax ; subtract 64-byte blocks from countRlNT20: prefetchnta 0[rsi] ; prefetch start of source block prefetchnta 63[rsi] ; prefetch end source block movdqu xmm0, [rsi] ; move 64-byte block movdqu xmm1, 16[rsi] ; movdqu xmm2, 32[rsi] ; movdqu xmm3, 48[rsi] ; movntq [rdi], xmm0 ; movntq 16[rdi], xmm1 ; movntq 32[rdi], xmm2 ; movntq 48[rdi], xmm3 ; add rdi, 64 ; advance destination address add rsi, 64 ; advance source address sub rax, 64 ; subtract number of bytes moved jnz short RlNT20 ; if nz, more 64-byte blocks to move
;; Move 16-byte blocks.;
RlNT30: mov rax, r8 ; compute number of 16-byte blocks and rax, 0fffffff0h ; jz short RlNT50 ; if z, no 16-byte blocks sub r8, rax ; subract 16-byte blocks from countRlNT40: movdqu xmm0, [rsi] ; move 16-byte block movntq [rdi], xmm0 ; add rdi, 16 ; advance destination address add rsi, 16 ; advance source address sub rax, 16 ; subtract number of bytes moved jnz short RlNT40 ; if nz, more 16-byte blocks to move
;; Move residual bytes.;
RlNT50: test r8, r8 ; test if any bytes to move jz short RlNT60 ; if z, no bytes to move mov rcx, r8 ; set residual bytes to move rep movsb ; move residual bytesRlNT60: sfence ; make sure all stores complete add rsp, sizeof NtFrame - (2 * 8) ; deallocate stack frame pop rsi ; restore nonvolatile registers pop rdi ; ret ; return
NESTED_END RtlCopyMemoryNonTemporal, _TEXT$00
subttl "Fill Memory";++;; VOID; RtlFillMemory (; IN VOID UNALIGNED *Destination,; IN SIZE_T Length,; IN UCHAR Fill; );; Routine Description:;; This function fills a block of unaligned memory with a specified pattern.;; Arguments:;; Destination (rcx) - Supplies a pointer to the memory to fill.;; Length (rdx) - Supplies the length, in bytes, of the memory to fill.;; Fill (r8d) - Supplies the value to fill memory with.;; Return Value:;; None.;;--
NESTED_ENTRY RtlFillMemory, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address mov eax, r8d ; set fill pattern cmp rdx, 8 ; check if 8 bytes to fill jb short RlFM20 ; if b, less than 8 bytes to fill
;; Fill alignment bytes.;
neg ecx ; compute alignment length and ecx, 07h ; jz short RlFM10 ; if z, buffers already aligned sub rdx, rcx ; reduce count by align length rep stosb ; fill bytes to alignment
;; Fill 8-byte blocks.;
RlFM10: mov rcx, rdx ; compute number of 8-byte blocks and rcx, 0fffffff8h ; jz short RlFM20 ; if z, no 8-byte blocks sub rdx, rcx ; subtract 8-byte blocks from count shr rcx, 3 ; compute number of 8-byte blocks mov ah, al ; replicate pattern to dword shl eax, 16 ; mov al, r8b ; mov ah, al ; mov r9, rax ; shl rax, 32 ; or rax, r9 ; rep stosq ; fill 8-byte blocks
;; Fill residual bytes.;
RlFM20: test rdx, rdx ; test if any bytes to fill jz short RlFM30 ; if z, no bytes to fill mov rcx, rdx ; set remaining byte to fill rep stosb ; fill residual bytesRlFM30: pop rdi ; restore nonvolatile register ret ; return
NESTED_END RtlFillMemory, _TEXT$00
subttl "Fill Memory 32-bits";++;; VOID; RtlFillMemoryUlong (; IN PVOID Destination,; IN SIZE_T Length,; IN ULONG Fill; );; Routine Description:;; This function fills a block of dword aligned memory with a specified; pattern 32-bits at a time.;; N.B. The low two bits of the length are assumed to be zero and are; ignored.;; Arguments:;; Destination (rcx) - Supplies a pointer to the memory to fill.;; Length (rdx) - Supplies the length, in bytes, of the memory to fill.;; Fill (r8d) - Supplies the value to fill memory with.;; Return Value:;; None.;;--
NESTED_ENTRY RtlFillMemoryUlong, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address mov rcx, rdx ; set length of fill in bytes shr rcx, 2 ; compute number of dwords jz short RlFL10 ; if z, no dwords to fill mov eax, r8d ; set fill pattern rep stosd ; fill memory with patternRlFl10: pop rdi ; restore nonvolatile register ret ; return
NESTED_END RtlFillMemoryUlong, _TEXT$00
subttl "Fill Memory 64-bits";++;; VOID; RtlFillMemoryUlonglong (; IN PVOID Destination,; IN SIZE_T Length,; IN ULONGLONG Fill; );; Routine Description:;; This function fills a block of qword aligned memory with a specified; pattern 64-bits at a time.;; N.B. The low three bits of the length parameter are assumed to be zero; and are ignored.;; Arguments:;; Destination (rcx) - Supplies a pointer to the memory to fill.;; Length (rdx) - Supplies the length, in bytes, of the memory to fill.;; Fill (r8) - Supplies the value to fill memory with.;; Return Value:;; None.;;--
NESTED_ENTRY RtlFillMemoryUlonglong, _TEXT$00
push_reg rdi ; save nonvolatile register
END_PROLOGUE
mov rdi, rcx ; set destination address mov rcx, rdx ; set length of fill in bytes shr rcx, 3 ; compute number of quadwords jz short RlFU10 ; if z, no quadwords to fill mov rax, r8 ; set fill pattern rep stosq ; fill memory with patternRlFU10: pop rdi ; restore nonvolatile register ret ; return
NESTED_END RtlFillMemoryUlonglong, _TEXT$00
subttl "Move Memory";++;; VOID; RtlMoveMemory (; OUT VOID UNALIGNED *Destination,; IN CONST VOID UNALIGNED * Sources,; IN SIZE_T Length; );; Routine Description:;; This function copies from one unaligned buffer to another.;; Arguments:;; Destination (rcx) - Supplies a pointer to the destination buffer.;; Sources (rdx) - Supplies a pointer to the source buffer.;; Length (r8) - Supplies the length, in bytes, of the copy operation.;; Return Value:;; None.;;--
MmFrame struct Fill dq ? ; fill to 8 mod 16 SavedRsi dq ? ; saved nonvolatile registers SavedRdi dq ? ;MmFrame ends
NESTED_ENTRY RtlMoveMemory, _TEXT$00
push_reg rdi ; save nonvolatile registers push_reg rsi ; alloc_stack (sizeof MmFrame - (2 * 8)) ; allocate stack frame
END_PROLOGUE
cmp rcx, rdx ; check if possible buffer overlap jbe RtlCopyMemoryAlternate ; if be, no overlap possible mov rsi, rdx ; compute ending source address add rsi, r8 ; dec rsi ; cmp rcx, rsi ; check for buffer overlap jg RtlCopyMemoryAlternate ; if g, no overlap possible mov rdi, rcx ; compute ending destination address add rdi, r8 ; dec rdi ; mov rcx, r8 ; set count of bytes to move std ; set direction flag rep movsb ; move bytes backward to destination cld ; clear direction flag add rsp, sizeof MmFrame - (2 * 8) ; deallocate stack frame pop rsi ; restore nonvolatile registers pop rdi ; ret ; return
NESTED_END RtlMoveMemory, _TEXT$00
subttl "Prefetch Memory NonTemporal";++;; VOID; RtlPrefetchMemoryNonTemporal (; IN CONST PVOID Source,; IN SIZE_T Length; );; Routine Description:;; This function prefetches memory at Source, for Length bytes into the; closest cache to the processor.;; Arguments:;; Source (rcx) - Supplies a pointer to the memory to be prefetched.;; Length (rdx) - Supplies the length, in bytes, of the operation.;; Return Value:;; None.;;--
LEAF_ENTRY RtlPrefetchMemoryNonTemporal, _TEXT$00
RlPF10: prefetchnta 0[rcx] ; prefetch line add rcx, 64 ; increment address to prefetch sub rdx, 64 ; subtract number of bytes prefetched ja RlPF10 ; if above zero, more bytes to move ret ; return
LEAF_END RtlPrefetchMemoryNonTemporal, _TEXT$00
subttl "Zero Memory";++;; VOID; RtlZeroMemory (; IN VOID UNALIGNED *Destination,; IN SIZE_T Length; );; Routine Description:;; This function fills a block of unaligned memory with zero.;; Arguments:;; Destination (rcx) - Supplies a pointer to the memory to fill.;; Length (rdx) - Supplies the length, in bytes, of the memory to fill.;; Return Value:;; None.;;--
LEAF_ENTRY RtlZeroMemory, _TEXT$00
xor r8, r8 ; set fill pattern jmp RtlFillMemory ; finish in common code
LEAF_END RtlZeroMemory, _TEXT$00
end
|
