// 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\nkern\x86\vectors.cia
// 
//

#include <x86.h>
#include "vectors.h"

#ifdef __GCC32__
#define DECLARE_X86_INT(n)			GLDEF_C __NAKED__ void __X86Vector##n() { asm("push 0x"#n);	asm("jmp %a0": :"i"(&__X86VectorIrq)); }
#define DECLARE_X86_EXC_NOERR(n)	GLDEF_C __NAKED__ void __X86Vector##n() { asm("push 0"); asm("push 0x"#n); asm("jmp %a0": : "i"(&__X86VectorExc)); }
#define DECLARE_X86_EXC_ERR(n)		GLDEF_C __NAKED__ void __X86Vector##n() { asm("push 0x"#n); asm("jmp %a0": : "i"(&__X86VectorExc)); }
#else
#define DECLARE_X86_INT(n)			GLDEF_C __NAKED__ void __X86Vector##n() { __asm push 0x##n __asm jmp __X86VectorIrq }
#define DECLARE_X86_EXC_NOERR(n)	GLDEF_C __NAKED__ void __X86Vector##n() { __asm push 0 __asm push 0x##n __asm jmp __X86VectorExc }
#define DECLARE_X86_EXC_ERR(n)		GLDEF_C __NAKED__ void __X86Vector##n() { __asm push 0x##n __asm jmp __X86VectorExc }
#endif

const TLinAddr NKern_WaitForAnyRequest = (TLinAddr)&NKern::WaitForAnyRequest;
const TLinAddr NKern_LockSystem = (TLinAddr)&NKern::LockSystem;
const TLinAddr NKern_UnlockSystem = (TLinAddr)&NKern::UnlockSystem;
const TLinAddr NKern_Unlock = (TLinAddr)&NKern::Unlock;
const TLinAddr TScheduler_Reschedule = (TLinAddr)&TScheduler::Reschedule;

#ifdef __CHECK_LOCK_STATE__
/******************************************************************************
 * Check that the kernel is unlocked, no fast mutex is held and the thread
 * is not in a critical section when returning to user mode.
 ******************************************************************************/
extern "C" __NAKED__ void check_lock_state()
	{
	asm("push ecx ");
	asm("mov ecx, [%a0]" : : "i" (&TheScheduler.iCurrentThread));
	asm("cmp dword ptr [%a0], 0" : : "i" (&TheScheduler.iKernCSLocked));
	asm("jnz short bad_lock_state1 ");
	asm("cmp dword ptr [ecx+%0], 0" : : "i" _FOFF(NThreadBase, iHeldFastMutex));
	asm("jne short bad_lock_state2 ");
	asm("cmp dword ptr [ecx+%0], 0" : : "i" _FOFF(NThreadBase, iCsCount));
	asm("jne short bad_lock_state3 ");
	asm("pop ecx ");
	asm("ret ");
	asm("bad_lock_state1: ");
	asm("int 0xff ");
	asm("bad_lock_state2: ");
	asm("int 0xff ");
	asm("bad_lock_state3: ");
	asm("int 0xff ");
	}
#endif

/******************************************************************************
* Int 20h Handler - Fast Executive Calls
* Enter with:
*		Call number in EAX
*		Parameter in ECX if any
* On entry SS:ESP references current threads supervisor stack
* [ESP+0] = return EIP
* [ESP+4] = return CS
* [ESP+8] = return EFLAGS
* [ESP+12] = return ESP if privilege change occurred
* [ESP+16] = return SS if privilege change occurred
*******************************************************************************/
GLDEF_C __NAKED__ void __X86Vector20()
	{
	// Interrupts enabled on entry
	asm("cld");
	asm("test eax, eax");
	asm("je wait_for_any_request");
	asm("push ds");
	asm("push es");
	asm("push gs");
	asm("push ecx");
	asm("mov cx, ds");
	asm("mov dx, ss");
	asm("mov ds, dx");
	asm("mov gs, cx");
	asm("mov ecx, [%a0]": :"i"(&TheScheduler.iCurrentThread));
	asm("mov es, dx");
	asm("mov edx, [ecx+%0]" : : "i"_FOFF(NThreadBase,iFastExecTable)); 
	asm("cmp eax, [edx]");
	asm("jae fast_exec_invalid");
	asm("cli");
	asm("call [edx+eax*4]");
	asm("add esp, 4");
	asm("fast_exec_exit:");
	asm("test dword ptr [esp+16], 3 ");	// returning to user mode?
	asm("jz short fast_exec_exit2 ");	// no - don't do lock check or user mode callbacks
#ifdef __CHECK_LOCK_STATE__
	asm("call %a0" : : "i" (&check_lock_state));
#endif
	asm("push eax");
#ifdef __GCC32__
	asm("mov ecx, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("push ecx");
	asm("call __ZN11NThreadBase21CallUserModeCallbacksEv ");
	asm("add esp,4"); 
#else
	TheScheduler.iCurrentThread->CallUserModeCallbacks();
#endif	
	asm("pop eax");

	asm("fast_exec_exit2: ");
	asm("pop gs");
	asm("pop es");
	asm("pop ds");
	asm("iretd");

	asm("wait_for_any_request:");
	asm("push ds");
	asm("push es");
	asm("mov cx, ss");
	asm("mov ds, cx");
	asm("mov es, cx");
	asm("call %a0" : : "i" (NKern_WaitForAnyRequest));

	asm("test dword ptr [esp+12], 3 ");	// returning to user mode?
	asm("jz short wfar_exit2 ");		// no - don't do lock check or user mode callbacks
	asm("push eax");
	asm("cli");
#ifdef __GCC32__
	asm("mov ecx, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("push ecx");
	asm("call __ZN11NThreadBase21CallUserModeCallbacksEv");
	asm("add esp,4"); 
#else
	TheScheduler.iCurrentThread->CallUserModeCallbacks();
#endif	
	asm("pop eax");
#ifdef __CHECK_LOCK_STATE__
	asm("call %a0" : : "i" (&check_lock_state));
#endif

	asm("wfar_exit2: ");
	asm("pop es");
	asm("pop ds");
	asm("iretd");

	asm("fast_exec_invalid:");
	asm("pop ecx");
	asm("push ebp");
	asm("push edi");
	asm("push esi");
	asm("push ebx");
	asm("push edx");
	asm("push ecx");
	asm("mov edi, [%a0]": :"i"(&TheScheduler.iCurrentThread));			// edi=TheCurrentThread
	asm("mov esi, [edi+%0]" : : "i"_FOFF(NThreadBase,iSlowExecTable));	// esi=slow exec table base
	asm("call [esi-8]");												// call invalid exec handler
	asm("pop ecx");
	asm("pop edx");
	asm("pop ebx");
	asm("pop esi");
	asm("pop edi");
	asm("pop ebp");
	asm("jmp fast_exec_exit");
	}

/******************************************************************************
* Int 21h Handler - Slow Executive Calls
* Enter with:
*		Call number in EAX
*		Parameters in ECX, EDX, EBX, ESI in that order
* On entry SS:ESP references current threads supervisor stack
* Must preserve EBX, EBP, ESI, EDI
* [ESP+0] = return EIP
* [ESP+4] = return CS
* [ESP+8] = return EFLAGS
* [ESP+12] = return ESP if privilege change occurred
* [ESP+16] = return SS if privilege change occurred
*******************************************************************************/
GLDEF_C __NAKED__ void __X86Vector21()
	{
	// Interrupts enabled on entry
	asm("sub esp, 32");								// reserve space for additional arguments
	asm("cld");
	asm("push ds");
	asm("push es");
	asm("push gs");
	asm("push ebp");
	asm("mov bp, ds");
	asm("mov gs, bp");
	asm("mov bp, ss");
	asm("mov ds, bp");
	asm("mov es, bp");
	asm("push edi");
	asm("mov edi, [%a0]": : "i"(&TheScheduler.iCurrentThread));	// edi=TheCurrentThread
	asm("push esi");
	asm("mov esi, [edi+%0]" : : "i"_FOFF(NThreadBase,iSlowExecTable)); // esi=slow exec table base 
	asm("push ebx");
	asm("push edx");
	asm("push ecx");
	asm("lea ebp, [esi+eax*8]");					// ebp points to exec table entry
	asm("cmp eax, [esi-12]");
	asm("jae slow_exec_invalid");
	asm("mov ebx, [ebp]");							// ebx=flags
	asm("test ebx, 0x1c000000");					// additional arguments required?
	asm("jz slow_exec_no_extra_args");
	asm("mov edx, [esp+8]");						// edx points to additional args
	asm("lea eax, [esp+36]");						// address of copied additional arguments
	asm("mov [esp+8], eax");						// replace supplied address
	asm("mov ecx, ebx");
	asm("shr ecx, 26");
	asm("and cl, 7");								// ecx=number of additional arguments-1
	asm("test edx, edx");
	asm("jnz slow_exec_extra_args_present");		// if arg ptr not NULL, copy args
	asm("slow_exec_zero_args:");
	asm("mov [esp+ecx*4+36], edx");					// else zero args
	asm("dec ecx");
	asm("jns slow_exec_zero_args");
	asm("jmp slow_exec_no_extra_args");

	asm("slow_exec_extra_args_present:");
	asm("slow_exec_copy_args:");
	asm("mov eax, gs:[edx+ecx*4]");					// get argument
	asm("mov [esp+ecx*4+36], eax");					// copy it
	asm("dec ecx");
	asm("jns slow_exec_copy_args");

	asm("slow_exec_no_extra_args:");
	asm("test ebx, 0x80000000");					// test EClaim
	asm("jz slow_exec_no_claim");
	asm("call %a0" : : "i"(NKern_LockSystem)); 		// trashes eax, ecx, edx
	asm("slow_exec_no_claim:");
	asm("test ebx, 0x20000000");					// test EPreprocess
	asm("jz slow_exec_no_preprocess");
	asm("call [esi-4]");							// trashes eax, ecx, edx, edi
	asm("slow_exec_no_preprocess:");
	asm("call [ebp+4]");							// call exec function
	asm("test ebx, 0x40000000");					// test ERelease
	asm("jz slow_exec_no_release");
	asm("mov edi, eax");							// save return value in EDI
	asm("call %a0" : : "i"(NKern_UnlockSystem)); // trashes eax, ecx, edx
	asm("mov eax, edi");							// restore return value
	asm("slow_exec_no_release:");

	asm("slow_exec_exit:");
	asm("test dword ptr [esp+72], 3 ");				// returning to user mode?
	asm("jz short slow_exec_exit2 ");				// no - don't do lock check or user mode callbacks
#ifdef __CHECK_LOCK_STATE__
	asm("call %a0" : : "i" (&check_lock_state));
#endif
	asm("push eax");
	asm("cli");
#ifdef __GCC32__
	asm("mov ecx, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("push ecx");
	asm("call __ZN11NThreadBase21CallUserModeCallbacksEv");
	asm("add esp,4"); 
#else
	TheScheduler.iCurrentThread->CallUserModeCallbacks();
#endif
	asm("pop eax");

	asm("slow_exec_exit2: ");
	asm("pop ecx");
	asm("pop edx");
	asm("pop ebx");
	asm("pop esi");
	asm("pop edi");
	asm("pop ebp");
	asm("pop gs");
	asm("pop es");
	asm("pop ds");
	asm("add esp, 32");								// remove additional arguments
	asm("iretd");

	asm("slow_exec_invalid:");
	asm("call [esi-8]");							// call invalid exec handler
	asm("jmp slow_exec_exit");
	}

const TUint32 irq_start_trace_header = ((4<<BTrace::ESizeIndex) + (BTrace::ECpuUsage<<BTrace::ECategoryIndex*8) + (BTrace::EIrqStart<<BTrace::ESubCategoryIndex*8));
const TUint32 irq_end_trace_header   = ((4<<BTrace::ESizeIndex) + (BTrace::ECpuUsage<<BTrace::ECategoryIndex*8) + (BTrace::EIrqEnd<<BTrace::ESubCategoryIndex*8));

/******************************************************************************
* IRQ Preamble/Postamble Common Code
* On entry SS:ESP references current threads supervisor stack
* [ESP+0] = vector number
* [ESP+4] = return EIP
* [ESP+8] = return CS
* [ESP+12] = return EFLAGS
* [ESP+16] = return ESP if privilege change occurred
* [ESP+20] = return SS if privilege change occurred
*******************************************************************************/
__NAKED__ void __X86VectorIrq()
	{
	asm("push ds");
	asm("push es");
	asm("push eax");
	asm("mov ax, ss");
	asm("cld");
	asm("push ecx");
	asm("push edx");
	asm("mov ds, ax");
	asm("mov es, ax");
	asm("mov eax, esp");									// eax points to saved stuff
	asm("inc dword ptr [%a0]": : "i"(&X86_IrqNestCount));	// nest count starts at -1
	asm("jnz nested_irq_entry");
#ifdef __GCC32__
	asm("mov esp, %0" : : "i"(&X86_IrqStack)); 
	asm("add esp, %0" : : "i"(IRQ_STACK_SIZE));
#else
	_asm lea esp, X86_IrqStack[IRQ_STACK_SIZE]
#endif
	asm("push eax");
	asm("nested_irq_entry:");

#ifdef BTRACE_CPU_USAGE
	asm("cmp byte ptr [%a0], 0": : "i"(&TheScheduler.iCpuUsageFilter));
	asm("jz no_trace");
	asm("push eax");
	asm("push %0": :"i"(irq_start_trace_header));
	asm("call dword ptr [%a0]": : "i"(&TheScheduler.iBTraceHandler));
	asm("pop eax");
	asm("pop eax");
	asm("no_trace:");
#endif
	asm("call [%a0]": : "i"(&X86_IrqHandler));

	// Postamble. Interrupts disabled here.
	asm("xor eax, eax");
	asm("dec dword ptr [%a0]": : "i"(&X86_IrqNestCount));
	asm("jns nested_irq_exit");
	asm("cmp eax, [%a0]": : "i"(&TheScheduler.iKernCSLocked));
	asm("lea edx, %a0": : "i"(&TheScheduler.iRescheduleNeededFlag));
	asm("jnz irq_kernel_locked_exit");
	asm("cmp eax, [edx]");
	asm("jz irq_kernel_locked_exit");
	asm("inc eax");
	asm("mov [%a0], eax": : "i"(&TheScheduler.iKernCSLocked));
	asm("pop eax");
	asm("mov esp, eax");
	asm("sti");
	asm("call %a0" : : "i"(TScheduler_Reschedule));
	asm("jmp irq_exit");

	asm("irq_kernel_locked_exit:");
	asm("pop eax");
	asm("mov esp, eax");

	asm("nested_irq_exit:");
#ifdef BTRACE_CPU_USAGE
	asm("cmp byte ptr [%a0], 0": : "i"(&TheScheduler.iCpuUsageFilter));
	asm("jz no_trace2");
	asm("push %0": : "i"(irq_end_trace_header));
	asm("call dword ptr [%a0]": : "i"(&TheScheduler.iBTraceHandler));
	asm("pop eax");
	asm("no_trace2:");
#endif
	asm("irq_exit:");
	asm("test dword ptr [esp+28], 3 ");	// check if we came from kernel mode
	asm("jz short irq_exit2 ");
#ifdef __CHECK_LOCK_STATE__
	asm("call %a0" : : "i" (&check_lock_state));
#endif
#ifdef __GCC32__
	asm("mov ecx, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("push ecx");
	asm("call __ZN11NThreadBase21CallUserModeCallbacksEv");
	asm("add esp,4"); 
#else
	TheScheduler.iCurrentThread->CallUserModeCallbacks();
#endif
	asm("irq_exit2:");
	asm("pop edx");
	asm("pop ecx");
	asm("pop eax");
	asm("pop es");
	asm("pop ds");
	asm("add esp, 4");
	asm("iretd");
	}


/******************************************************************************
* General Exception Handler
* On entry SS:ESP references current threads supervisor stack
* [ESP+0] = vector number
* [ESP+4] = error code (filled with 0 for exceptions without error codes)
* [ESP+8] = return EIP
* [ESP+12] = return CS
* [ESP+16] = return EFLAGS
* [ESP+20] = return ESP if privilege change occurred
* [ESP+24] = return SS if privilege change occurred
*******************************************************************************/
GLDEF_C __NAKED__ void __X86VectorExc()
	{
	asm("push ds");
	asm("push es");
	asm("push fs");
	asm("push gs");
	asm("cld");
	asm("push ebp");
	asm("mov bp, ds");
	asm("push edi");
	asm("mov gs, bp");
	asm("mov bp, ss");
	asm("push esi");
	asm("push ebx");
	asm("push ecx");
	asm("push edx");
	asm("push eax");
	asm("mov eax, cr2");
	asm("mov ds, bp");
	asm("mov es, bp");
	asm("push eax");
	asm("sub esp, 8");
	asm("mov ebp, esp");		// ebp points to exception info frame
	asm("mov edi, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("xor eax, eax");
	asm("mov ax, ss");
	asm("mov [ebp+4], eax");	// SS
	asm("mov eax, ebp");
	asm("add eax, 76");		// EAX = ESP at point of exception if ring 0
	asm("test dword ptr [ebp+68], 3");	// check if we came from kernel mode
	asm("jz ring0_exception");
	asm("mov byte ptr [edi+11], 1");
	asm("add eax, 8");		// EAX = ESP at point of exception if ring 3
	asm("ring0_exception:");
	asm("mov [ebp], eax");
	asm("cmp dword ptr [%a0], -1": : "i"(&X86_IrqNestCount));
	asm("jnz fatal_exception_irq");
	asm("cmp dword ptr [%a0], 0": : "i"(&TheScheduler.iKernCSLocked));
	asm("jnz fatal_exception_locked");
	asm("cmp dword ptr [ebp+%0], 7": :"i"_FOFF(TX86ExcInfo,iExcId));	// check for device not available
	asm("jne not_fpu");
	asm("mov dword ptr [%a0], 1": :"i"(&TheScheduler.iKernCSLocked));
	asm("clts");
	asm("frstor [edi+%0]": :"i"_FOFF(NThread,iCoprocessorState));
	asm("call %a0": :"i"(NKern_Unlock));
	asm("add esp, 12");
	asm("jmp proceed");

	asm("not_fpu:");
	asm("mov eax, [edi+%0]" : : "i"_FOFF(NThreadBase,iHandlers)); 
	asm("push edi");		// pass current thread parameter
	asm("push ebp");		// pass frame address
	asm("call [eax+%0]" : : "i"_FOFF(SNThreadHandlers,iExceptionHandler)); 
	asm("add esp, 20");		// remove parameters, esp, ss, fault address

	asm("proceed:");
	asm("mov byte ptr [edi+11], 0 ");
	asm("test dword ptr [esp+56], 3 ");	// check if we came from kernel mode
	asm("jz short proceed2 ");
	asm("cli");
#ifdef __CHECK_LOCK_STATE__
	asm("call %a0" : : "i" (&check_lock_state));
#endif
#ifdef __GCC32__
	asm("mov ecx, [%a0]": : "i"(&TheScheduler.iCurrentThread));
	asm("push ecx");
	asm("call __ZN11NThreadBase21CallUserModeCallbacksEv");
	asm("add esp,4"); 
#else
	TheScheduler.iCurrentThread->CallUserModeCallbacks();
#endif	
	asm("proceed2:");
	asm("pop eax");
	asm("pop edx");
	asm("pop ecx");
	asm("pop ebx");
	asm("pop esi");
	asm("pop edi");
	asm("pop ebp");
	asm("pop gs");
	asm("pop fs");
	asm("pop es");
	asm("pop ds");
	asm("add esp, 8");		// skip vector number and error code
	asm("iretd");

	asm("fatal_exception_irq:");
	asm("fatal_exception_locked:");
	asm("lea eax, %a0": :"i"(&TheScheduler)); 
	asm("lea eax, [eax+%0]": :"i"_FOFF(TScheduler,iMonitorExceptionHandler));
	asm("mov eax,[eax]");

	asm("test eax, eax");
	asm("jnz monitor_exception");
	asm("push ebp");
	asm("call %a0": :"i"(&__X86ExcFault));	// doesn't return

	asm("monitor_exception:");
	asm("jmp eax");
	}


/******************************************************************************
* Exception Handlers
*******************************************************************************/

DECLARE_X86_EXC_NOERR(00)
DECLARE_X86_EXC_NOERR(01)
DECLARE_X86_EXC_NOERR(02)
DECLARE_X86_EXC_NOERR(03)
DECLARE_X86_EXC_NOERR(04)
DECLARE_X86_EXC_NOERR(05)
DECLARE_X86_EXC_NOERR(06)
DECLARE_X86_EXC_NOERR(07)
DECLARE_X86_EXC_ERR(08)
DECLARE_X86_EXC_NOERR(09)
DECLARE_X86_EXC_ERR(0A)
DECLARE_X86_EXC_ERR(0B)
DECLARE_X86_EXC_ERR(0C)
DECLARE_X86_EXC_ERR(0D)
DECLARE_X86_EXC_ERR(0E)
DECLARE_X86_EXC_NOERR(0F)
DECLARE_X86_EXC_NOERR(10)
DECLARE_X86_EXC_ERR(11)
DECLARE_X86_EXC_NOERR(12)
DECLARE_X86_EXC_NOERR(13)
DECLARE_X86_EXC_NOERR(14)
DECLARE_X86_EXC_NOERR(15)
DECLARE_X86_EXC_NOERR(16)
DECLARE_X86_EXC_NOERR(17)
DECLARE_X86_EXC_NOERR(18)
DECLARE_X86_EXC_NOERR(19)
DECLARE_X86_EXC_NOERR(1A)
DECLARE_X86_EXC_NOERR(1B)
DECLARE_X86_EXC_NOERR(1C)
DECLARE_X86_EXC_NOERR(1D)
DECLARE_X86_EXC_NOERR(1E)
DECLARE_X86_EXC_NOERR(1F)

/******************************************************************************
* Interrupt Handlers
*******************************************************************************/

DECLARE_X86_INT(30)
DECLARE_X86_INT(31)
DECLARE_X86_INT(32)
DECLARE_X86_INT(33)
DECLARE_X86_INT(34)
DECLARE_X86_INT(35)
DECLARE_X86_INT(36)
DECLARE_X86_INT(37)
DECLARE_X86_INT(38)
DECLARE_X86_INT(39)
DECLARE_X86_INT(3A)
DECLARE_X86_INT(3B)
DECLARE_X86_INT(3C)
DECLARE_X86_INT(3D)
DECLARE_X86_INT(3E)
DECLARE_X86_INT(3F)

/*const*/ PFV TheExcVectors[64]=
{
__X86Vector00,	__X86Vector01,	__X86Vector02,	__X86Vector03,
__X86Vector04,	__X86Vector05,	__X86Vector06,	__X86Vector07,
__X86Vector08,	__X86Vector09,	__X86Vector0A,	__X86Vector0B,
__X86Vector0C,	__X86Vector0D,	__X86Vector0E,	__X86Vector0F,
__X86Vector10,	__X86Vector11,	__X86Vector12,	__X86Vector13,
__X86Vector14,	__X86Vector15,	__X86Vector16,	__X86Vector17,
__X86Vector18,	__X86Vector19,	__X86Vector1A,	__X86Vector1B,
__X86Vector1C,	__X86Vector1D,	__X86Vector1E,	__X86Vector1F,
__X86Vector20,	__X86Vector21,	NULL,			NULL,
NULL,			NULL,			NULL,			NULL,
NULL,			NULL,			NULL,			NULL,
NULL,			NULL,			NULL,			NULL,
__X86Vector30,	__X86Vector31,	__X86Vector32,	__X86Vector33,
__X86Vector34,	__X86Vector35,	__X86Vector36,	__X86Vector37,
__X86Vector38,	__X86Vector39,	__X86Vector3A,	__X86Vector3B,
__X86Vector3C,	__X86Vector3D,	__X86Vector3E,	__X86Vector3F
};

EXPORT_C __NAKED__ TUint32 X86::IrqReturnAddress()
	{
	asm("mov eax, %0": :"i"(&X86_IrqStack[0]));
	asm("mov eax, [eax + %0]": :"i"(IRQ_STACK_SIZE - 4));	// pointer to saved supervisor stack pointer
	asm("mov eax, [eax+24]");								// return address from original interrupt
	asm("ret");
	}

__NAKED__ TUint32 get_cr0()
	{
	asm("mov eax, cr0");
	asm("ret");
	}

__NAKED__ TUint32 get_cr3()
	{
	asm("mov eax, cr0");
	asm("ret");
	}

__NAKED__ TUint32 get_esp()
	{
	asm("mov eax, esp");
	asm("ret");
	}

__NAKED__ void __lidt(SX86Des* /*aTable*/, TInt /*aLimit*/)
	{
	asm("mov eax, [esp+4]");
	asm("mov ecx, [esp+8]");
	asm("shl ecx, 3");
	asm("sub ecx, 1");
	asm("sub esp, 8");
	asm("mov word ptr [esp], cx");
	asm("mov dword ptr [esp+2], eax");
	asm("lidt [esp]"); 
	asm("add esp, 8");
	asm("mov eax, 0x28");
	asm("ltr ax");
	asm("ret");
	}