unit FastMove;

(*
Copyright (c) 2006, John O'Harrow (john@elmcrest.demon.co.uk)

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the
use of this software.

Permission is granted to anyone to use this software for any purpose, including
commercial applications, and to alter it and redistribute it freely, subject to
the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim
that you wrote the original software. If you use this software in a product,
an acknowledgment in the product documentation would be appreciated but is
not required.

2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

-------------------------------------------------------------------------------

Version: 3.03 : 06-MAR-2006

How to use:

Include this unit in any uses clause - Thats It!

What is Does:

This unit replaces all calls to system.move with calls to a faster move
procedure (Up to 3 times faster). The code will automatically detect and
use MMX, SSE, SSE2 or SSE3 where available.

Version Change
------- ------
2.00 Updated all Moves to use Move_JOH_XXX_6 (better code alignment).
2.10 VirtualProtect modified to use PAGE_EXECUTE_READWRITE to prevent
error under WinXP SP2 with AMD64 running DEP.
2.20 Added Check for "Already Patched" to prevent error when using.
Packages in both DLL's and EXE.
2.30 PrefetchLimit initialization moved outside of ReplaceMove.
3.00 Updated all Moves to use latest Move_JOH_XXX_10 procedures and added
SSE2 and SSE3 optimized moves.
Extra VirtualProtect removed. PatchSystemMove Directive added.
Local Move Procedure added for direct calling of fastest Move.
3.01 {$D-} Added to prevent stepping into the Move BASM Code
Badly Names PrefetchLimit renamed CacheLimit
3.02 Incorrect DB equivalents of lddqu instruction corrected
3.03 Compiler Directives for D2006 Added
Contact Email address corrected
*)

{.$D-} {Prevent Steppping into Move Code}

{$DEFINE PatchSystemMove} {Enable Patching of System.Move}

{$IFDEF VER170}
{$DEFINE SSE2Basm}
{$WARN UNSAFE_CODE OFF}
{$ENDIF}

{$IFDEF CONDITIONALEXPRESSIONS}
{$IF CompilerVersion >= 18.0}
{$DEFINE SSE2Basm}
{$WARN UNSAFE_CODE OFF}
{$IFEND}
{$ENDIF}

interface

var
Move : procedure(const Source; var Dest; Count : Integer); {Fastest Move}

{Procedures interfaced only for testing and validation purposes}
procedure MoveJOH_PAS_10 (const Source; var Dest; Count : Integer);
procedure MoveJOH_IA32_10(const Source; var Dest; Count : Integer);
procedure MoveJOH_MMX_10 (const Source; var Dest; Count : Integer);
procedure MoveJOH_SSE_10 (const Source; var Dest; Count : Integer);
procedure MoveJOH_SSE2_10(const Source; var Dest; Count : Integer);
procedure MoveJOH_SSE3_10(const Source; var Dest; Count : Integer);

implementation

uses
Windows, SysUtils, FastcodeCPUID;

var
CacheLimit : Integer; {Used within SSE Moves}

{-------------------------------------------------------------------------}
{Move without using any BASM Code}
procedure MoveJOH_PAS_10(const Source; var Dest; Count : Integer);
var
S, D : Cardinal;
Temp, C, I : Integer;
L : PInteger;
begin
S := Cardinal(@Source);
D := Cardinal(@Dest);
if S = D then
Exit;
if Count <= 4 then
case Count of
1 : PByte(@Dest)^ := PByte(S)^;
2 : PWord(@Dest)^ := PWord(S)^;
3 : if D > S then
begin
PByte(Integer(@Dest)+2)^ := PByte(S+2)^;
PWord(@Dest)^ := PWord(S)^;
end
else
begin
PWord(@Dest)^ := PWord(S)^;
PByte(Integer(@Dest)+2)^ := PByte(S+2)^;
end;
4 : PInteger(@Dest)^ := PInteger(S)^
else Exit; {Count <= 0}
end
else
if D > S then
begin
Temp := PInteger(S)^;
I := Integer(@Dest);
C := Count - 4;
L := PInteger(Integer(@Dest) + C);
Inc(S, C);
repeat
L^ := PInteger(S)^;
if Count <= 8 then
Break;
Dec(Count, 4);
Dec(S, 4);
Dec(L);
until False;
PInteger(I)^ := Temp;
end
else
begin
C := Count - 4;
Temp := PInteger(S + Cardinal(C))^;
I := Integer(@Dest) + C;
L := @Dest;
repeat
L^ := PInteger(S)^;
if Count <= 8 then
Break;
Dec(Count, 4);
Inc(S, 4);
Inc(L);
until False;
PInteger(I)^ := Temp;
end;
end; {MoveJOH_PAS}

const
TINYSIZE = 36;

{-------------------------------------------------------------------------}
{Perform Forward Move of 0..36 Bytes}
{On Entry, ECX = Count, EAX = Source+Count, EDX = Dest+Count. Destroys ECX}
procedure SmallForwardMove_10;
asm
jmp dword ptr [@@FwdJumpTable+ecx*4]
nop {Align Jump Table}
@@FwdJumpTable:
dd @@Done {Removes need to test for zero size move}
dd @@Fwd01, @@Fwd02, @@Fwd03, @@Fwd04, @@Fwd05, @@Fwd06, @@Fwd07, @@Fwd08
dd @@Fwd09, @@Fwd10, @@Fwd11, @@Fwd12, @@Fwd13, @@Fwd14, @@Fwd15, @@Fwd16
dd @@Fwd17, @@Fwd18, @@Fwd19, @@Fwd20, @@Fwd21, @@Fwd22, @@Fwd23, @@Fwd24
dd @@Fwd25, @@Fwd26, @@Fwd27, @@Fwd28, @@Fwd29, @@Fwd30, @@Fwd31, @@Fwd32
dd @@Fwd33, @@Fwd34, @@Fwd35, @@Fwd36
@@Fwd36:
mov ecx, [eax-36]
mov [edx-36], ecx
@@Fwd32:
mov ecx, [eax-32]
mov [edx-32], ecx
@@Fwd28:
mov ecx, [eax-28]
mov [edx-28], ecx
@@Fwd24:
mov ecx, [eax-24]
mov [edx-24], ecx
@@Fwd20:
mov ecx, [eax-20]
mov [edx-20], ecx
@@Fwd16:
mov ecx, [eax-16]
mov [edx-16], ecx
@@Fwd12:
mov ecx, [eax-12]
mov [edx-12], ecx
@@Fwd08:
mov ecx, [eax-8]
mov [edx-8], ecx
@@Fwd04:
mov ecx, [eax-4]
mov [edx-4], ecx
ret
nop
@@Fwd35:
mov ecx, [eax-35]
mov [edx-35], ecx
@@Fwd31:
mov ecx, [eax-31]
mov [edx-31], ecx
@@Fwd27:
mov ecx, [eax-27]
mov [edx-27], ecx
@@Fwd23:
mov ecx, [eax-23]
mov [edx-23], ecx
@@Fwd19:
mov ecx, [eax-19]
mov [edx-19], ecx
@@Fwd15:
mov ecx, [eax-15]
mov [edx-15], ecx
@@Fwd11:
mov ecx, [eax-11]
mov [edx-11], ecx
@@Fwd07:
mov ecx, [eax-7]
mov [edx-7], ecx
mov ecx, [eax-4]
mov [edx-4], ecx
ret
nop
@@Fwd03:
movzx ecx, word ptr [eax-3]
mov [edx-3], cx
movzx ecx, byte ptr [eax-1]
mov [edx-1], cl
ret
@@Fwd34:
mov ecx, [eax-34]
mov [edx-34], ecx
@@Fwd30:
mov ecx, [eax-30]
mov [edx-30], ecx
@@Fwd26:
mov ecx, [eax-26]
mov [edx-26], ecx
@@Fwd22:
mov ecx, [eax-22]
mov [edx-22], ecx
@@Fwd18:
mov ecx, [eax-18]
mov [edx-18], ecx
@@Fwd14:
mov ecx, [eax-14]
mov [edx-14], ecx
@@Fwd10:
mov ecx, [eax-10]
mov [edx-10], ecx
@@Fwd06:
mov ecx, [eax-6]
mov [edx-6], ecx
@@Fwd02:
movzx ecx, word ptr [eax-2]
mov [edx-2], cx
ret
nop
nop
nop
@@Fwd33:
mov ecx, [eax-33]
mov [edx-33], ecx
@@Fwd29:
mov ecx, [eax-29]
mov [edx-29], ecx
@@Fwd25:
mov ecx, [eax-25]
mov [edx-25], ecx
@@Fwd21:
mov ecx, [eax-21]
mov [edx-21], ecx
@@Fwd17:
mov ecx, [eax-17]
mov [edx-17], ecx
@@Fwd13:
mov ecx, [eax-13]
mov [edx-13], ecx
@@Fwd09:
mov ecx, [eax-9]
mov [edx-9], ecx
@@Fwd05:
mov ecx, [eax-5]
mov [edx-5], ecx
@@Fwd01:
movzx ecx, byte ptr [eax-1]
mov [edx-1], cl
ret
@@Done:
end; {SmallForwardMove}

{-------------------------------------------------------------------------}
{Perform Backward Move of 0..36 Bytes}
{On Entry, ECX = Count, EAX = Source, EDX = Dest. Destroys ECX}
procedure SmallBackwardMove_10;
asm
jmp dword ptr [@@BwdJumpTable+ecx*4]
nop {Align Jump Table}
@@BwdJumpTable:
dd @@Done {Removes need to test for zero size move}
dd @@Bwd01, @@Bwd02, @@Bwd03, @@Bwd04, @@Bwd05, @@Bwd06, @@Bwd07, @@Bwd08
dd @@Bwd09, @@Bwd10, @@Bwd11, @@Bwd12, @@Bwd13, @@Bwd14, @@Bwd15, @@Bwd16
dd @@Bwd17, @@Bwd18, @@Bwd19, @@Bwd20, @@Bwd21, @@Bwd22, @@Bwd23, @@Bwd24
dd @@Bwd25, @@Bwd26, @@Bwd27, @@Bwd28, @@Bwd29, @@Bwd30, @@Bwd31, @@Bwd32
dd @@Bwd33, @@Bwd34, @@Bwd35, @@Bwd36
@@Bwd36:
mov ecx, [eax+32]
mov [edx+32], ecx
@@Bwd32:
mov ecx, [eax+28]
mov [edx+28], ecx
@@Bwd28:
mov ecx, [eax+24]
mov [edx+24], ecx
@@Bwd24:
mov ecx, [eax+20]
mov [edx+20], ecx
@@Bwd20:
mov ecx, [eax+16]
mov [edx+16], ecx
@@Bwd16:
mov ecx, [eax+12]
mov [edx+12], ecx
@@Bwd12:
mov ecx, [eax+8]
mov [edx+8], ecx
@@Bwd08:
mov ecx, [eax+4]
mov [edx+4], ecx
@@Bwd04:
mov ecx, [eax]
mov [edx], ecx
ret
nop
nop
nop
@@Bwd35:
mov ecx, [eax+31]
mov [edx+31], ecx
@@Bwd31:
mov ecx, [eax+27]
mov [edx+27], ecx
@@Bwd27:
mov ecx, [eax+23]
mov [edx+23], ecx
@@Bwd23:
mov ecx, [eax+19]
mov [edx+19], ecx
@@Bwd19:
mov ecx, [eax+15]
mov [edx+15], ecx
@@Bwd15:
mov ecx, [eax+11]
mov [edx+11], ecx
@@Bwd11:
mov ecx, [eax+7]
mov [edx+7], ecx
@@Bwd07:
mov ecx, [eax+3]
mov [edx+3], ecx
mov ecx, [eax]
mov [edx], ecx
ret
nop
nop
nop
@@Bwd03:
movzx ecx, word ptr [eax+1]
mov [edx+1], cx
movzx ecx, byte ptr [eax]
mov [edx], cl
ret
nop
nop
@@Bwd34:
mov ecx, [eax+30]
mov [edx+30], ecx
@@Bwd30:
mov ecx, [eax+26]
mov [edx+26], ecx
@@Bwd26:
mov ecx, [eax+22]
mov [edx+22], ecx
@@Bwd22:
mov ecx, [eax+18]
mov [edx+18], ecx
@@Bwd18:
mov ecx, [eax+14]
mov [edx+14], ecx
@@Bwd14:
mov ecx, [eax+10]
mov [edx+10], ecx
@@Bwd10:
mov ecx, [eax+6]
mov [edx+6], ecx
@@Bwd06:
mov ecx, [eax+2]
mov [edx+2], ecx
@@Bwd02:
movzx ecx, word ptr [eax]
mov [edx], cx
ret
nop
@@Bwd33:
mov ecx, [eax+29]
mov [edx+29], ecx
@@Bwd29:
mov ecx, [eax+25]
mov [edx+25], ecx
@@Bwd25:
mov ecx, [eax+21]
mov [edx+21], ecx
@@Bwd21:
mov ecx, [eax+17]
mov [edx+17], ecx
@@Bwd17:
mov ecx, [eax+13]
mov [edx+13], ecx
@@Bwd13:
mov ecx, [eax+9]
mov [edx+9], ecx
@@Bwd09:
mov ecx, [eax+5]
mov [edx+5], ecx
@@Bwd05:
mov ecx, [eax+1]
mov [edx+1], ecx
@@Bwd01:
movzx ecx, byte ptr[eax]
mov [edx], cl
ret
@@Done:
end; {SmallBackwardMove}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX > EDX and ECX > 36 (TINYSIZE)}
procedure Forwards_IA32_10;
asm
fild qword ptr [eax] {First 8}
lea eax, [eax+ecx-8]
lea ecx, [edx+ecx-8]
push edx
push ecx
fild qword ptr [eax] {Last 8}
neg ecx {QWORD Align Writes}
and edx, -8
lea ecx, [ecx+edx+8]
pop edx
@@Loop:
fild qword ptr [eax+ecx]
fistp qword ptr [edx+ecx]
add ecx, 8
jl @@Loop
pop eax
fistp qword ptr [edx] {Last 8}
fistp qword ptr [eax] {First 8}
end; {Forwards_IA32}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX < EDX and ECX > 36 (TINYSIZE)}
procedure Backwards_IA32_10;
asm
sub ecx, 8
fild qword ptr [eax+ecx] {Last 8}
fild qword ptr [eax] {First 8}
add ecx, edx {QWORD Align Writes}
push ecx
and ecx, -8
sub ecx, edx
@@Loop:
fild qword ptr [eax+ecx]
fistp qword ptr [edx+ecx]
sub ecx, 8
jg @@Loop
pop eax
fistp qword ptr [edx] {First 8}
fistp qword ptr [eax] {Last 8}
end; {Backwards_IA32}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX > EDX and ECX > 36 (TINYSIZE)}
procedure Forwards_MMX_10;
const
SMALLSIZE = 64;
LARGESIZE = 2048;
asm
cmp ecx, SMALLSIZE {Size at which using MMX becomes worthwhile}
jl Forwards_IA32_10
cmp ecx, LARGESIZE
jge @@FwdLargeMove
push ebx
mov ebx, edx
movq mm0, [eax] {First 8 Bytes}
add eax, ecx {QWORD Align Writes}
add ecx, edx
and edx, -8
add edx, 40
sub ecx, edx
add edx, ecx
neg ecx
nop {Align Loop}
@@FwdLoopMMX:
movq mm1, [eax+ecx-32]
movq mm2, [eax+ecx-24]
movq mm3, [eax+ecx-16]
movq mm4, [eax+ecx- 8]
movq [edx+ecx-32], mm1
movq [edx+ecx-24], mm2
movq [edx+ecx-16], mm3
movq [edx+ecx- 8], mm4
add ecx, 32
jle @@FwdLoopMMX
movq [ebx], mm0 {First 8 Bytes}
emms
pop ebx
neg ecx
add ecx, 32
jmp SmallForwardMove_10
nop {Align Loop}
nop
@@FwdLargeMove:
push ebx
mov ebx, ecx
test edx, 15
jz @@FwdAligned
lea ecx, [edx+15] {16 byte Align Destination}
and ecx, -16
sub ecx, edx
add eax, ecx
add edx, ecx
sub ebx, ecx
call SmallForwardMove_10
@@FwdAligned:
mov ecx, ebx
and ecx, -16
sub ebx, ecx {EBX = Remainder}
push esi
push edi
mov esi, eax {ESI = Source}
mov edi, edx {EDI = Dest}
mov eax, ecx {EAX = Count}
and eax, -64 {EAX = No of Bytes to Blocks Moves}
and ecx, $3F {ECX = Remaining Bytes to Move (0..63)}
add esi, eax
add edi, eax
neg eax
@@MMXcopyloop:
movq mm0, [esi+eax ]
movq mm1, [esi+eax+ 8]
movq mm2, [esi+eax+16]
movq mm3, [esi+eax+24]
movq mm4, [esi+eax+32]
movq mm5, [esi+eax+40]
movq mm6, [esi+eax+48]
movq mm7, [esi+eax+56]
movq [edi+eax ], mm0
movq [edi+eax+ 8], mm1
movq [edi+eax+16], mm2
movq [edi+eax+24], mm3
movq [edi+eax+32], mm4
movq [edi+eax+40], mm5
movq [edi+eax+48], mm6
movq [edi+eax+56], mm7
add eax, 64
jnz @@MMXcopyloop
emms {Empty MMX State}
add ecx, ebx
shr ecx, 2
rep movsd
mov ecx, ebx
and ecx, 3
rep movsb
pop edi
pop esi
pop ebx
end; {Forwards_MMX}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX < EDX and ECX > 36 (TINYSIZE)}
procedure Backwards_MMX_10;
const
SMALLSIZE = 64;
asm
cmp ecx, SMALLSIZE {Size at which using MMX becomes worthwhile}
jl Backwards_IA32_10
push ebx
movq mm0, [eax+ecx-8] {Get Last QWORD}
lea ebx, [edx+ecx] {QWORD Align Writes}
and ebx, 7
sub ecx, ebx
add ebx, ecx
sub ecx, 32
@@BwdLoopMMX:
movq mm1, [eax+ecx ]
movq mm2, [eax+ecx+ 8]
movq mm3, [eax+ecx+16]
movq mm4, [eax+ecx+24]
movq [edx+ecx+24], mm4
movq [edx+ecx+16], mm3
movq [edx+ecx+ 8], mm2
movq [edx+ecx ], mm1
sub ecx, 32
jge @@BwdLoopMMX
movq [edx+ebx-8], mm0 {Last QWORD}
emms
add ecx, 32
pop ebx
jmp SmallBackwardMove_10
end; {Backwards_MMX}

{-------------------------------------------------------------------------}
procedure LargeAlignedSSEMove;
asm
@@Loop:
movaps xmm0, [eax+ecx]
movaps xmm1, [eax+ecx+16]
movaps xmm2, [eax+ecx+32]
movaps xmm3, [eax+ecx+48]
movaps [edx+ecx], xmm0
movaps [edx+ecx+16], xmm1
movaps [edx+ecx+32], xmm2
movaps [edx+ecx+48], xmm3
movaps xmm4, [eax+ecx+64]
movaps xmm5, [eax+ecx+80]
movaps xmm6, [eax+ecx+96]
movaps xmm7, [eax+ecx+112]
movaps [edx+ecx+64], xmm4
movaps [edx+ecx+80], xmm5
movaps [edx+ecx+96], xmm6
movaps [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
end; {LargeAlignedSSEMove}

{-------------------------------------------------------------------------}
procedure LargeUnalignedSSEMove;
asm
@@Loop:
movups xmm0, [eax+ecx]
movups xmm1, [eax+ecx+16]
movups xmm2, [eax+ecx+32]
movups xmm3, [eax+ecx+48]
movaps [edx+ecx], xmm0
movaps [edx+ecx+16], xmm1
movaps [edx+ecx+32], xmm2
movaps [edx+ecx+48], xmm3
movups xmm4, [eax+ecx+64]
movups xmm5, [eax+ecx+80]
movups xmm6, [eax+ecx+96]
movups xmm7, [eax+ecx+112]
movaps [edx+ecx+64], xmm4
movaps [edx+ecx+80], xmm5
movaps [edx+ecx+96], xmm6
movaps [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
end; {LargeUnalignedSSEMove}

{-------------------------------------------------------------------------}
procedure HugeAlignedSSEMove;
const
Prefetch = 512;
asm
@@Loop:
prefetchnta [eax+ecx+Prefetch]
prefetchnta [eax+ecx+Prefetch+64]
movaps xmm0, [eax+ecx]
movaps xmm1, [eax+ecx+16]
movaps xmm2, [eax+ecx+32]
movaps xmm3, [eax+ecx+48]
movntps [edx+ecx], xmm0
movntps [edx+ecx+16], xmm1
movntps [edx+ecx+32], xmm2
movntps [edx+ecx+48], xmm3
movaps xmm4, [eax+ecx+64]
movaps xmm5, [eax+ecx+80]
movaps xmm6, [eax+ecx+96]
movaps xmm7, [eax+ecx+112]
movntps [edx+ecx+64], xmm4
movntps [edx+ecx+80], xmm5
movntps [edx+ecx+96], xmm6
movntps [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
sfence
end; {HugeAlignedSSEMove}

{-------------------------------------------------------------------------}
procedure HugeUnalignedSSEMove;
const
Prefetch = 512;
asm
@@Loop:
prefetchnta [eax+ecx+Prefetch]
prefetchnta [eax+ecx+Prefetch+64]
movups xmm0, [eax+ecx]
movups xmm1, [eax+ecx+16]
movups xmm2, [eax+ecx+32]
movups xmm3, [eax+ecx+48]
movntps [edx+ecx], xmm0
movntps [edx+ecx+16], xmm1
movntps [edx+ecx+32], xmm2
movntps [edx+ecx+48], xmm3
movups xmm4, [eax+ecx+64]
movups xmm5, [eax+ecx+80]
movups xmm6, [eax+ecx+96]
movups xmm7, [eax+ecx+112]
movntps [edx+ecx+64], xmm4
movntps [edx+ecx+80], xmm5
movntps [edx+ecx+96], xmm6
movntps [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
sfence
end; {HugeUnalignedSSEMove}

{-------------------------------------------------------------------------}
{Dest MUST be 16-Byes Aligned, Count MUST be multiple of 16 }
procedure LargeSSEMove(const Source; var Dest; Count: Integer);
asm
push ebx
mov ebx, ecx
and ecx, -128 {No of Bytes to Block Move (Multiple of 128)}
add eax, ecx {End of Source Blocks}
add edx, ecx {End of Dest Blocks}
neg ecx
cmp ecx, CacheLimit {Count > Limit - Use Prefetch}
jl @@Huge
test eax, 15 {Check if Both Source/Dest are Aligned}
jnz @@LargeUnaligned
call LargeAlignedSSEMove {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@LargeUnaligned: {Source Not 16-Byte Aligned}
call LargeUnalignedSSEMove
jmp @@Remainder
@@Huge:
test eax, 15 {Check if Both Source/Dest Aligned}
jnz @@HugeUnaligned
call HugeAlignedSSEMove {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@HugeUnaligned: {Source Not 16-Byte Aligned}
call HugeUnalignedSSEMove
@@Remainder:
and ebx, $7F {Remainder (0..112 - Multiple of 16)}
jz @@Done
add eax, ebx
add edx, ebx
neg ebx
@@RemainderLoop:
movups xmm0, [eax+ebx]
movaps [edx+ebx], xmm0
add ebx, 16
jnz @@RemainderLoop
@@Done:
pop ebx
end; {LargeSSEMove}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX > EDX and ECX > 36 (TINYSIZE)}
procedure Forwards_SSE_10;
const
SMALLSIZE = 64;
LARGESIZE = 2048;
asm
cmp ecx, SMALLSIZE
jle Forwards_IA32_10
push ebx
cmp ecx, LARGESIZE
jge @@FwdLargeMove
movups xmm0, [eax] {First 16 Bytes}
mov ebx, edx
add eax, ecx {Align Writes}
add ecx, edx
and edx, -16
add edx, 48
sub ecx, edx
add edx, ecx
neg ecx
nop {Align Loop}
@@FwdLoopSSE:
movups xmm1, [eax+ecx-32]
movups xmm2, [eax+ecx-16]
movaps [edx+ecx-32], xmm1
movaps [edx+ecx-16], xmm2
add ecx, 32
jle @@FwdLoopSSE
movups [ebx], xmm0 {First 16 Bytes}
neg ecx
add ecx, 32
pop ebx
jmp SmallForwardMove_10
@@FwdLargeMove:
mov ebx, ecx
test edx, 15
jz @@FwdLargeAligned
lea ecx, [edx+15] {16 byte Align Destination}
and ecx, -16
sub ecx, edx
add eax, ecx
add edx, ecx
sub ebx, ecx
call SmallForwardMove_10
mov ecx, ebx
@@FwdLargeAligned:
and ecx, -16
sub ebx, ecx {EBX = Remainder}
push edx
push eax
push ecx
call LargeSSEMove
pop ecx
pop eax
pop edx
add ecx, ebx
add eax, ecx
add edx, ecx
mov ecx, ebx
pop ebx
jmp SmallForwardMove_10
end; {Forwards_SSE}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX < EDX and ECX > 36 (TINYSIZE)}
procedure Backwards_SSE_10;
const
SMALLSIZE = 64;
asm
cmp ecx, SMALLSIZE
jle Backwards_IA32_10
push ebx
movups xmm0, [eax+ecx-16] {Last 16 Bytes}
lea ebx, [edx+ecx] {Align Writes}
and ebx, 15
sub ecx, ebx
add ebx, ecx
sub ecx, 32
@@BwdLoop:
movups xmm1, [eax+ecx]
movups xmm2, [eax+ecx+16]
movaps [edx+ecx], xmm1
movaps [edx+ecx+16], xmm2
sub ecx, 32
jge @@BwdLoop
movups [edx+ebx-16], xmm0 {Last 16 Bytes}
add ecx, 32
pop ebx
jmp SmallBackwardMove_10
end; {Backwards_SSE}

{-------------------------------------------------------------------------}
procedure LargeAlignedSSE2Move; {Also used in SSE3 Move}
asm
@@Loop:
movdqa xmm0, [eax+ecx]
movdqa xmm1, [eax+ecx+16]
movdqa xmm2, [eax+ecx+32]
movdqa xmm3, [eax+ecx+48]
movdqa [edx+ecx], xmm0
movdqa [edx+ecx+16], xmm1
movdqa [edx+ecx+32], xmm2
movdqa [edx+ecx+48], xmm3
movdqa xmm4, [eax+ecx+64]
movdqa xmm5, [eax+ecx+80]
movdqa xmm6, [eax+ecx+96]
movdqa xmm7, [eax+ecx+112]
movdqa [edx+ecx+64], xmm4
movdqa [edx+ecx+80], xmm5
movdqa [edx+ecx+96], xmm6
movdqa [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
end; {LargeAlignedSSE2Move}

{-------------------------------------------------------------------------}
procedure LargeUnalignedSSE2Move;
asm
@@Loop:
movdqu xmm0, [eax+ecx]
movdqu xmm1, [eax+ecx+16]
movdqu xmm2, [eax+ecx+32]
movdqu xmm3, [eax+ecx+48]
movdqa [edx+ecx], xmm0
movdqa [edx+ecx+16], xmm1
movdqa [edx+ecx+32], xmm2
movdqa [edx+ecx+48], xmm3
movdqu xmm4, [eax+ecx+64]
movdqu xmm5, [eax+ecx+80]
movdqu xmm6, [eax+ecx+96]
movdqu xmm7, [eax+ecx+112]
movdqa [edx+ecx+64], xmm4
movdqa [edx+ecx+80], xmm5
movdqa [edx+ecx+96], xmm6
movdqa [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
end; {LargeUnalignedSSE2Move}

{-------------------------------------------------------------------------}
procedure HugeAlignedSSE2Move; {Also used in SSE3 Move}
const
Prefetch = 512;
asm
@@Loop:
prefetchnta [eax+ecx+Prefetch]
prefetchnta [eax+ecx+Prefetch+64]
movdqa xmm0, [eax+ecx]
movdqa xmm1, [eax+ecx+16]
movdqa xmm2, [eax+ecx+32]
movdqa xmm3, [eax+ecx+48]
movntdq [edx+ecx], xmm0
movntdq [edx+ecx+16], xmm1
movntdq [edx+ecx+32], xmm2
movntdq [edx+ecx+48], xmm3
movdqa xmm4, [eax+ecx+64]
movdqa xmm5, [eax+ecx+80]
movdqa xmm6, [eax+ecx+96]
movdqa xmm7, [eax+ecx+112]
movntdq [edx+ecx+64], xmm4
movntdq [edx+ecx+80], xmm5
movntdq [edx+ecx+96], xmm6
movntdq [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
sfence
end; {HugeAlignedSSE2Move}

{-------------------------------------------------------------------------}
procedure HugeUnalignedSSE2Move;
const
Prefetch = 512;
asm
@@Loop:
prefetchnta [eax+ecx+Prefetch]
prefetchnta [eax+ecx+Prefetch+64]
movdqu xmm0, [eax+ecx]
movdqu xmm1, [eax+ecx+16]
movdqu xmm2, [eax+ecx+32]
movdqu xmm3, [eax+ecx+48]
movntdq [edx+ecx], xmm0
movntdq [edx+ecx+16], xmm1
movntdq [edx+ecx+32], xmm2
movntdq [edx+ecx+48], xmm3
movdqu xmm4, [eax+ecx+64]
movdqu xmm5, [eax+ecx+80]
movdqu xmm6, [eax+ecx+96]
movdqu xmm7, [eax+ecx+112]
movntdq [edx+ecx+64], xmm4
movntdq [edx+ecx+80], xmm5
movntdq [edx+ecx+96], xmm6
movntdq [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
sfence
end; {HugeUnalignedSSE2Move}

{-------------------------------------------------------------------------}
{Dest MUST be 16-Byes Aligned, Count MUST be multiple of 16 }
procedure LargeSSE2Move(const Source; var Dest; Count: Integer);
asm
push ebx
mov ebx, ecx
and ecx, -128 {No of Bytes to Block Move (Multiple of 128)}
add eax, ecx {End of Source Blocks}
add edx, ecx {End of Dest Blocks}
neg ecx
cmp ecx, CacheLimit {Count > Limit - Use Prefetch}
jl @@Huge
test eax, 15 {Check if Both Source/Dest are Aligned}
jnz @@LargeUnaligned
call LargeAlignedSSE2Move {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@LargeUnaligned: {Source Not 16-Byte Aligned}
call LargeUnalignedSSE2Move
jmp @@Remainder
@@Huge:
test eax, 15 {Check if Both Source/Dest Aligned}
jnz @@HugeUnaligned
call HugeAlignedSSE2Move {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@HugeUnaligned: {Source Not 16-Byte Aligned}
call HugeUnalignedSSE2Move
@@Remainder:
and ebx, $7F {Remainder (0..112 - Multiple of 16)}
jz @@Done
add eax, ebx
add edx, ebx
neg ebx
@@RemainderLoop:
movdqu xmm0, [eax+ebx]
movdqa [edx+ebx], xmm0
add ebx, 16
jnz @@RemainderLoop
@@Done:
pop ebx
end; {LargeSSE2Move}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX > EDX and ECX > 36 (TINYSIZE)}
procedure Forwards_SSE2_10;
const
SMALLSIZE = 64;
LARGESIZE = 2048;
asm
cmp ecx, SMALLSIZE
jle Forwards_IA32_10
push ebx
cmp ecx, LARGESIZE
jge @@FwdLargeMove
movdqu xmm0, [eax] {First 16 Bytes}
mov ebx, edx
add eax, ecx {Align Writes}
add ecx, edx
and edx, -16
add edx, 48
sub ecx, edx
add edx, ecx
neg ecx
@@FwdLoopSSE2:
movdqu xmm1, [eax+ecx-32]
movdqu xmm2, [eax+ecx-16]
movdqa [edx+ecx-32], xmm1
movdqa [edx+ecx-16], xmm2
add ecx, 32
jle @@FwdLoopSSE2
movdqu [ebx], xmm0 {First 16 Bytes}
neg ecx
add ecx, 32
pop ebx
jmp SmallForwardMove_10
@@FwdLargeMove:
mov ebx, ecx
test edx, 15
jz @@FwdLargeAligned
lea ecx, [edx+15] {16 byte Align Destination}
and ecx, -16
sub ecx, edx
add eax, ecx
add edx, ecx
sub ebx, ecx
call SmallForwardMove_10
mov ecx, ebx
@@FwdLargeAligned:
and ecx, -16
sub ebx, ecx {EBX = Remainder}
push edx
push eax
push ecx
call LargeSSE2Move
pop ecx
pop eax
pop edx
add ecx, ebx
add eax, ecx
add edx, ecx
mov ecx, ebx
pop ebx
jmp SmallForwardMove_10
end; {Forwards_SSE2}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX < EDX and ECX > 36 (TINYSIZE)}
procedure Backwards_SSE2_10;
const
SMALLSIZE = 64;
asm
cmp ecx, SMALLSIZE
jle Backwards_IA32_10
push ebx
movdqu xmm0, [eax+ecx-16] {Last 16 Bytes}
lea ebx, [edx+ecx] {Align Writes}
and ebx, 15
sub ecx, ebx
add ebx, ecx
sub ecx, 32
add edi, 0 {3-Byte NOP Equivalent to Align Loop}
@@BwdLoop:
movdqu xmm1, [eax+ecx]
movdqu xmm2, [eax+ecx+16]
movdqa [edx+ecx], xmm1
movdqa [edx+ecx+16], xmm2
sub ecx, 32
jge @@BwdLoop
movdqu [edx+ebx-16], xmm0 {Last 16 Bytes}
add ecx, 32
pop ebx
jmp SmallBackwardMove_10
end; {Backwards_SSE2}

{-------------------------------------------------------------------------}
procedure LargeUnalignedSSE3Move;
asm
@@Loop:
{$IFDEF SSE2Basm}
lddqu xmm0, [eax+ecx]
lddqu xmm1, [eax+ecx+16]
lddqu xmm2, [eax+ecx+32]
lddqu xmm3, [eax+ecx+48]
{$ELSE}
DB $F2,$0F,$F0,$04,$01
DB $F2,$0F,$F0,$4C,$01,$10
DB $F2,$0F,$F0,$54,$01,$20
DB $F2,$0F,$F0,$5C,$01,$30
{$ENDIF}
movdqa [edx+ecx], xmm0
movdqa [edx+ecx+16], xmm1
movdqa [edx+ecx+32], xmm2
movdqa [edx+ecx+48], xmm3
{$IFDEF SSE2Basm}
lddqu xmm4, [eax+ecx+64]
lddqu xmm5, [eax+ecx+80]
lddqu xmm6, [eax+ecx+96]
lddqu xmm7, [eax+ecx+112]
{$ELSE}
DB $F2,$0F,$F0,$64,$01,$40
DB $F2,$0F,$F0,$6C,$01,$50
DB $F2,$0F,$F0,$74,$01,$60
DB $F2,$0F,$F0,$7C,$01,$70
{$ENDIF}
movdqa [edx+ecx+64], xmm4
movdqa [edx+ecx+80], xmm5
movdqa [edx+ecx+96], xmm6
movdqa [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
end; {LargeUnalignedSSE3Move}

{-------------------------------------------------------------------------}
procedure HugeUnalignedSSE3Move;
const
Prefetch = 512;
asm
@@Loop:
prefetchnta [eax+ecx+Prefetch]
prefetchnta [eax+ecx+Prefetch+64]
{$IFDEF SSE2Basm}
lddqu xmm0, [eax+ecx]
lddqu xmm1, [eax+ecx+16]
lddqu xmm2, [eax+ecx+32]
lddqu xmm3, [eax+ecx+48]
{$ELSE}
DB $F2,$0F,$F0,$04,$01
DB $F2,$0F,$F0,$4C,$01,$10
DB $F2,$0F,$F0,$54,$01,$20
DB $F2,$0F,$F0,$5C,$01,$30
{$ENDIF}
movntdq [edx+ecx], xmm0
movntdq [edx+ecx+16], xmm1
movntdq [edx+ecx+32], xmm2
movntdq [edx+ecx+48], xmm3
{$IFDEF SSE2Basm}
lddqu xmm4, [eax+ecx+64]
lddqu xmm5, [eax+ecx+80]
lddqu xmm6, [eax+ecx+96]
lddqu xmm7, [eax+ecx+112]
{$ELSE}
DB $F2,$0F,$F0,$64,$01,$40
DB $F2,$0F,$F0,$6C,$01,$50
DB $F2,$0F,$F0,$74,$01,$60
DB $F2,$0F,$F0,$7C,$01,$70
{$ENDIF}
movntdq [edx+ecx+64], xmm4
movntdq [edx+ecx+80], xmm5
movntdq [edx+ecx+96], xmm6
movntdq [edx+ecx+112], xmm7
add ecx, 128
js @@Loop
sfence
end; {HugeUnalignedSSE3Move}

{-------------------------------------------------------------------------}
{Dest MUST be 16-Byes Aligned, Count MUST be multiple of 16 }
procedure LargeSSE3Move(const Source; var Dest; Count: Integer);
asm
push ebx
mov ebx, ecx
and ecx, -128 {No of Bytes to Block Move (Multiple of 128)}
add eax, ecx {End of Source Blocks}
add edx, ecx {End of Dest Blocks}
neg ecx
cmp ecx, CacheLimit {Count > Limit - Use Prefetch}
jl @@Huge
test eax, 15 {Check if Both Source/Dest are Aligned}
jnz @@LargeUnaligned
call LargeAlignedSSE2Move {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@LargeUnaligned: {Source Not 16-Byte Aligned}
call LargeUnalignedSSE3Move
jmp @@Remainder
@@Huge:
test eax, 15 {Check if Both Source/Dest Aligned}
jnz @@HugeUnaligned
call HugeAlignedSSE2Move {Both Source and Dest 16-Byte Aligned}
jmp @@Remainder
@@HugeUnaligned: {Source Not 16-Byte Aligned}
call HugeUnalignedSSE3Move
@@Remainder:
and ebx, $7F {Remainder (0..112 - Multiple of 16)}
jz @@Done
add eax, ebx
add edx, ebx
neg ebx
@@RemainderLoop:
{$IFDEF SSE2Basm}
lddqu xmm0, [eax+ebx]
{$ELSE}
DB $F2,$0F,$F0,$04,$03
{$ENDIF}
movdqa [edx+ebx], xmm0
add ebx, 16
jnz @@RemainderLoop
@@Done:
pop ebx
end; {LargeSSE3Move}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX > EDX and ECX > 36 (TINYSIZE)}
procedure Forwards_SSE3_10;
const
SMALLSIZE = 64;
LARGESIZE = 2048;
asm
cmp ecx, SMALLSIZE
jle Forwards_IA32_10
push ebx
cmp ecx, LARGESIZE
jge @@FwdLargeMove
{$IFDEF SSE2Basm}
lddqu xmm0, [eax] {First 16 Bytes}
{$ELSE}
DB $F2,$0F,$F0,$00
{$ENDIF}
mov ebx, edx
add eax, ecx {Align Writes}
add ecx, edx
and edx, -16
add edx, 48
sub ecx, edx
add edx, ecx
neg ecx
@@FwdLoopSSE3:
{$IFDEF SSE2Basm}
lddqu xmm1, [eax+ecx-32]
lddqu xmm2, [eax+ecx-16]
{$ELSE}
DB $F2,$0F,$F0,$4C,$01,$E0
DB $F2,$0F,$F0,$54,$01,$F0
{$ENDIF}
movdqa [edx+ecx-32], xmm1
movdqa [edx+ecx-16], xmm2
add ecx, 32
jle @@FwdLoopSSE3
movdqu [ebx], xmm0 {First 16 Bytes}
neg ecx
add ecx, 32
pop ebx
jmp SmallForwardMove_10
@@FwdLargeMove:
mov ebx, ecx
test edx, 15
jz @@FwdLargeAligned
lea ecx, [edx+15] {16 byte Align Destination}
and ecx, -16
sub ecx, edx
add eax, ecx
add edx, ecx
sub ebx, ecx
call SmallForwardMove_10
mov ecx, ebx
@@FwdLargeAligned:
and ecx, -16
sub ebx, ecx {EBX = Remainder}
push edx
push eax
push ecx
call LargeSSE3Move
pop ecx
pop eax
pop edx
add ecx, ebx
add eax, ecx
add edx, ecx
mov ecx, ebx
pop ebx
jmp SmallForwardMove_10
end; {Forwards_SSE3}

{-------------------------------------------------------------------------}
{Move ECX Bytes from EAX to EDX, where EAX < EDX and ECX > 36 (TINYSIZE)}
procedure Backwards_SSE3_10;
const
SMALLSIZE = 64;
asm
cmp ecx, SMALLSIZE
jle Backwards_IA32_10
push ebx
{$IFDEF SSE2Basm}
lddqu xmm0, [eax+ecx-16] {Last 16 Bytes}
{$ELSE}
DB $F2,$0F,$F0,$44,$01,$F0
{$ENDIF}
lea ebx, [edx+ecx] {Align Writes}
and ebx, 15
sub ecx, ebx
add ebx, ecx
sub ecx, 32
add edi, 0 {3-Byte NOP Equivalent to Align Loop}
@@BwdLoop:
{$IFDEF SSE2Basm}
lddqu xmm1, [eax+ecx]
lddqu xmm2, [eax+ecx+16]
{$ELSE}
DB $F2,$0F,$F0,$0C,$01
DB $F2,$0F,$F0,$54,$01,$10
{$ENDIF}
movdqa [edx+ecx], xmm1
movdqa [edx+ecx+16], xmm2
sub ecx, 32
jge @@BwdLoop
movdqu [edx+ebx-16], xmm0 {Last 16 Bytes}
add ecx, 32
pop ebx
jmp SmallBackwardMove_10
end; {Backwards_SSE3}

{-------------------------------------------------------------------------}
{Move using IA32 Instruction Set Only}
procedure MoveJOH_IA32_10(const Source; var Dest; Count : Integer);
asm
cmp ecx, TINYSIZE
ja @@Large {Count > TINYSIZE or Count < 0}
cmp eax, edx
jbe @@SmallCheck
add eax, ecx
add edx, ecx
jmp SmallForwardMove_10
@@SmallCheck:
jne SmallBackwardMove_10
ret {For Compatibility with Delphi's move for Source = Dest}
@@Large:
jng @@Done {For Compatibility with Delphi's move for Count < 0}
cmp eax, edx
ja Forwards_IA32_10
je @@Done {For Compatibility with Delphi's move for Source = Dest}
sub edx, ecx
cmp eax, edx
lea edx, [edx+ecx]
jna Forwards_IA32_10
jmp Backwards_IA32_10 {Source/Dest Overlap}
@@Done:
end; {MoveJOH_IA32}

{-------------------------------------------------------------------------}
{Move using MMX Instruction Set}
procedure MoveJOH_MMX_10(const Source; var Dest; Count : Integer);
asm
cmp ecx, TINYSIZE
ja @@Large {Count > TINYSIZE or Count < 0}
cmp eax, edx
jbe @@SmallCheck
add eax, ecx
add edx, ecx
jmp SmallForwardMove_10
@@SmallCheck:
jne SmallBackwardMove_10
ret {For Compatibility with Delphi's move for Source = Dest}
@@Large:
jng @@Done {For Compatibility with Delphi's move for Count < 0}
cmp eax, edx
ja Forwards_MMX_10
je @@Done {For Compatibility with Delphi's move for Source = Dest}
sub edx, ecx
cmp eax, edx
lea edx, [edx+ecx]
jna Forwards_MMX_10
jmp Backwards_MMX_10 {Source/Dest Overlap}
@@Done:
end; {MoveJOH_MMX}

{-------------------------------------------------------------------------}
{Move using SSE Instruction Set}
procedure MoveJOH_SSE_10(const Source; var Dest; Count : Integer);
asm
cmp ecx, TINYSIZE
ja @@Large {Count > TINYSIZE or Count < 0}
cmp eax, edx
jbe @@SmallCheck
add eax, ecx
add edx, ecx
jmp SmallForwardMove_10
@@SmallCheck:
jne SmallBackwardMove_10
ret {For Compatibility with Delphi's move for Source = Dest}
@@Large:
jng @@Done {For Compatibility with Delphi's move for Count < 0}
cmp eax, edx
ja Forwards_SSE_10
je @@Done {For Compatibility with Delphi's move for Source = Dest}
sub edx, ecx
cmp eax, edx
lea edx, [edx+ecx]
jna Forwards_SSE_10
jmp Backwards_SSE_10 {Source/Dest Overlap}
@@Done:
end; {MoveJOH_SSE}

{-------------------------------------------------------------------------}
{Move using SSE2 Instruction Set}
procedure MoveJOH_SSE2_10(const Source; var Dest; Count : Integer);
asm
cmp ecx, TINYSIZE
ja @@Large {Count > TINYSIZE or Count < 0}
cmp eax, edx
jbe @@SmallCheck
add eax, ecx
add edx, ecx
jmp SmallForwardMove_10
@@SmallCheck:
jne SmallBackwardMove_10
ret {For Compatibility with Delphi's move for Source = Dest}
@@Large:
jng @@Done {For Compatibility with Delphi's move for Count < 0}
cmp eax, edx
ja Forwards_SSE2_10
je @@Done {For Compatibility with Delphi's move for Source = Dest}
sub edx, ecx
cmp eax, edx
lea edx, [edx+ecx]
jna Forwards_SSE2_10
jmp Backwards_SSE2_10 {Source/Dest Overlap}
@@Done:
end; {MoveJOH_SSE2}

{-------------------------------------------------------------------------}
{Move using SSE3 Instruction Set}
procedure MoveJOH_SSE3_10(const Source; var Dest; Count : Integer);
asm
cmp ecx, TINYSIZE
ja @@Large {Count > TINYSIZE or Count < 0}
cmp eax, edx
jbe @@SmallCheck
add eax, ecx
add edx, ecx
jmp SmallForwardMove_10
@@SmallCheck:
jne SmallBackwardMove_10
ret {For Compatibility with Delphi's move for Source = Dest}
@@Large:
jng @@Done {For Compatibility with Delphi's move for Count < 0}
cmp eax, edx
ja Forwards_SSE3_10
je @@Done {For Compatibility with Delphi's move for Source = Dest}
sub edx, ecx
cmp eax, edx
lea edx, [edx+ecx]
jna Forwards_SSE3_10
jmp Backwards_SSE3_10 {Source/Dest Overlap}
@@Done:
end; {MoveJOH_SSE3}

{-------------------------------------------------------------------------}

{$IFDEF PurePascal}

procedure PatchMove; {Patch System.Move to Divert Calls to New Move Procedure}
const
JumpFarId = $E9;
var
Protect, OldProtect : DWORD;
begin
VirtualProtect(@System.Move, 256, PAGE_EXECUTE_READWRITE, @OldProtect);
if PByte(@System.Move)^ <> JumpFarId then {Check if Already Patched}
begin
PByte(@System.Move)^ := JumpFarId;
PInteger(Integer(@System.Move)+1)^ :=
Integer(@Move) - Integer(@System.Move)-5; {Change Destination}
end;
VirtualProtect(@System.Move, 256, OldProtect, @Protect);
FlushInstructionCache(GetCurrentProcess, @System.Move, 256);
end; {PatchMove}

{$ELSE}

procedure PatchMove; {Overwrite System.Move with Main Procedure of New Move}
const
JumpFarId = $E9;
JumpPtrId = $25FF;
type {Jump Positions in Move Prodedures Above - Really Horrible but it Works}
NewMoveType = packed record {Size = 56 Bytes, System.Move Size = 64 Bytes}
Padding1 : array[1..14] of Byte;
Jump1Dest : Integer; {jmp SmallForwardMove}
Padding2 : array[1.. 2] of Byte;
Jump2Dest : Integer; {jmp SmallBackwardMove}
Padding3 : array[1.. 7] of Byte;
Jump3Dest : Integer; {jg Forwards_XXX}
Padding4 : array[1..11] of Byte;
Jump4Dest : Integer; {jg Backwards_XXX}
Padding5 : array[1.. 1] of Byte;
Jump5Dest : Integer; {jmp Forwards_XXX}
Padding6 : array[1.. 1] of Byte;
end;
var
I, Offset : Integer;
Src, Dest : PByteArray;
NewMove : NewMoveType;
Protect,
OldProtect : DWORD;
begin
VirtualProtect(@System.Move, 256, PAGE_EXECUTE_READWRITE, @OldProtect);
if PByte(@System.Move)^ <> JumpFarId then {Check if Already Patched}
if PWord(@System.Move)^ = JumpPtrId then
begin {System.Move Starts JMP DWORD PTR [XXXXXXXX] (ie. Using Packages)}
PByte(@System.Move)^ := JumpFarId;
PInteger(Integer(@System.Move)+1)^ :=
Integer(@Move) - Integer(@System.Move)-5; {Change Destination}
end
else
begin {Patch System.Move. Adjust Jump Destinations in Copied Procedure}
Move(Pointer(@Move)^, NewMove, SizeOf(NewMove));
Offset := Integer(@Move) - Integer(@System.Move);
Inc(NewMove.Jump1Dest, Offset);
Inc(NewMove.Jump2Dest, Offset);
Inc(NewMove.Jump3Dest, Offset);
Inc(NewMove.Jump4Dest, Offset);
Inc(NewMove.Jump5Dest, Offset);
Src := @NewMove;
Dest := @System.Move;
for I := 0 to SizeOf(NewMove) - 1 do
Dest[I] := Src[I]; {Overwrite System.Move}
end;
VirtualProtect(@System.Move, 256, OldProtect, @Protect);
FlushInstructionCache(GetCurrentProcess, @System.Move, SizeOf(NewMove));
end; {PatchMove}

{$ENDIF}

initialization
{$IFDEF PurePascal}
Move := MoveJOH_PAS_10;
{$ELSE}
if isSSE3 in CPU.InstructionSupport then
Move := MoveJOH_SSE3_10 {Processor Supports SSE3}
else
if isSSE2 in CPU.InstructionSupport then
Move := MoveJOH_SSE2_10 {Processor Supports SSE2}
else
if isSSE in CPU.InstructionSupport then
Move := MoveJOH_SSE_10 {Processor Supports SSE}
else
if isMMX in CPU.InstructionSupport then
Move := MoveJOH_MMX_10 {Processor Supports MMX}
else
Move := MoveJOH_IA32_10; {Processor does not Support MMX or SSE}
CacheLimit := CPU.L2CacheSize * -512; {Used within SSE Based Moves}
{$ENDIF}
{$IFDEF PatchSystemMove}
PatchMove; {Patch Delphi's System.Move}
{$ENDIF}
end.