diff --git a/InOsEmuPkg/Sec/Ia32/SwitchRam.S b/InOsEmuPkg/Sec/Ia32/SwitchRam.S
new file mode 100644
index 0000000000..abb8e7dac1
--- /dev/null
+++ b/InOsEmuPkg/Sec/Ia32/SwitchRam.S
@@ -0,0 +1,103 @@
+#------------------------------------------------------------------------------
+#
+# Copyright (c) 2007, Intel Corporation. All rights reserved.
+# 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.
+#
+# Module Name:
+#
+# Stack.asm
+#
+# Abstract:
+#
+# Switch the stack from temporary memory to permenent memory.
+#
+#------------------------------------------------------------------------------
+
+ .text
+
+
+// EFI_STATUS
+// EFIAPI
+// SecTemporaryRamSupport (
+// IN CONST EFI_PEI_SERVICES **PeiServices, // %rcx
+// IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase, // %rdx
+// IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase, // %r8
+// IN UINTN CopySize // %r9
+// )
+//
+ASM_GLOBAL ASM_PFX(SecTemporaryRamSupport)
+ASM_PFX(SecTemporaryRamSupport):
+//------------------------------------------------------------------------------
+// VOID
+// EFIAPI
+// SecSwitchStack (
+// UINT32 TemporaryMemoryBase,
+// UINT32 PermenentMemoryBase
+// )//
+//------------------------------------------------------------------------------
+
+ //
+ // Save three register: eax, ebx, ecx
+ //
+ push %eax
+ push %ebx
+ push %ecx
+ push %edx
+
+#if 0
+// Port me to GAS syntax
+ //
+ // !!CAUTION!! this function addresss is pushed into stack after
+ // migration of whole temporary memory, so need save it to permenent
+ // memory at first!
+ //
+
+ mov ebx, [esp + 20] // Save the first parameter
+ mov ecx, [esp + 24] // Save the second parameter
+
+ //
+ // Save this functions return address into permenent memory at first.
+ // Then, Fixup the esp point to permenent memory
+ //
+ mov eax, esp
+ sub eax, ebx
+ add eax, ecx
+ mov edx, dword ptr [esp] // copy pushed registers value to permenent memory
+ mov dword ptr [eax], edx
+ mov edx, dword ptr [esp + 4]
+ mov dword ptr [eax + 4], edx
+ mov edx, dword ptr [esp + 8]
+ mov dword ptr [eax + 8], edx
+ mov edx, dword ptr [esp + 12]
+ mov dword ptr [eax + 12], edx
+ mov edx, dword ptr [esp + 16] // Update this functions return address into permenent memory
+ mov dword ptr [eax + 16], edx
+ mov esp, eax // From now, esp is pointed to permenent memory
+
+ //
+ // Fixup the ebp point to permenent memory
+ //
+ mov eax, ebp
+ sub eax, ebx
+ add eax, ecx
+ mov ebp, eax // From now, ebp is pointed to permenent memory
+
+ //
+ // Fixup callees ebp point for PeiDispatch
+ //
+ mov eax, dword ptr [ebp]
+ sub eax, ebx
+ add eax, ecx
+ mov dword ptr [ebp], eax // From now, Temporarys PPI callers stack is in permenent memory
+#endif
+ pop %edx
+ pop %ecx
+ pop %ebx
+ pop %eax
+ ret
diff --git a/InOsEmuPkg/Sec/Sec.inf b/InOsEmuPkg/Sec/Sec.inf
index c263f9db2b..5d875b55b5 100644
--- a/InOsEmuPkg/Sec/Sec.inf
+++ b/InOsEmuPkg/Sec/Sec.inf
@@ -28,6 +28,9 @@
[Sources.X64]
X64/SwitchRam.S
+[Sources.IA32]
+ Ia32/SwitchRam.S
+
[Packages]
MdePkg/MdePkg.dec
InOsEmuPkg/InOsEmuPkg.dec
diff --git a/InOsEmuPkg/Unix/Sec/Ia32/Gasket.S b/InOsEmuPkg/Unix/Sec/Ia32/Gasket.S
new file mode 100644
index 0000000000..227be548da
--- /dev/null
+++ b/InOsEmuPkg/Unix/Sec/Ia32/Gasket.S
@@ -0,0 +1,1505 @@
+#------------------------------------------------------------------------------
+#
+# 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.
+# 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ ret
+
+
+ASM_GLOBAL ASM_PFX(GasketSecSetTimer)
+ASM_PFX(GasketSecSetTimer):
+ 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(SecSetTimer)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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 %eax, (%esp)
+
+ call ASM_PFX(SecSleep)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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 // stack frame is for the debugger
+ subl $8, %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 // stack frame is for the debugger
+ 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
+
+
+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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileOpen)
+ASM_PFX(GasketPosixFileOpen):
+ 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(PosixFileOpen)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ ret
+
+
+ASM_GLOBAL ASM_PFX(GasketPosixFileSetPossition)
+ASM_PFX(GasketPosixFileSetPossition):
+ 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(PosixFileSetPossition)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoReadBlocks)
+ASM_PFX(GasketEmuBlockIoReadBlocks):
+ 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(EmuBlockIoReadBlocks)
+
+ addl $40, %esp
+ popl %ebp
+ ret
+
+
+ASM_GLOBAL ASM_PFX(GasketEmuBlockIoWriteBlocks)
+ASM_PFX(GasketEmuBlockIoWriteBlocks):
+ 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(EmuBlockIoWriteBlocks)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $40, %esp
+ popl %ebp
+ 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)
+
+ addl $56, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ 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)
+
+ addl $24, %esp
+ popl %ebp
+ ret
+
+
diff --git a/InOsEmuPkg/Unix/Sec/Ia32/SwitchStack.c b/InOsEmuPkg/Unix/Sec/Ia32/SwitchStack.c
new file mode 100644
index 0000000000..c75073ac2e
--- /dev/null
+++ b/InOsEmuPkg/Unix/Sec/Ia32/SwitchStack.c
@@ -0,0 +1,74 @@
+/*++
+
+Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.
+Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.
+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);
+}
+
+
+
diff --git a/InOsEmuPkg/Unix/Sec/SecMain.c b/InOsEmuPkg/Unix/Sec/SecMain.c
index 4b6cb98e83..807f067ceb 100644
--- a/InOsEmuPkg/Unix/Sec/SecMain.c
+++ b/InOsEmuPkg/Unix/Sec/SecMain.c
@@ -439,7 +439,7 @@ MapFd0 (
// Map the rest of the FD as read/write
res2 = mmap (
- (void *)(FixedPcdGet64 (PcdEmuFlashFvRecoveryBase) + FvSize),
+ (void *)(UINTN)(FixedPcdGet64 (PcdEmuFlashFvRecoveryBase) + FvSize),
FileSize - FvSize,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_SHARED,
diff --git a/InOsEmuPkg/Unix/Sec/SecMain.inf b/InOsEmuPkg/Unix/Sec/SecMain.inf
index a0976efe86..294cf31d26 100644
--- a/InOsEmuPkg/Unix/Sec/SecMain.inf
+++ b/InOsEmuPkg/Unix/Sec/SecMain.inf
@@ -20,7 +20,6 @@
BASE_NAME = SecMain
FILE_GUID = 8863C0AD-7724-C84B-88E5-A33B116D1485
MODULE_TYPE = USER_DEFINED
-# MODULE_TYPE = BASE
VERSION_STRING = 1.0
#
@@ -43,6 +42,10 @@
X64/Gasket.S # convert between Emu x86_64 ABI and EFI X64 ABI
X64/SwitchStack.S
+[Sources.IA32]
+ Ia32/Gasket.S # enforce 16-byte stack alignment for Mac OS X
+ Ia32/SwitchStack.c
+
[Packages]
MdePkg/MdePkg.dec
diff --git a/InOsEmuPkg/Unix/UnixX64.dsc b/InOsEmuPkg/Unix/UnixX64.dsc
index a601c0cbce..79c0ac67ef 100644
--- a/InOsEmuPkg/Unix/UnixX64.dsc
+++ b/InOsEmuPkg/Unix/UnixX64.dsc
@@ -28,7 +28,7 @@
PLATFORM_VERSION = 0.3
DSC_ SPECIFICATION = 0x00010005
OUTPUT_DIRECTORY = Build/EmuUnixX64
- SUPPORTED_ARCHITECTURES = X64
+ SUPPORTED_ARCHITECTURES = X64|IA32
BUILD_TARGETS = DEBUG|RELEASE
SKUID_IDENTIFIER = DEFAULT
FLASH_DEFINITION = InOsEmuPkg/Unix/UnixX64.fdf
@@ -264,6 +264,17 @@
# generated for it, but the binary will not be put into any firmware volume.
#
###################################################################################################
+
+[Components.X64]
+ MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf {
+
+ # turn off CR3 write so that DXE IPL will not crash emulator
+ BaseLib|UnixPkg/Library/UnixBaseLib/UnixBaseLib.inf
+ }
+
+[Components.IA32]
+ MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf
+
[Components]
!if $(SEC_ONLY)
##
@@ -294,11 +305,6 @@
InOsEmuPkg/FirmwareVolumePei/FirmwareVolumePei.inf
InOsEmuPkg/FlashMapPei/FlashMapPei.inf
InOsEmuPkg/ThunkPpiToProtocolPei/ThunkPpiToProtocolPei.inf
- MdeModulePkg/Core/DxeIplPeim/DxeIpl.inf {
-
- # turn off CR3 write so that DXE IPL will not crash emulator
- BaseLib|UnixPkg/Library/UnixBaseLib/UnixBaseLib.inf
- }
##
# DXE Phase modules
diff --git a/InOsEmuPkg/Unix/build.sh b/InOsEmuPkg/Unix/build.sh
new file mode 100755
index 0000000000..e7e7b33b4c
--- /dev/null
+++ b/InOsEmuPkg/Unix/build.sh
@@ -0,0 +1,129 @@
+#!/bin/bash
+#
+# Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.
+# Copyright (c) 2010, Intel Corporation. All rights reserved.
+#
+# 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.
+#
+
+set -e
+shopt -s nocasematch
+
+
+#
+# Setup workspace if it is not set
+#
+if [ -z "$WORKSPACE" ]
+then
+ echo Initializing workspace
+ if [ ! -e `pwd`/edksetup.sh ]
+ then
+ cd ../..
+ fi
+# This version is for the tools in the BaseTools project.
+# this assumes svn pulls have the same root dir
+# export EDK_TOOLS_PATH=`pwd`/../BaseTools
+# This version is for the tools source in edk2
+ export EDK_TOOLS_PATH=`pwd`/BaseTools
+ echo $EDK_TOOLS_PATH
+ source edksetup.sh BaseTools
+else
+ echo Building from: $WORKSPACE
+fi
+
+#
+# Pick a default tool type for a given OS
+#
+TARGET_TOOLS=MYTOOLS
+UNIXPKG_TOOLS=GCC44
+NETWORK_SUPPORT=
+BUILD_NEW_SHELL=
+BUILD_FAT=
+case `uname` in
+ CYGWIN*) echo Cygwin not fully supported yet. ;;
+ Darwin*)
+ Major=$(uname -r | cut -f 1 -d '.')
+ if [[ $Major == 9 ]]
+ then
+ echo UnixPkg requires Snow Leopard or later OS
+ exit 1
+ else
+ TARGET_TOOLS=XCODE32
+ UNIXPKG_TOOLS=XCLANG
+ fi
+# NETWORK_SUPPORT="-D NETWORK_SUPPORT"
+ BUILD_NEW_SHELL="-D BUILD_NEW_SHELL"
+ BUILD_FAT="-D BUILD_FAT"
+ ;;
+ Linux*) TARGET_TOOLS=ELFGCC ;;
+
+esac
+
+BUILD_ROOT_ARCH=$WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/IA32
+
+if [[ ! -f `which build` || ! -f `which GenFv` ]];
+then
+ # build the tools if they don't yet exist. Bin scheme
+ echo Building tools as they are not in the path
+ make -C $WORKSPACE/BaseTools
+elif [[ ( -f `which build` || -f `which GenFv` ) && ! -d $EDK_TOOLS_PATH/Source/C/bin ]];
+then
+ # build the tools if they don't yet exist. BinWrapper scheme
+ echo Building tools no $EDK_TOOLS_PATH/Source/C/bin directory
+ make -C $WORKSPACE/BaseTools
+else
+ echo using prebuilt tools
+fi
+
+
+for arg in "$@"
+do
+ if [[ $arg == run ]]; then
+ case `uname` in
+ Darwin*)
+ #
+ # On Darwin we can't use dlopen, so we have to load the real PE/COFF images.
+ # This .gdbinit script sets a breakpoint that loads symbols for the PE/COFFEE
+ # images that get loaded in SecMain
+ #
+ cp $WORKSPACE/InOsEmuPkg/Unix/.gdbinit $WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/IA32
+ ;;
+ esac
+
+ /usr/bin/gdb $BUILD_ROOT_ARCH/SecMain -q -cd=$BUILD_ROOT_ARCH
+ exit
+ fi
+
+ if [[ $arg == cleanall ]]; then
+ make -C $WORKSPACE/BaseTools clean
+ build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $TARGET_TOOLS -D SEC_ONLY -n 3 clean
+ build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $UNIXPKG_TOOLS -n 3 clean
+ build -p $WORKSPACE/ShellPkg/ShellPkg.dsc -a IA32 -t $UNIXPKG_TOOLS -n 3 clean
+ exit $?
+ fi
+
+ if [[ $arg == clean ]]; then
+ build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $TARGET_TOOLS -D SEC_ONLY -n 3 clean
+ build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $UNIXPKG_TOOLS -n 3 clean
+ exit $?
+ fi
+
+done
+
+
+#
+# Build the edk2 UnixPkg
+#
+echo $PATH
+echo `which build`
+build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $TARGET_TOOLS -D SEC_ONLY -n 3 $1 $2 $3 $4 $5 $6 $7 $8 modules
+build -p $WORKSPACE/InOsEmuPkg/Unix/UnixX64.dsc -a IA32 -t $UNIXPKG_TOOLS $NETWORK_SUPPORT $BUILD_NEW_SHELL $BUILD_FAT -n 3 $1 $2 $3 $4 $5 $6 $7 $8
+cp $WORKSPACE/Build/EmuUnixX64/DEBUG_"$TARGET_TOOLS"/IA32/SecMain $WORKSPACE/Build/EmuUnixX64/DEBUG_"$UNIXPKG_TOOLS"/IA32
+exit $?
+