mirror of https://github.com/acidanthera/audk.git
1493 lines
33 KiB
ArmAsm
1493 lines
33 KiB
ArmAsm
#------------------------------------------------------------------------------
|
|
#
|
|
# 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
|
|
|
|
|