1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
2 // All rights reserved.
3 // This component and the accompanying materials are made available
4 // under the terms of the License "Eclipse Public License v1.0"
5 // which accompanies this distribution, and is available
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
8 // Initial Contributors:
9 // Nokia Corporation - initial contribution.
14 // e32\common\x86\cmem.cia
21 #if defined(__MEM_MACHINE_CODED__)
25 // See header file e32cmn.h for the in-source documentation.
26 EXPORT_C __NAKED__ TAny* memmove(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)
31 asm("mov edi,[esp+16]");// destination address into edi
32 asm("mov esi,[esp+20]");// source address into esi
33 asm("mov ecx,[esp+24]");// byte count into ecx
36 asm("mov eax,edi"); // return value
37 asm("cld"); // assume forward copy initially
38 asm("test ecx,ecx"); //
39 asm("jz short memcopy0");// if length=0, nothing to do
40 asm("xor edx,edx"); //
41 asm("cmp edi,esi"); // compare source and dest addresses
42 asm("je short memcopy0");// if equal, nothing to do
43 asm("jc short memcopy1");// if dest<source, must go forwards
44 asm("std"); // else go backwards
45 asm("add esi,ecx"); // and start at end of block
46 asm("add edi,ecx"); //
47 asm("inc edx"); // edx=1 if backwards, 0 if forwards
49 asm("cmp ecx,16"); // if length<16 don't bother with alignment check
50 asm("jc short memcopy2");//
51 asm("mov ebx,edi"); // ebx = destination address
52 asm("and ebx,3"); // ebx bottom 2 bits = alignment of destination wrt hardware bus
53 asm("jz short memcopy3");// if aligned, proceed with block move
54 asm("or edx,edx"); // check direction of move
55 asm("jnz short memcopy4");// if backwards, ebx = number of byte moves to align destination
56 asm("neg ebx"); // else number of byte moves = 4-ebx
59 asm("sub ecx,ebx"); // subtract number of bytes from length
60 asm("xchg ecx,ebx"); // temporarily put length in ebx
61 asm("sub edi,edx"); // adjust if backwards move
62 asm("sub esi,edx"); //
63 asm("rep movsb"); // move bytes to align destination
64 asm("add edi,edx"); // adjust if backwards move
65 asm("add esi,edx"); //
66 asm("mov ecx,ebx"); // length back into ecx
68 asm("mov ebx,ecx"); // save length in ebx
69 asm("shl edx,2"); // adjustment 4 for backwards move
70 asm("shr ecx,2"); // number of dwords to move into ecx
71 asm("sub edi,edx"); // adjust if backwards move
72 asm("sub esi,edx"); //
73 asm("rep movsd"); // perform DWORD block move
74 asm("add edi,edx"); // adjust if backwards move
75 asm("add esi,edx"); //
76 asm("mov ecx,ebx"); // length back into ecx
77 asm("and ecx,3"); // number of remaining bytes to move
78 asm("jz short memcopy0");// if zero, we are finished
79 asm("shr edx,2"); // adjustment 1 for backwards move
80 asm("memcopy2:"); // *** come here for small move
81 asm("sub edi,edx"); // adjust if backwards move
82 asm("sub esi,edx"); //
83 asm("rep movsb"); // move remaining bytes
90 asm("ret"); // finished - return value in EAX
94 // See header file e32cmn.h for the in-source documentation.
95 EXPORT_C __NAKED__ TAny* memcpy(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)
97 asm("jmp %a0": :"i"(&memmove));
103 // See header file e32cmn.h for the in-source documentation.
104 EXPORT_C __NAKED__ TAny* wordmove(TAny* /*aTrg*/, const TAny* /*aSrc*/, unsigned int /*aLength*/)
108 asm("mov edi,[esp+12]");// destination address into edi
109 asm("mov esi,[esp+16]");// source address into esi
110 asm("mov ecx,[esp+20]");// byte count into ecx
113 asm("mov eax,edi"); // return value
115 asm("test ecx,ecx"); //
116 asm("jz short memmove0");// if length=0, nothing to do
117 asm("cmp edi,esi"); // compare source and dest addresses
118 asm("je short memmove0");// if equal, nothing to do
119 asm("jc short memmove1");// if dest<source, must go forwards
120 asm("std"); // else go backwards
121 asm("lea esi,[esi+ecx-4]"); // and start at end of block - 4
122 asm("lea edi,[edi+ecx-4]"); //
124 asm("shr ecx,2"); // ecx now contains number of dwords to move
125 asm("rep movsd"); // do dword block move
131 asm("ret"); // finished - return value in EAX
136 // See header file e32cmn.h for the in-source documentation.
137 EXPORT_C __NAKED__ TAny* memset(TAny* /*aTrg*/, TInt /*aValue*/, unsigned int /*aLength*/)
140 asm("mov edi,[esp+8]"); // destination address into edi
141 asm("mov al,[esp+12]"); // fill value into al
142 asm("mov ecx,[esp+16]");// number of bytes to fill into ecx
143 asm("push edi"); // save destination for return value
145 asm("cld"); // go forwards through array
146 asm("test ecx,ecx"); //
147 asm("jz short memfill0");// if length zero, nothing to do
148 asm("cmp ecx,8"); // if array very small, just do byte fills
149 asm("jb short memfill1");
151 asm("mov ah,al"); // repeat al in all bytes of eax
152 asm("movzx edx,ax"); //
153 asm("shl eax,16"); //
154 asm("or eax,edx"); //
155 asm("mov edx,ecx"); // length into edx
156 asm("mov ecx,4"); // number of byte fills to align = 4-[edi mod 4]
157 asm("sub ecx,edi"); //
159 asm("jz short memfill2");// if already aligned, proceed to dword fill
160 asm("sub edx,ecx"); // subtract alignment bytes from length
161 asm("rep stosb"); // do byte fills to align
163 asm("mov ecx,edx"); // length remaining into ecx
164 asm("shr ecx,2"); // number of dwords to fill into ecx
165 asm("rep stosd"); // perform dword fill
166 asm("mov ecx,edx"); // calculate number of leftover bytes
167 asm("and ecx,3"); // in ecx
168 asm("jz short memfill0");// if none left, exit
170 asm("rep stosb"); // do byte fills to make up correct length
174 asm("pop eax"); // return value
182 // See header file e32cmn.h for the in-source documentation.
183 EXPORT_C __NAKED__ TAny* memclr(TAny* /*aTrg*/, unsigned int /*aLength*/)
186 asm("mov edi,[esp+8]"); // destination address into edi
187 asm("mov ecx,[esp+12]");// number of bytes to fill into ecx
188 asm("xor eax, eax"); // fill value
189 asm("push edi"); // save destination for return value
191 asm("cld"); // go forwards through array
192 asm("test ecx,ecx"); //
193 asm("jz short memclr0");// if length zero, nothing to do
194 asm("cmp ecx,8"); // if array very small, just do byte fills
195 asm("jb short memclr1");
197 asm("mov edx,ecx"); // length into edx
198 asm("mov ecx,4"); // number of byte fills to align = 4-[edi mod 4]
199 asm("sub ecx,edi"); //
201 asm("jz short memclr2");// if already aligned, proceed to dword fill
202 asm("sub edx,ecx"); // subtract alignment bytes from length
203 asm("rep stosb"); // do byte fills to align
205 asm("mov ecx,edx"); // length remaining into ecx
206 asm("shr ecx,2"); // number of dwords to fill into ecx
207 asm("rep stosd"); // perform dword fill
208 asm("mov ecx,edx"); // calculate number of leftover bytes
209 asm("and ecx,3"); // in ecx
210 asm("jz short memclr0");// if none left, exit
212 asm("rep stosb"); // do byte fills to make up correct length
216 asm("pop eax"); // return value
223 //EXPORT_C __NAKED__ TInt Mem::Compare(const TUint8* /*aLeft*/, TInt /*aLeftL*/, const TUint8* /*aRight*/, TInt /*aRightL*/)
225 // asm("jmp _memcompare");
228 // See header file e32cmn.h for the in-source documentation.
229 EXPORT_C __NAKED__ TInt memcompare(const TUint8* /*aLeft*/, TInt /*aLeftL*/, const TUint8* /*aRight*/, TInt /*aRightL*/)
233 asm("mov esi,[esp+12]");// left buffer address into esi
234 asm("mov ecx,[esp+16]");// left buffer length into ecx
235 asm("mov edi,[esp+20]");// right buffer address into edi
236 asm("mov eax,[esp+24]");// right buffer length into eax
239 asm("mov edx,ecx"); // edx = left len
240 asm("cld"); // go forwards through arrays
241 asm("sub edx,eax"); // edx = [left len - right len]
242 asm("jbe short memcmp1");//
243 asm("mov ecx,eax"); // ecx = min[ left len, right len ]
245 asm("mov eax,edx"); // save length difference for later use
246 asm("test ecx,ecx"); //
247 asm("jz short memcmp0");// if length=0, nothing to compare
248 asm("cmp ecx,8"); // for small buffers don't bother with alignment check
249 asm("jc short memcmp2");//
250 asm("mov edx,ecx"); // comparison length into edx
251 asm("mov ecx,4"); // number of byte compares to align left ptr = 4-[esi mod 4]
252 asm("sub ecx,esi"); //
253 asm("and ecx,3"); // number of byte compares to align in ecx
254 asm("jz short memcmp3");// if already aligned, proceed with dword compare
255 asm("sub edx,ecx"); // subtract number of byte compares from length
256 asm("repe cmpsb"); // do byte compares to align
257 asm("jne short memcmp4");// if a difference was found, exit
259 asm("mov ecx,edx"); // length back into ecx
260 asm("shr ecx,2"); // number of dwords to compare
261 asm("repe cmpsd"); // perform DWORD block comparison
262 asm("je short memcmp5");// if no difference found, proceed with leftover bytes
263 asm("mov eax,[esi-4]"); // differing left dword into eax [first char in al]
264 asm("mov edx,[edi-4]"); // differing right dword into edx [first char in dl]
265 asm("cmp al,dl"); // compare 1st chars
266 asm("jne short memcmp7");// if difference found, exit
267 asm("cmp ah,dh"); // compare 2nd chars
268 asm("jne short memcmp6");// if difference found, exit
269 asm("shr eax,16"); // 3rd and 4th chars into al, ah respectively
270 asm("shr edx,16"); // 3rd and 4th chars into dl, dh respectively
271 asm("cmp al,dl"); // compare 3rd chars
272 asm("jne short memcmp7");// if difference found, exit, else 4th chars must differ
274 asm("mov al,ah"); // differing bytes into al and dl
277 asm("movzx eax,al"); // zero extend al into eax
278 asm("movzx edx,dl"); // zero extend dl into edx
279 asm("jmp short memcmp8");// and exit with eax = difference of bytes
281 asm("mov ecx,edx"); // length back into ecx
282 asm("and ecx,3"); // number of remaining bytes to compare
283 asm("jz short memcmp0");// if zero, exit with eax=length difference
284 asm("memcmp2:"); // *** come here for small buffers
285 asm("repe cmpsb"); // compare remaining bytes
286 asm("je short memcmp0");// if no difference found, exit with eax=length difference
287 asm("memcmp4:"); // *** come here if a byte has been compared and differs
288 asm("movzx eax,byte ptr [esi-1]");
289 asm("movzx edx,byte ptr [edi-1]");
291 asm("sub eax,edx"); // return value is difference of bytes
293 asm("memcmp0:"); // *** come here if common initial segment identical