// 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");
	}

}