// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\common\x86\x86hlp_gcc.inl

// If there are no exports then GCC 3.4.x does not generate a .reloc 

// section, without which rombuild can't relocate the .code section

// to its ROM address. Your ROM then goes boom early in the boot sequence.

// This unused export forces the PE to be generated with a .reloc section.

// 

//

EXPORT_C void __ignore_this_export()

	{

	}

static void DivisionByZero()

	{

	asm("int 0");

	}

extern "C" {

void __NAKED__ _alloca()

{

	// GCC passes the param in eax and expects no return value

	asm("pop ecx");

	asm("sub esp, eax");

	asm("push ecx");

	asm("ret");

}

void __NAKED__ _allmul()

//

// Multiply two 64 bit integers returning a 64 bit result

// On entry:

//		[esp+4], [esp+8] = arg 1

//		[esp+12], [esp+16] = arg 1

// Return result in edx:eax

// Remove arguments from stack

//

	{

	asm("mov eax, [esp+4]");		// eax = low1

	asm("mul dword ptr [esp+16]");	// edx:eax = low1*high2

	asm("mov ecx, eax");			// keep low 32 bits of product

	asm("mov eax, [esp+8]");		// eax = high1

	asm("mul dword ptr [esp+12]");	// edx:eax = high1*low2

	asm("add ecx, eax");			// accumulate low 32 bits of product

	asm("mov eax, [esp+4]");		// eax = low1

	asm("mul dword ptr [esp+12]");	// edx:eax = low1*low2

	asm("add edx, ecx");			// add cross terms to high 32 bits

	asm("ret");

	}

void __NAKED__ udiv64_divby0()

	{

	asm("int 0");					// division by zero exception

	asm("ret");

	}

__NAKED__ /*LOCAL_C*/ void UDiv64()

	{

	// unsigned divide edx:eax by edi:esi

	// quotient in ebx:eax, remainder in edi:edx

	// ecx, ebp, esi also modified

	asm("test edi, edi");

	asm("jnz short UDiv64a");			// branch if divisor >= 2^32

	asm("test esi, esi");

	asm("jz %a0": : "i"(&DivisionByZero)); // if divisor=0, branch to error routine

	asm("mov ebx, eax");				// ebx=dividend low

	asm("mov eax, edx");				// eax=dividend high

	asm("xor edx, edx");				// edx=0

	asm("div esi");						// quotient high now in eax

	asm("xchg eax, ebx");				// quotient high in ebx, dividend low in eax

	asm("div esi");						// quotient now in ebx:eax, remainder in edi:edx

	asm("ret");

	asm("UDiv64e:");

	asm("xor eax, eax");				// set result to 0xFFFFFFFF

	asm("dec eax");

	asm("jmp short UDiv64f");

	asm("UDiv64a:");

	asm("js short UDiv64b");			// skip if divisor msb set

	asm("bsr ecx, edi");				// ecx=bit number of divisor msb - 32

	asm("inc cl");

	asm("push edi");					// save divisor high

	asm("push esi");					// save divisor low

	asm("shrd esi, edi, cl");			// shift divisor right so that msb is bit 31

	asm("mov ebx, edx");				// dividend into ebx:ebp

	asm("mov ebp, eax");

	asm("shrd eax, edx, cl");			// shift dividend right same number of bits

	asm("shr edx, cl");

	asm("cmp edx, esi");				// check if approx quotient will be 2^32

	asm("jae short UDiv64e");			// if so, true result must be 0xFFFFFFFF

	asm("div esi");						// approximate quotient now in eax

	asm("UDiv64f:");

	asm("mov ecx, eax");				// into ecx

	asm("mul edi");						// multiply approx. quotient by divisor high

	asm("mov esi, eax");				// ls dword into esi, ms into edi

	asm("mov edi, edx");

	asm("mov eax, ecx");				// approx. quotient into eax

	asm("mul dword ptr [esp]");			// multiply approx. quotient by divisor low

	asm("add edx, esi");				// edi:edx:eax now equals approx. quotient * divisor

	asm("adc edi, 0");

	asm("xor esi, esi");

	asm("sub ebp, eax");				// subtract dividend - approx. quotient *divisor

	asm("sbb ebx, edx");

	asm("sbb esi, edi");

	asm("jnc short UDiv64c");			// if no borrow, result OK

	asm("dec ecx");						// else result is one too big

	asm("add ebp, [esp]");				// and add divisor to get correct remainder

	asm("adc ebx, [esp+4]");

	asm("UDiv64c:");

	asm("mov eax, ecx");				// result into ebx:eax, remainder into edi:edx

	asm("mov edi, ebx");

	asm("mov edx, ebp");

	asm("xor ebx, ebx");

	asm("add esp, 8");					// remove temporary values from stack

	asm("ret");

	asm("UDiv64b:");

	asm("mov ebx, 1");

	asm("sub eax, esi");				// subtract divisor from dividend

	asm("sbb edx, edi");

	asm("jnc short UDiv64d");			// if no borrow, result=1, remainder in edx:eax

	asm("add eax, esi");				// else add back

	asm("adc edx, edi");

	asm("dec ebx");						// and decrement quotient

	asm("UDiv64d:");

	asm("mov edi, edx");				// remainder into edi:edx

	asm("mov edx, eax");

	asm("mov eax, ebx");				// result in ebx:eax

	asm("xor ebx, ebx");

	asm("ret");

	}

__NAKED__ void _aulldvrm()

//

// Divide two 64 bit unsigned integers, returning a 64 bit result

// and a 64 bit remainder

//

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

//

// Return (dividend / divisor) in edx:eax

// Return (dividend % divisor) in ebx:ecx

//

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("mov eax, [esp+16]");

	asm("mov edx, [esp+20]");

	asm("mov esi, [esp+24]");

	asm("mov edi, [esp+28]");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov ecx, edx");

	asm("mov edx, ebx");

	asm("mov ebx, edi");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

__NAKED__ void _alldvrm()

//

// Divide two 64 bit signed integers, returning a 64 bit result

// and a 64 bit remainder

//

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

//

// Return (dividend / divisor) in edx:eax

// Return (dividend % divisor) in ebx:ecx

//

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("mov eax, [esp+16]");

	asm("mov edx, [esp+20]");

	asm("mov esi, [esp+24]");

	asm("mov edi, [esp+28]");

	asm("test edx, edx");

	asm("jns alldrvm_dividend_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("alldrvm_dividend_nonnegative:");

	asm("test edi, edi");

	asm("jns alldrvm_divisor_nonnegative");

	asm("neg edi");

	asm("neg esi");

	asm("sbb edi, 0");

	asm("alldrvm_divisor_nonnegative:");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov ebp, [esp+20]");

	asm("mov ecx, edx");

	asm("xor ebp, [esp+28]");

	asm("mov edx, ebx");

	asm("mov ebx, edi");

	asm("jns alldrvm_quotient_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("alldrvm_quotient_nonnegative:");

	asm("cmp dword ptr [esp+20], 0");

	asm("jns alldrvm_rem_nonnegative");

	asm("neg ebx");

	asm("neg ecx");

	asm("sbb ebx, 0");

	asm("alldrvm_rem_nonnegative:");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

//__NAKED__ void _aulldiv()

__NAKED__ void __udivdi3 ()

//

// Divide two 64 bit unsigned integers returning a 64 bit result

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

// Return result in edx:eax

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("push ebx");

	asm("mov eax, [esp+20]");

	asm("mov edx, [esp+24]");

	asm("mov esi, [esp+28]");

	asm("mov edi, [esp+32]");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov edx, ebx");

	asm("pop ebx");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

__NAKED__ void __divdi3()

//

// Divide two 64 bit signed integers returning a 64 bit result

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

// Return result in edx:eax

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("push ebx");

	asm("mov eax, [esp+20]");

	asm("mov edx, [esp+24]");

	asm("mov esi, [esp+28]");

	asm("mov edi, [esp+32]");

	asm("test edx, edx");

	asm("jns divdi_dividend_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("divdi_dividend_nonnegative:");

	asm("test edi, edi");

	asm("jns divdi_divisor_nonnegative");

	asm("neg edi");

	asm("neg esi");

	asm("sbb edi, 0");

	asm("divdi_divisor_nonnegative:");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov ecx, [esp+24]");

	asm("mov edx, ebx");

	asm("xor ecx, [esp+32]");

	asm("jns divdi_quotient_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("divdi_quotient_nonnegative:");

	asm("pop ebx");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

__NAKED__ void __umoddi3()

//

// Divide two 64 bit unsigned integers and return 64 bit remainder

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

// Return result in edx:eax

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("push ebx");

	asm("mov eax, [esp+20]");

	asm("mov edx, [esp+24]");

	asm("mov esi, [esp+28]");

	asm("mov edi, [esp+32]");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov eax, edx");

	asm("mov edx, edi");

	asm("pop ebx");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

__NAKED__ void __moddi3()

//

// Divide two 64 bit signed integers and return 64 bit remainder

// On entry:

//		[esp+4], [esp+8] = dividend

//		[esp+12], [esp+16] = divisor

// Return result in edx:eax

// Remove arguments from stack

//

	{

	asm("push ebp");

	asm("push edi");

	asm("push esi");

	asm("push ebx");

	asm("mov eax, [esp+20]");

	asm("mov edx, [esp+24]");

	asm("mov esi, [esp+28]");

	asm("mov edi, [esp+32]");

	asm("test edx, edx");

	asm("jns dividend_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("dividend_nonnegative:");

	asm("test edi, edi");

	asm("jns divisor_nonnegative");

	asm("neg edi");

	asm("neg esi");

	asm("sbb edi, 0");

	asm("divisor_nonnegative:");

	asm("call %a0": : "i"(&UDiv64));

	asm("mov eax, edx");

	asm("mov edx, edi");

	asm("cmp dword ptr [esp+24], 0");

	asm("jns rem_nonnegative");

	asm("neg edx");

	asm("neg eax");

	asm("sbb edx, 0");

	asm("rem_nonnegative:");

	asm("pop ebx");

	asm("pop esi");

	asm("pop edi");

	asm("pop ebp");

	asm("ret");

	}

__NAKED__ void _allshr()

//

// Arithmetic shift right EDX:EAX by CL

//

	{

	asm("cmp cl, 64");

	asm("jae asr_count_ge_64");

	asm("cmp cl, 32");

	asm("jae asr_count_ge_32");

	asm("shrd eax, edx, cl");

	asm("sar edx, cl");

	asm("ret");

	asm("asr_count_ge_32:");

	asm("sub cl, 32");

	asm("mov eax, edx");

	asm("cdq");

	asm("sar eax, cl");

	asm("ret");

	asm("asr_count_ge_64:");

	asm("sar edx, 32");

	asm("mov eax, edx");

	asm("ret");

	}

__NAKED__ void _allshl()

//

// shift left EDX:EAX by CL

//

	{

	asm("cmp cl, 64");

	asm("jae lsl_count_ge_64");

	asm("cmp cl, 32");

	asm("jae lsl_count_ge_32");

	asm("shld edx, eax, cl");

	asm("shl eax, cl");

	asm("ret");

	asm("lsl_count_ge_32:");

	asm("sub cl, 32");

	asm("mov edx, eax");

	asm("xor eax, eax");

	asm("shl edx, cl");

	asm("ret");

	asm("lsl_count_ge_64:");

	asm("xor edx, edx");

	asm("xor eax, eax");

	asm("ret");

	}

__NAKED__ void _aullshr()

//

// Logical shift right EDX:EAX by CL

//

	{

	asm("cmp cl, 64");

	asm("jae lsr_count_ge_64");

	asm("cmp cl, 32");

	asm("jae lsr_count_ge_32");

	asm("shrd eax, edx, cl");

	asm("shr edx, cl");

	asm("ret");

	asm("lsr_count_ge_32:");

	asm("sub cl, 32");

	asm("mov eax, edx");

	asm("xor edx, edx");

	asm("shr eax, cl");

	asm("ret");

	asm("lsr_count_ge_64:");

	asm("xor edx, edx");

	asm("xor eax, eax");

	asm("ret");

	}

}