sl@0: // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // e32\klib\x86\cumem.cia
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <x86.h>
sl@0: 
sl@0: extern "C" {
sl@0: 
sl@0: __NAKED__ void CopyInterSeg()
sl@0: //
sl@0: // Copy ECX bytes from DS:ESI to ES:EDI
sl@0: // Modifies EAX, EBX, ECX, EDX, ESI, EDI
sl@0: //
sl@0: 	{
sl@0: 	asm("pushfd");
sl@0: 	asm("cld");				// assume forward copy initially
sl@0: 	asm("test ecx,ecx");	//
sl@0: 	asm("jz short memcopy0");// if length=0, nothing to do
sl@0: 	asm("xor edx,edx");		//
sl@0: 	asm("cmp edi,esi");		// compare source and dest addresses
sl@0: 	asm("jc short memcopy1");// if dest<source, must go forwards
sl@0: 	asm("std");				// else go backwards
sl@0: 	asm("add esi,ecx");		// and start at end of block
sl@0: 	asm("add edi,ecx");		//
sl@0: 	asm("inc edx");			// edx=1 if backwards, 0 if forwards
sl@0: 	asm("memcopy1:");
sl@0: 	asm("cmp ecx,16");		// if length<16 don't bother with alignment check
sl@0: 	asm("jc short memcopy2");//
sl@0: 	asm("mov ebx,edi");		// ebx = destination address
sl@0: 	asm("and ebx,3");		// ebx bottom 2 bits = alignment of destination wrt hardware bus
sl@0: 	asm("jz short memcopy3");// if aligned, proceed with block move
sl@0: 	asm("or edx,edx");		// check direction of move
sl@0: 	asm("jnz short memcopy4");// if backwards, ebx = number of byte moves to align destination
sl@0: 	asm("neg ebx");			// else number of byte moves = 4-ebx
sl@0: 	asm("add ebx,4");		//
sl@0: 	asm("memcopy4:");
sl@0: 	asm("sub ecx,ebx");		// subtract number of bytes from length
sl@0: 	asm("xchg ecx,ebx");	// temporarily put length in ebx
sl@0: 	asm("sub edi,edx");		// adjust if backwards move
sl@0: 	asm("sub esi,edx");		//
sl@0: 	asm("rep movsb");		// move bytes to align destination
sl@0: 	asm("add edi,edx");		// adjust if backwards move
sl@0: 	asm("add esi,edx");		//
sl@0: 	asm("mov ecx,ebx");		// length back into ecx
sl@0: 	asm("memcopy3:");
sl@0: 	asm("mov ebx,ecx");		// save length in ebx
sl@0: 	asm("shl edx,2");		// adjustment 4 for backwards move
sl@0: 	asm("shr ecx,2");		// number of dwords to move into ecx
sl@0: 	asm("sub edi,edx");		// adjust if backwards move
sl@0: 	asm("sub esi,edx");		//
sl@0: 	asm("rep movsd");		// perform DWORD block move
sl@0: 	asm("add edi,edx");		// adjust if backwards move
sl@0: 	asm("add esi,edx");		//
sl@0: 	asm("mov ecx,ebx");		// length back into ecx
sl@0: 	asm("and ecx,3");		// number of remaining bytes to move
sl@0: 	asm("jz short memcopy0");// if zero, we are finished
sl@0: 	asm("shr edx,2");		// adjustment 1 for backwards move
sl@0: 	asm("memcopy2:");		// *** come here for small move
sl@0: 	asm("sub edi,edx");		// adjust if backwards move
sl@0: 	asm("sub esi,edx");		//
sl@0: 	asm("rep movsb");		// move remaining bytes
sl@0: 	asm("memcopy0:");
sl@0: 	asm("popfd");
sl@0: 	asm("ret");				// finished - return value in EAX
sl@0: 	}
sl@0: 
sl@0: __NAKED__ void CopyInterSeg32()
sl@0: //
sl@0: // Copy ECX bytes from DS:ESI to ES:EDI
sl@0: // ECX, ESI and EDI are all multiples of 4
sl@0: // Modifies EAX, EBX, ECX, EDX, ESI, EDI
sl@0: //
sl@0: 	{
sl@0: 	asm("pushfd");
sl@0: 	asm("cld");				//
sl@0: 	asm("test ecx,ecx");	//
sl@0: 	asm("jz short memmove0");// if length=0, nothing to do
sl@0: 	asm("cmp edi,esi");		// compare source and dest addresses
sl@0: 	asm("jc short memmove1");// if dest<source, must go forwards
sl@0: 	asm("std");				// else go backwards
sl@0: 	asm("lea esi,[esi+ecx-4]");	// and start at end of block - 4
sl@0: 	asm("lea edi,[edi+ecx-4]");	//
sl@0: 	asm("memmove1:");
sl@0: 	asm("shr ecx,2");		// ecx now contains number of dwords to move
sl@0: 	asm("rep movsd");		// do dword block move
sl@0: 	asm("memmove0:");
sl@0: 	asm("popfd");
sl@0: 	asm("ret");				// finished - return value in EAX
sl@0: 	}
sl@0: 
sl@0: __NAKED__ void FillInterSeg()
sl@0: //
sl@0: // Fill ECX bytes at ES:EDI with AL
sl@0: // Modifies EAX, ECX, EDX, EDI
sl@0: //
sl@0: 	{
sl@0: 	asm("pushfd");
sl@0: 	asm("cld");				// go forwards through array
sl@0: 	asm("test ecx,ecx");	//
sl@0: 	asm("jz short memfill0");// if length zero, nothing to do
sl@0: 	asm("cmp ecx,8");			// if array very small, just do byte fills
sl@0: 	asm("jb short memfill1");
sl@0: 
sl@0: 	asm("mov ah,al");		// repeat al in all bytes of eax
sl@0: 	asm("movzx edx,ax");	//
sl@0: 	asm("shl eax,16");		//
sl@0: 	asm("or eax,edx");		//
sl@0: 	asm("mov edx,ecx");		// length into edx
sl@0: 	// ecx = number of byte fills to align = 4-(edi mod 4)
sl@0: 	asm("mov ecx,4");		
sl@0: 	asm("sub ecx,edi");		//
sl@0: 	asm("and ecx,3");		//
sl@0: 	asm("jz short memfill2");// if already aligned, proceed to dword fill
sl@0: 	asm("sub edx,ecx");		// subtract alignment bytes from length
sl@0: 	asm("rep stosb");		// do byte fills to align
sl@0: 	asm("memfill2:");
sl@0: 	asm("mov ecx,edx");		// length remaining into ecx
sl@0: 	asm("shr ecx,2");		// number of dwords to fill into ecx
sl@0: 	asm("rep stosd");		// perform dword fill
sl@0: 	asm("mov ecx,edx");		// calculate number of leftover bytes
sl@0: 	asm("and ecx,3");		// in ecx
sl@0: 	asm("jz short memfill0");// if none left, exit
sl@0: 	asm("memfill1:");
sl@0: 	asm("rep stosb");		// do byte fills to make up correct length
sl@0: 	asm("memfill0:");
sl@0: 	asm("popfd");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Reads the current thread's memory space with appropriate permissions.
sl@0: 
sl@0: Performs a memcpy(aKernAddr, aAddr, aLength).
sl@0: The reads are performed	using requestor privilege level from GS, ie equal
sl@0: to the privilege level of the caller of the Exec:: function.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aKernAddr	Destination address in kernel memory.
sl@0: @param	aAddr		Source address in kernel or user memory.
sl@0: @param	aLength		Number of bytes to copy.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void kumemget(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg));
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Reads the current thread's memory space with user permissions.
sl@0: 
sl@0: Performs a memcpy(aKernAddr, aUserAddr, aLength).
sl@0: The reads are performed with ring 3 RPL.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aKernAddr	Destination address in kernel memory.
sl@0: @param	aUserAddr	Source address in user memory.
sl@0: @param	aLength		Number of bytes to copy.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void umemget(TAny* /*aKernAddr*/, const TAny* /*aUserAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov eax, %0": : "i"(RING3_DS));
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg));
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Does a word-aligned read of the current thread's memory space with appropriate permissions.
sl@0: 
sl@0: Performs a memcpy(aKernAddr, aAddr, aLength).
sl@0: The reads are performed	using requestor privilege level from GS, ie equal
sl@0: to the privilege level of the caller of the Exec:: function.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aKernAddr	Destination address in kernel memory, must be 4-byte aligned.
sl@0: @param	aAddr		Source address in kernel or user memory, must be 4-byte aligned.
sl@0: @param	aLength		Number of bytes to copy, must be a multiple of 4.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void kumemget32(TAny* /*aKernAddr*/, const TAny* /*aAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg32));
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Does a word-aligned read of the current thread's memory space with user permissions.
sl@0: 
sl@0: Performs a memcpy(aKernAddr, aUserAddr, aLength).
sl@0: The reads are performed with ring 3 RPL.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aKernAddr	Destination address in kernel memory, must be 4-byte aligned.
sl@0: @param	aUserAddr	Source address in user memory, must be 4-byte aligned.
sl@0: @param	aLength		Number of bytes to copy, must be a multiple of 4.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void umemget32(TAny* /*aKernAddr*/, const TAny* /*aUserAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov eax, %0": : "i"(RING3_DS));
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg32));
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Writes to the current thread's memory space with appropriate permissions.
sl@0: 
sl@0: Performs a memcpy(aAddr, aKernAddr, aLength).
sl@0: The writes are performed using requestor privilege level from GS, ie equal
sl@0: to the privilege level of the caller of the Exec:: function.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aAddr		Destination address in kernel or user memory.
sl@0: @param	aKernAddr	Source address in kernel memory.
sl@0: @param	aLength		Number of bytes to copy.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void kumemput(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Writes to the current thread's memory space with user permissions.
sl@0: 
sl@0: Performs a memcpy(aAddr, aKernAddr, aLength).
sl@0: The writes are performed with ring 3 RPL.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aUserAddr	Destination address in user memory.
sl@0: @param	aKernAddr	Source address in kernel memory.
sl@0: @param	aLength		Number of bytes to copy.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void umemput(TAny* /*aUserAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov eax, %0": : "i"(RING3_DS));
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Does a word-aligned write to the current thread's memory space with appropriate permissions.
sl@0: 
sl@0: Performs a memcpy(aAddr, aKernAddr, aLength).
sl@0: The writes are performed using requestor privilege level from GS, ie equal
sl@0: to the privilege level of the caller of the Exec:: function.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aAddr		Destination address in kernel or user memory, must be 4-byte aligned.
sl@0: @param	aKernAddr	Source address in kernel memory, must be 4-byte aligned.
sl@0: @param	aLength		Number of bytes to copy, must be a multiple of 4.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void kumemput32(TAny* /*aAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg32));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Does a word-aligned write to the current thread's memory space with user permissions.
sl@0: 
sl@0: Performs a memcpy(aAddr, aKernAddr, aLength).
sl@0: The writes are performed with ring 3 RPL.
sl@0: Note that source and destination areas may not overlap.
sl@0: 
sl@0: @param	aUserAddr	Destination address in user memory, must be 4-byte aligned.
sl@0: @param	aKernAddr	Source address in kernel memory, must be 4-byte aligned.
sl@0: @param	aLength		Number of bytes to copy, must be a multiple of 4.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void umemput32(TAny* /*aUserAddr*/, const TAny* /*aKernAddr*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+20]");
sl@0: 	asm("mov esi, [esp+24]");
sl@0: 	asm("mov ecx, [esp+28]");
sl@0: 	asm("mov eax, %0": : "i"(RING3_DS));
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg32));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Fills the current thread's memory space with appropriate permissions.
sl@0: 
sl@0: Performs a memset(aAddr, aValue, aLength).
sl@0: The writes are performed using requestor privilege level from GS, ie equal
sl@0: to the privilege level of the caller of the Exec:: function.
sl@0: 
sl@0: @param	aAddr		Destination address in kernel or user memory.
sl@0: @param	aValue		Value to write to each byte.
sl@0: @param	aLength		Number of bytes to fill.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void kumemset(TAny* /*aAddr*/, const TUint8 /*aValue*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+12]");
sl@0: 	asm("mov eax, [esp+16]");
sl@0: 	asm("mov ecx, [esp+20]");
sl@0: 	asm("mov dx, gs");
sl@0: 	asm("mov es, dx");
sl@0: 	asm("call %a0": :"i"(&FillInterSeg));
sl@0: 	asm("pop es");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**	Fills the current thread's memory space with user permissions.
sl@0: 
sl@0: Performs a memset(aUserAddr, aValue, aLength).
sl@0: The writes are performed with ring 3 RPL.
sl@0: 
sl@0: @param	aUserAddr	Destination address in user memory.
sl@0: @param	aValue		Value to write to each byte.
sl@0: @param	aLength		Number of bytes to fill.
sl@0: 
sl@0: @pre    Call in a thread context.
sl@0: @pre    Kernel must be unlocked.
sl@0: @pre	Must be called under an XTRAP harness, or calling thread must not be
sl@0: in a critical section.
sl@0: */
sl@0: EXPORT_C __NAKED__ void umemset(TAny* /*aUserAddr*/, const TUint8 /*aValue*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+12]");
sl@0: 	asm("mov eax, [esp+16]");
sl@0: 	asm("mov ecx, [esp+20]");
sl@0: 	asm("mov edx, %0": : "i"(RING3_DS));
sl@0: 	asm("mov es, dx");
sl@0: 	asm("call %a0": :"i"(&FillInterSeg));
sl@0: 	asm("pop es");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: __NAKED__ void uumemcpy32(TAny* /*aUserDst*/, const TAny* /*aUserSrc*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+24]");
sl@0: 	asm("mov esi, [esp+28]");
sl@0: 	asm("mov ecx, [esp+32]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg32));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: __NAKED__ void uumemcpy(TAny* /*aUserDst*/, const TAny* /*aUserSrc*/, TInt /*aLength*/)
sl@0: 	{
sl@0: 	asm("push edi");
sl@0: 	asm("push esi");
sl@0: 	asm("push ebx");
sl@0: 	asm("push ds");
sl@0: 	asm("push es");
sl@0: 	asm("mov edi, [esp+24]");
sl@0: 	asm("mov esi, [esp+28]");
sl@0: 	asm("mov ecx, [esp+32]");
sl@0: 	asm("mov ax, gs");
sl@0: 	asm("mov ds, ax");
sl@0: 	asm("mov es, ax");
sl@0: 	asm("call %a0": : "i"(&CopyInterSeg));
sl@0: 	asm("pop es");
sl@0: 	asm("pop ds");
sl@0: 	asm("pop ebx");
sl@0: 	asm("pop esi");
sl@0: 	asm("pop edi");
sl@0: 	asm("ret");
sl@0: 	}
sl@0: 
sl@0: }