InOsEmuPkg: Rename package to EmulatorPkg & Sec to Host

* Rename InOsEmuPkg to EmulatorPkg
* Rename Unix/Sec to Unix/Host

Signed-off-by: jljusten
Reviewed-by: andrewfish
Reviewed-by: geekboy15a

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11918 6f19259b-4bc3-4df7-8a09-765794883524

2 files changed, 1566 insertions, 0 deletions

diff --git a/EmulatorPkg/Unix/Host/Ia32/Gasket.S b/EmulatorPkg/Unix/Host/Ia32/Gasket.S
new file mode 100644
index 0000000000..aa031ecece
--- /dev/null
+++ b/EmulatorPkg/Unix/Host/Ia32/Gasket.S
@@ -0,0 +1,1492 @@
+#------------------------------------------------------------------------------
+#
+# Manage differenced between UNIX ABI and EFI/Windows ABI
+#
+# For IA-32 the only difference is Mac OS X requires a 16-byte aligned stack.
+# For Linux this stack adjustment is a no-op, but we may as well make the 
+# the code common. 
+#
+# Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
+# This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution.  The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+#------------------------------------------------------------------------------
+ 
+
+
+  .text
+  
+//
+// EMU_THUNK_PROTOCOL gaskets (EFIAPI to UNIX ABI)
+//
+
+
+ASM_GLOBAL ASM_PFX(GasketSecWriteStdErr) 
+ASM_PFX(GasketSecWriteStdErr):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecWriteStdErr)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecConfigStdIn) 
+ASM_PFX(GasketSecConfigStdIn):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecConfigStdIn)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecWriteStdOut) 
+ASM_PFX(GasketSecWriteStdOut):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecWriteStdOut)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecReadStdIn)  
+ASM_PFX(GasketSecReadStdIn):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecReadStdIn)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecPollStdIn)  
+ASM_PFX(GasketSecPollStdIn):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecPollStdIn)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecMalloc) 
+ASM_PFX(GasketSecMalloc):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecMalloc)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecValloc) 
+ASM_PFX(GasketSecValloc):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecValloc)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecFree) 
+ASM_PFX(GasketSecFree):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecFree)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecSetTimer) 
+ASM_PFX(GasketSecSetTimer):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	12(%ebp), %edx
+	movl	%edx, 4(%esp)
+	movl	%eax, (%esp)
+
+  call  ASM_PFX(SecSetTimer)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecEnableInterrupt) 
+ASM_PFX(GasketSecEnableInterrupt):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(SecEnableInterrupt)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecDisableInterrupt) 
+ASM_PFX(GasketSecDisableInterrupt):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(SecDisableInterrupt)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketQueryPerformanceFrequency) 
+ASM_PFX(GasketQueryPerformanceFrequency):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(QueryPerformanceFrequency)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketQueryPerformanceCounter) 
+ASM_PFX(GasketQueryPerformanceCounter):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(QueryPerformanceCounter)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecSleep) 
+ASM_PFX(GasketSecSleep):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	8(%ebp), %eax
+	movl	12(%ebp), %ecx
+	movl	%ecx, 4(%esp)
+	movl	%eax, (%esp)
+
+  call  ASM_PFX(SecSleep)
+  
+  leave
+  ret
+  
+   
+ASM_GLOBAL ASM_PFX(GasketSecCpuSleep) 
+ASM_PFX(GasketSecCpuSleep):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call  ASM_PFX(SecCpuSleep)
+  
+  leave
+  ret
+  
+  
+ASM_GLOBAL ASM_PFX(GasketSecExit) 
+ASM_PFX(GasketSecExit):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecExit)     // Less to do as we will never return to EFI ABI world
+LDEAD_LOOP:
+  jmp  LDEAD_LOOP              // _exit should never return
+
+  
+ASM_GLOBAL ASM_PFX(GasketSecGetTime) 
+ASM_PFX(GasketSecGetTime):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecGetTime)
+
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketSecSetTime) 
+ASM_PFX(GasketSecSetTime):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call  ASM_PFX(SecSetTime)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecGetNextProtocol) 
+ASM_PFX(GasketSecGetNextProtocol):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(SecGetNextProtocol)
+  
+  leave
+  ret
+
+// PPIs produced by SEC
+
+ASM_GLOBAL ASM_PFX(GasketSecPeCoffGetEntryPoint) 
+ASM_PFX(GasketSecPeCoffGetEntryPoint):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecPeCoffGetEntryPoint)
+  
+  leave
+  ret
+ 
+ASM_GLOBAL ASM_PFX(GasketSecPeCoffRelocateImageExtraAction) 
+ASM_PFX(GasketSecPeCoffRelocateImageExtraAction):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecPeCoffRelocateImageExtraAction)
+  
+  leave
+  ret
+ 
+ASM_GLOBAL ASM_PFX(GasketSecPeCoffUnloadImageExtraAction) 
+ASM_PFX(GasketSecPeCoffUnloadImageExtraAction):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(SecPeCoffUnloadImageExtraAction)
+  
+  leave
+  ret
+ 
+
+ASM_GLOBAL ASM_PFX(GasketSecEmuThunkAddress) 
+ASM_PFX(GasketSecEmuThunkAddress):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(SecEmuThunkAddress)
+  
+  leave
+  ret
+
+//
+// Gasket functions for EFI_EMU_UGA_IO_PROTOCOL
+//
+
+ASM_GLOBAL ASM_PFX(GasketX11Size) 
+ASM_PFX(GasketX11Size):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(X11Size)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketX11CheckKey) 
+ASM_PFX(GasketX11CheckKey):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11CheckKey)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketX11GetKey) 
+ASM_PFX(GasketX11GetKey):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11GetKey)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketX11KeySetState) 
+ASM_PFX(GasketX11KeySetState):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11KeySetState)
+  
+  leave
+  ret
+
+  
+ASM_GLOBAL ASM_PFX(GasketX11RegisterKeyNotify) 
+ASM_PFX(GasketX11RegisterKeyNotify):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(X11RegisterKeyNotify)
+  
+  leave
+  ret
+
+  
+ASM_GLOBAL ASM_PFX(GasketX11Blt) 
+ASM_PFX(GasketX11Blt):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(X11Blt)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketX11CheckPointer) 
+ASM_PFX(GasketX11CheckPointer):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11CheckPointer)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketX11GetPointerState) 
+ASM_PFX(GasketX11GetPointerState):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11GetPointerState)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketX11GraphicsWindowOpen) 
+ASM_PFX(GasketX11GraphicsWindowOpen):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11GraphicsWindowOpen)
+  
+  leave
+  ret
+
+ 
+ASM_GLOBAL ASM_PFX(GasketX11GraphicsWindowClose) 
+ASM_PFX(GasketX11GraphicsWindowClose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(X11GraphicsWindowClose)
+  
+  leave
+  ret
+
+
+// Pthreads
+
+ASM_GLOBAL ASM_PFX(GasketPthreadMutexLock) 
+ASM_PFX(GasketPthreadMutexLock):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadMutexLock)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPthreadMutexUnLock) 
+ASM_PFX(GasketPthreadMutexUnLock):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadMutexUnLock)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketPthreadMutexTryLock) 
+ASM_PFX(GasketPthreadMutexTryLock):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadMutexTryLock)
+  
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketPthreadMutexInit) 
+ASM_PFX(GasketPthreadMutexInit):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(PthreadMutexInit)
+  
+  leave
+  ret
+
+
+ 
+ASM_GLOBAL ASM_PFX(GasketPthreadMutexDestroy) 
+ASM_PFX(GasketPthreadMutexDestroy):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadMutexDestroy)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPthreadCreate)  
+ASM_PFX(GasketPthreadCreate):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PthreadCreate)
+  
+  leave
+  ret
+
+                          
+ASM_GLOBAL ASM_PFX(GasketPthreadExit) 
+ASM_PFX(GasketPthreadExit):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadExit)
+  
+  leave
+  ret
+
+
+                             
+ASM_GLOBAL ASM_PFX(GasketPthreadSelf) 
+ASM_PFX(GasketPthreadSelf):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+
+  call    ASM_PFX(PthreadSelf)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPthreadOpen) 
+ASM_PFX(GasketPthreadOpen):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadOpen)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPthreadClose)  
+ASM_PFX(GasketPthreadClose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PthreadClose)
+  
+  leave
+  ret
+
+
+
+
+//
+// UNIX ABI to EFI ABI call
+//
+// UINTN
+// ReverseGasketUint64 (
+//   void *Api,
+//   UINTN Arg1
+//   );
+ASM_GLOBAL ASM_PFX(ReverseGasketUint64)
+ASM_PFX(ReverseGasketUint64):
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$8, %esp
+	movl	16(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, (%esp)
+	calll	*8(%ebp)
+	addl	$8, %esp
+	popl	%ebp
+	ret
+
+
+
+//
+// UNIX ABI to EFI ABI call
+//
+// UINTN
+// ReverseGasketUint64Uint64 (
+//   void *Api,
+//   UINTN Arg1
+//   UINTN Arg2
+//   );
+ASM_GLOBAL ASM_PFX(ReverseGasketUint64Uint64)
+ASM_PFX(ReverseGasketUint64Uint64):
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	24(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, (%esp)
+	calll	*8(%ebp)
+	addl	$24, %esp
+	popl	%ebp
+	ret
+  
+
+ASM_GLOBAL ASM_PFX(GasketSecUnixPeiAutoScan)  
+ASM_PFX(GasketSecUnixPeiAutoScan):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(SecUnixPeiAutoScan)
+  
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecUnixFdAddress) 
+ASM_PFX(GasketSecUnixFdAddress):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(SecUnixFdAddress)
+
+  leave
+  ret
+
+
+// EmuIoThunk SimpleFileSystem
+
+ASM_GLOBAL ASM_PFX(GasketPosixOpenVolume) 
+ASM_PFX(GasketPosixOpenVolume):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixOpenVolume)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileOpen) 
+ASM_PFX(GasketPosixFileOpen):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $56, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	28(%ebp), %eax
+	movl	32(%ebp), %ecx
+	movl	%ecx, 24(%esp)
+	movl	%eax, 20(%esp)
+	movl	20(%ebp), %eax
+	movl	24(%ebp), %ecx
+	movl	%ecx, 16(%esp)
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+ 
+  call    ASM_PFX(PosixFileOpen)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileCLose) 
+ASM_PFX(GasketPosixFileCLose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileCLose)
+
+  leave
+  ret
+
+   
+ASM_GLOBAL ASM_PFX(GasketPosixFileDelete) 
+ASM_PFX(GasketPosixFileDelete):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileDelete)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileRead) 
+ASM_PFX(GasketPosixFileRead):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixFileRead)
+
+  leave
+  ret
+
+  
+ASM_GLOBAL ASM_PFX(GasketPosixFileWrite) 
+ASM_PFX(GasketPosixFileWrite):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixFileWrite)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileSetPossition) 
+ASM_PFX(GasketPosixFileSetPossition):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	12(%ebp), %eax
+	movl	16(%ebp), %ecx
+	movl	%ecx, 8(%esp)
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixFileSetPossition)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileGetPossition) 
+ASM_PFX(GasketPosixFileGetPossition):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileGetPossition)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileGetInfo) 
+ASM_PFX(GasketPosixFileGetInfo):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixFileGetInfo)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileSetInfo) 
+ASM_PFX(GasketPosixFileSetInfo):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(PosixFileSetInfo)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileFlush) 
+ASM_PFX(GasketPosixFileFlush):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileFlush)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileSystmeThunkOpen) 
+ASM_PFX(GasketPosixFileSystmeThunkOpen):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileSystmeThunkOpen)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileSystmeThunkClose) 
+ASM_PFX(GasketPosixFileSystmeThunkClose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(PosixFileSystmeThunkClose)
+
+  leave
+  ret
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoReset) 
+ASM_PFX(GasketEmuBlockIoReset):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoReset)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoReadBlocks) 
+ASM_PFX(GasketEmuBlockIoReadBlocks):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $56, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	32(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	20(%ebp), %edx
+	movl	%edx, 12(%esp)
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoReadBlocks)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoWriteBlocks)  
+ASM_PFX(GasketEmuBlockIoWriteBlocks):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $56, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	32(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	20(%ebp), %edx
+	movl	%edx, 12(%esp)
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoWriteBlocks)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoFlushBlocks)  
+ASM_PFX(GasketEmuBlockIoFlushBlocks):  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+
+  call    ASM_PFX(EmuBlockIoFlushBlocks)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoCreateMapping) 
+ASM_PFX(GasketEmuBlockIoCreateMapping):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoCreateMapping)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketBlockIoThunkOpen)  
+ASM_PFX(GasketBlockIoThunkOpen):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoThunkOpen)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketBlockIoThunkClose)  
+ASM_PFX(GasketBlockIoThunkClose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuBlockIoThunkClose)
+
+  leave
+  ret
+
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpCreateMapping) 
+ASM_PFX(GasketSnpCreateMapping):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpCreateMapping)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpStart) 
+ASM_PFX(GasketSnpStart):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpStart)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpStop) 
+ASM_PFX(GasketSnpStop):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpStop)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpInitialize) 
+ASM_PFX(GasketSnpInitialize):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpInitialize)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpReset)  
+ASM_PFX(GasketSnpReset):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  12(%ebp), %eax
+  movl  %eax, 4(%esp)
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpReset)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpShutdown) 
+ASM_PFX(GasketSnpShutdown):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpShutdown)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpReceiveFilters)  
+ASM_PFX(GasketSnpReceiveFilters):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	28(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpReceiveFilters)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpStationAddress)  
+ASM_PFX(GasketSnpStationAddress):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  leave
+  ret
+
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpStatistics) 
+ASM_PFX(GasketSnpStatistics):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpStatistics)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpMCastIpToMac) 
+ASM_PFX(GasketSnpMCastIpToMac):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpMCastIpToMac)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpNvData) 
+ASM_PFX(GasketSnpNvData):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpNvData)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpGetStatus) 
+ASM_PFX(GasketSnpGetStatus):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $40, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpGetStatus)
+
+  leave
+  ret
+
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpTransmit) 
+ASM_PFX(GasketSnpTransmit):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $56, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	32(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpTransmit)
+
+  leave
+  ret
+
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpReceive) 
+ASM_PFX(GasketSnpReceive):
+	pushl	%ebp
+	movl	%esp, %ebp
+  subl  $56, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+	movl	32(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+
+  call    ASM_PFX(EmuSnpReceive)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpThunkOpen) 
+ASM_PFX(GasketSnpThunkOpen):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpThunkOpen)
+
+  leave
+  ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSnpThunkClose) 
+ASM_PFX(GasketSnpThunkClose):
+  pushl %ebp
+  movl  %esp, %ebp
+  subl  $24, %esp      // sub extra 16 from the stack for alignment
+  and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
+  movl  8(%ebp), %eax
+  movl  %eax, (%esp)
+
+  call    ASM_PFX(EmuSnpThunkClose)
+
+  leave
+  ret
+
+
diff --git a/EmulatorPkg/Unix/Host/Ia32/SwitchStack.c b/EmulatorPkg/Unix/Host/Ia32/SwitchStack.c
new file mode 100644
index 0000000000..c75073ac2e
--- /dev/null
+++ b/EmulatorPkg/Unix/Host/Ia32/SwitchStack.c
@@ -0,0 +1,74 @@
+/*++
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the BSD License
+which accompanies this distribution.  The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+
+--*/
+
+#include "SecMain.h"
+
+
+/**
+  Transfers control to a function starting with a new stack.
+
+  Transfers control to the function specified by EntryPoint using the new stack
+  specified by NewStack and passing in the parameters specified by Context1 and
+  Context2. Context1 and Context2 are optional and may be NULL. The function
+  EntryPoint must never return.
+
+  If EntryPoint is NULL, then ASSERT().
+  If NewStack is NULL, then ASSERT().
+
+  @param  EntryPoint  A pointer to function to call with the new stack.
+  @param  Context1    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  Context2    A pointer to the context to pass into the EntryPoint
+                      function.
+  @param  NewStack    A pointer to the new stack to use for the EntryPoint
+                      function.
+
+**/
+VOID
+EFIAPI
+PeiSwitchStacks (
+  IN      SWITCH_STACK_ENTRY_POINT  EntryPoint,
+  IN      VOID                      *Context1,  OPTIONAL
+  IN      VOID                      *Context2,  OPTIONAL
+  IN      VOID                      *NewStack
+  )
+{
+  BASE_LIBRARY_JUMP_BUFFER  JumpBuffer;
+  
+  ASSERT (EntryPoint != NULL);
+  ASSERT (NewStack != NULL);
+
+  //
+  // Stack should be aligned with CPU_STACK_ALIGNMENT
+  //
+  ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0);
+
+  JumpBuffer.Eip = (UINTN)EntryPoint;
+  JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*);
+  JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2);
+  ((VOID**)JumpBuffer.Esp)[1] = Context1;
+  ((VOID**)JumpBuffer.Esp)[2] = Context2;
+
+  LongJump (&JumpBuffer, (UINTN)-1);
+  
+
+  //
+  // PeiSwitchStacks () will never return
+  //
+  ASSERT (FALSE);  
+}
+
+
+