Home | History | Annotate | Download | only in Ia32 
      1 #------------------------------------------------------------------------------
      2 #
      3 # Manage differenced between UNIX ABI and EFI/Windows ABI
      4 #
      5 # For IA-32 the only difference is Mac OS X requires a 16-byte aligned stack.
      6 # For Linux this stack adjustment is a no-op, but we may as well make the
      7 # the code common.
      8 #
      9 # Copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
     10 # This program and the accompanying materials
     11 # are licensed and made available under the terms and conditions of the BSD License
     12 # which accompanies this distribution.  The full text of the license may be found at
     13 # http://opensource.org/licenses/bsd-license.php
     14 #
     15 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     16 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     17 #
     18 #------------------------------------------------------------------------------
     19 
     20 
     21 
     22   .text
     23 
     24 //
     25 // EMU_THUNK_PROTOCOL gaskets (EFIAPI to UNIX ABI)
     26 //
     27 
     28 
     29 ASM_GLOBAL ASM_PFX(GasketSecWriteStdErr)
     30 ASM_PFX(GasketSecWriteStdErr):
     31   pushl %ebp
     32   movl  %esp, %ebp
     33   subl  $24, %esp      // sub extra 16 from the stack for alignment
     34   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
     35   movl  12(%ebp), %eax
     36   movl  %eax, 4(%esp)
     37   movl  8(%ebp), %eax
     38   movl  %eax, (%esp)
     39 
     40   call  ASM_PFX(SecWriteStdErr)
     41 
     42   leave
     43   ret
     44 
     45 
     46 ASM_GLOBAL ASM_PFX(GasketSecConfigStdIn)
     47 ASM_PFX(GasketSecConfigStdIn):
     48   pushl %ebp
     49   movl  %esp, %ebp
     50   subl  $24, %esp      // sub extra 16 from the stack for alignment
     51   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
     52   movl  12(%ebp), %eax
     53   movl  %eax, 4(%esp)
     54   movl  8(%ebp), %eax
     55   movl  %eax, (%esp)
     56 
     57   call  ASM_PFX(SecConfigStdIn)
     58 
     59   leave
     60   ret
     61 
     62 ASM_GLOBAL ASM_PFX(GasketSecWriteStdOut)
     63 ASM_PFX(GasketSecWriteStdOut):
     64   pushl %ebp
     65   movl  %esp, %ebp
     66   subl  $24, %esp      // sub extra 16 from the stack for alignment
     67   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
     68   movl  12(%ebp), %eax
     69   movl  %eax, 4(%esp)
     70   movl  8(%ebp), %eax
     71   movl  %eax, (%esp)
     72 
     73   call  ASM_PFX(SecWriteStdOut)
     74 
     75   leave
     76   ret
     77 
     78 ASM_GLOBAL ASM_PFX(GasketSecReadStdIn)
     79 ASM_PFX(GasketSecReadStdIn):
     80   pushl %ebp
     81   movl  %esp, %ebp
     82   subl  $24, %esp      // sub extra 16 from the stack for alignment
     83   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
     84   movl  12(%ebp), %eax
     85   movl  %eax, 4(%esp)
     86   movl  8(%ebp), %eax
     87   movl  %eax, (%esp)
     88 
     89   call  ASM_PFX(SecReadStdIn)
     90 
     91   leave
     92   ret
     93 
     94 ASM_GLOBAL ASM_PFX(GasketSecPollStdIn)
     95 ASM_PFX(GasketSecPollStdIn):
     96   pushl %ebp
     97   movl  %esp, %ebp
     98   subl  $24, %esp      // sub extra 16 from the stack for alignment
     99   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    100   movl  12(%ebp), %eax
    101   movl  %eax, 4(%esp)
    102   movl  8(%ebp), %eax
    103   movl  %eax, (%esp)
    104 
    105   call  ASM_PFX(SecPollStdIn)
    106 
    107   leave
    108   ret
    109 
    110 ASM_GLOBAL ASM_PFX(GasketSecMalloc)
    111 ASM_PFX(GasketSecMalloc):
    112   pushl %ebp
    113   movl  %esp, %ebp
    114   subl  $24, %esp      // sub extra 16 from the stack for alignment
    115   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    116   movl  8(%ebp), %eax
    117   movl  %eax, (%esp)
    118 
    119   call    ASM_PFX(SecMalloc)
    120 
    121   leave
    122   ret
    123 
    124 ASM_GLOBAL ASM_PFX(GasketSecValloc)
    125 ASM_PFX(GasketSecValloc):
    126   pushl %ebp
    127   movl  %esp, %ebp
    128   subl  $24, %esp      // sub extra 16 from the stack for alignment
    129   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    130   movl  8(%ebp), %eax
    131   movl  %eax, (%esp)
    132 
    133   call    ASM_PFX(SecValloc)
    134 
    135   leave
    136   ret
    137 
    138 ASM_GLOBAL ASM_PFX(GasketSecFree)
    139 ASM_PFX(GasketSecFree):
    140   pushl %ebp
    141   movl  %esp, %ebp
    142   subl  $24, %esp      // sub extra 16 from the stack for alignment
    143   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    144   movl  8(%ebp), %eax
    145   movl  %eax, (%esp)
    146 
    147   call    ASM_PFX(SecFree)
    148 
    149   leave
    150   ret
    151 
    152 
    153 ASM_GLOBAL ASM_PFX(GasketSecSetTimer)
    154 ASM_PFX(GasketSecSetTimer):
    155   pushl %ebp
    156   movl  %esp, %ebp
    157   subl  $40, %esp      // sub extra 16 from the stack for alignment
    158   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    159   movl	16(%ebp), %eax
    160 	movl	%eax, 8(%esp)
    161 	movl	8(%ebp), %eax
    162 	movl	12(%ebp), %edx
    163 	movl	%edx, 4(%esp)
    164 	movl	%eax, (%esp)
    165 
    166   call  ASM_PFX(SecSetTimer)
    167 
    168   leave
    169   ret
    170 
    171 
    172 ASM_GLOBAL ASM_PFX(GasketSecEnableInterrupt)
    173 ASM_PFX(GasketSecEnableInterrupt):
    174   pushl %ebp
    175   movl  %esp, %ebp
    176   subl  $24, %esp      // sub extra 16 from the stack for alignment
    177   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    178 
    179   call    ASM_PFX(SecEnableInterrupt)
    180 
    181   leave
    182   ret
    183 
    184 
    185 ASM_GLOBAL ASM_PFX(GasketSecDisableInterrupt)
    186 ASM_PFX(GasketSecDisableInterrupt):
    187   pushl %ebp
    188   movl  %esp, %ebp
    189   subl  $24, %esp      // sub extra 16 from the stack for alignment
    190   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    191 
    192   call    ASM_PFX(SecDisableInterrupt)
    193 
    194   leave
    195   ret
    196 
    197 ASM_GLOBAL ASM_PFX(GasketQueryPerformanceFrequency)
    198 ASM_PFX(GasketQueryPerformanceFrequency):
    199   pushl %ebp
    200   movl  %esp, %ebp
    201   subl  $24, %esp      // sub extra 16 from the stack for alignment
    202   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    203 
    204   call    ASM_PFX(QueryPerformanceFrequency)
    205 
    206   leave
    207   ret
    208 
    209 
    210 ASM_GLOBAL ASM_PFX(GasketQueryPerformanceCounter)
    211 ASM_PFX(GasketQueryPerformanceCounter):
    212   pushl %ebp
    213   movl  %esp, %ebp
    214   subl  $24, %esp      // sub extra 16 from the stack for alignment
    215   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    216 
    217   call    ASM_PFX(QueryPerformanceCounter)
    218 
    219   leave
    220   ret
    221 
    222 
    223 ASM_GLOBAL ASM_PFX(GasketSecSleep)
    224 ASM_PFX(GasketSecSleep):
    225   pushl %ebp
    226   movl  %esp, %ebp
    227   subl  $24, %esp      // sub extra 16 from the stack for alignment
    228   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    229 	movl	8(%ebp), %eax
    230 	movl	12(%ebp), %ecx
    231 	movl	%ecx, 4(%esp)
    232 	movl	%eax, (%esp)
    233 
    234   call  ASM_PFX(SecSleep)
    235 
    236   leave
    237   ret
    238 
    239 
    240 ASM_GLOBAL ASM_PFX(GasketSecCpuSleep)
    241 ASM_PFX(GasketSecCpuSleep):
    242   pushl %ebp
    243   movl  %esp, %ebp
    244   subl  $24, %esp      // sub extra 16 from the stack for alignment
    245   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    246 
    247   call  ASM_PFX(SecCpuSleep)
    248 
    249   leave
    250   ret
    251 
    252 
    253 ASM_GLOBAL ASM_PFX(GasketSecExit)
    254 ASM_PFX(GasketSecExit):
    255   pushl %ebp
    256   movl  %esp, %ebp
    257   subl  $24, %esp      // sub extra 16 from the stack for alignment
    258   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    259   movl  8(%ebp), %eax
    260   movl  %eax, (%esp)
    261 
    262   call    ASM_PFX(SecExit)     // Less to do as we will never return to EFI ABI world
    263 LDEAD_LOOP:
    264   jmp  LDEAD_LOOP              // _exit should never return
    265 
    266 
    267 ASM_GLOBAL ASM_PFX(GasketSecGetTime)
    268 ASM_PFX(GasketSecGetTime):
    269   pushl %ebp
    270   movl  %esp, %ebp
    271   subl  $24, %esp      // sub extra 16 from the stack for alignment
    272   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    273   movl  12(%ebp), %eax
    274   movl  %eax, 4(%esp)
    275   movl  8(%ebp), %eax
    276   movl  %eax, (%esp)
    277 
    278   call  ASM_PFX(SecGetTime)
    279 
    280   leave
    281   ret
    282 
    283 ASM_GLOBAL ASM_PFX(GasketSecSetTime)
    284 ASM_PFX(GasketSecSetTime):
    285   pushl %ebp
    286   movl  %esp, %ebp
    287   subl  $24, %esp      // sub extra 16 from the stack for alignment
    288   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    289   movl  12(%ebp), %eax
    290   movl  %eax, 4(%esp)
    291   movl  8(%ebp), %eax
    292   movl  %eax, (%esp)
    293 
    294   call  ASM_PFX(SecSetTime)
    295 
    296   leave
    297   ret
    298 
    299 
    300 ASM_GLOBAL ASM_PFX(GasketSecGetNextProtocol)
    301 ASM_PFX(GasketSecGetNextProtocol):
    302 	pushl	%ebp
    303 	movl	%esp, %ebp
    304   subl  $40, %esp      // sub extra 16 from the stack for alignment
    305   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    306 	movl	20(%ebp), %eax
    307 	movl	%eax, 12(%esp)
    308 	movl	16(%ebp), %eax
    309 	movl	%eax, 8(%esp)
    310 	movl	12(%ebp), %eax
    311 	movl	%eax, 4(%esp)
    312 	movl	8(%ebp), %eax
    313 	movl	%eax, (%esp)
    314 
    315   call    ASM_PFX(SecGetNextProtocol)
    316 
    317   leave
    318   ret
    319 
    320 // PPIs produced by SEC
    321 
    322 ASM_GLOBAL ASM_PFX(GasketSecPeCoffGetEntryPoint)
    323 ASM_PFX(GasketSecPeCoffGetEntryPoint):
    324   pushl %ebp
    325   movl  %esp, %ebp
    326   subl  $24, %esp      // sub extra 16 from the stack for alignment
    327   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    328   movl  12(%ebp), %eax
    329   movl  %eax, 4(%esp)
    330   movl  8(%ebp), %eax
    331   movl  %eax, (%esp)
    332 
    333   call    ASM_PFX(SecPeCoffGetEntryPoint)
    334 
    335   leave
    336   ret
    337 
    338 ASM_GLOBAL ASM_PFX(GasketSecPeCoffRelocateImageExtraAction)
    339 ASM_PFX(GasketSecPeCoffRelocateImageExtraAction):
    340   pushl %ebp
    341   movl  %esp, %ebp
    342   subl  $24, %esp      // sub extra 16 from the stack for alignment
    343   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    344   movl  8(%ebp), %eax
    345   movl  %eax, (%esp)
    346 
    347   call    ASM_PFX(SecPeCoffRelocateImageExtraAction)
    348 
    349   leave
    350   ret
    351 
    352 ASM_GLOBAL ASM_PFX(GasketSecPeCoffUnloadImageExtraAction)
    353 ASM_PFX(GasketSecPeCoffUnloadImageExtraAction):
    354   pushl %ebp
    355   movl  %esp, %ebp
    356   subl  $24, %esp      // sub extra 16 from the stack for alignment
    357   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    358   movl  8(%ebp), %eax
    359   movl  %eax, (%esp)
    360 
    361   call    ASM_PFX(SecPeCoffUnloadImageExtraAction)
    362 
    363   leave
    364   ret
    365 
    366 
    367 ASM_GLOBAL ASM_PFX(GasketSecEmuThunkAddress)
    368 ASM_PFX(GasketSecEmuThunkAddress):
    369   pushl %ebp
    370   movl  %esp, %ebp
    371   subl  $24, %esp      // sub extra 16 from the stack for alignment
    372   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    373 
    374   call    ASM_PFX(SecEmuThunkAddress)
    375 
    376   leave
    377   ret
    378 
    379 //
    380 // Gasket functions for EFI_EMU_UGA_IO_PROTOCOL
    381 //
    382 
    383 ASM_GLOBAL ASM_PFX(GasketX11Size)
    384 ASM_PFX(GasketX11Size):
    385 	pushl	%ebp
    386 	movl	%esp, %ebp
    387   subl  $40, %esp      // sub extra 16 from the stack for alignment
    388   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    389 	movl	20(%ebp), %eax
    390 	movl	%eax, 12(%esp)
    391 	movl	16(%ebp), %eax
    392 	movl	%eax, 8(%esp)
    393 	movl	12(%ebp), %eax
    394 	movl	%eax, 4(%esp)
    395 	movl	8(%ebp), %eax
    396 	movl	%eax, (%esp)
    397 
    398   call    ASM_PFX(X11Size)
    399 
    400   leave
    401   ret
    402 
    403 
    404 ASM_GLOBAL ASM_PFX(GasketX11CheckKey)
    405 ASM_PFX(GasketX11CheckKey):
    406   pushl %ebp
    407   movl  %esp, %ebp
    408   subl  $24, %esp      // sub extra 16 from the stack for alignment
    409   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    410   movl  8(%ebp), %eax
    411   movl  %eax, (%esp)
    412 
    413   call    ASM_PFX(X11CheckKey)
    414 
    415   leave
    416   ret
    417 
    418 ASM_GLOBAL ASM_PFX(GasketX11GetKey)
    419 ASM_PFX(GasketX11GetKey):
    420   pushl %ebp
    421   movl  %esp, %ebp
    422   subl  $24, %esp      // sub extra 16 from the stack for alignment
    423   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    424   movl  12(%ebp), %eax
    425   movl  %eax, 4(%esp)
    426   movl  8(%ebp), %eax
    427   movl  %eax, (%esp)
    428 
    429   call    ASM_PFX(X11GetKey)
    430 
    431   leave
    432   ret
    433 
    434 
    435 ASM_GLOBAL ASM_PFX(GasketX11KeySetState)
    436 ASM_PFX(GasketX11KeySetState):
    437   pushl %ebp
    438   movl  %esp, %ebp
    439   subl  $24, %esp      // sub extra 16 from the stack for alignment
    440   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    441   movl  12(%ebp), %eax
    442   movl  %eax, 4(%esp)
    443   movl  8(%ebp), %eax
    444   movl  %eax, (%esp)
    445 
    446   call    ASM_PFX(X11KeySetState)
    447 
    448   leave
    449   ret
    450 
    451 
    452 ASM_GLOBAL ASM_PFX(GasketX11RegisterKeyNotify)
    453 ASM_PFX(GasketX11RegisterKeyNotify):
    454 	pushl	%ebp
    455 	movl	%esp, %ebp
    456   subl  $40, %esp      // sub extra 16 from the stack for alignment
    457   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    458 	movl	20(%ebp), %eax
    459 	movl	%eax, 12(%esp)
    460 	movl	16(%ebp), %eax
    461 	movl	%eax, 8(%esp)
    462 	movl	12(%ebp), %eax
    463 	movl	%eax, 4(%esp)
    464 	movl	8(%ebp), %eax
    465 	movl	%eax, (%esp)
    466 
    467   call    ASM_PFX(X11RegisterKeyNotify)
    468 
    469   leave
    470   ret
    471 
    472 
    473 ASM_GLOBAL ASM_PFX(GasketX11Blt)
    474 ASM_PFX(GasketX11Blt):
    475 	pushl	%ebp
    476 	movl	%esp, %ebp
    477   subl  $40, %esp      // sub extra 16 from the stack for alignment
    478   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    479 	movl	20(%ebp), %eax
    480 	movl	%eax, 12(%esp)
    481 	movl	16(%ebp), %eax
    482 	movl	%eax, 8(%esp)
    483 	movl	12(%ebp), %eax
    484 	movl	%eax, 4(%esp)
    485 	movl	8(%ebp), %eax
    486 	movl	%eax, (%esp)
    487 
    488   call    ASM_PFX(X11Blt)
    489 
    490   leave
    491   ret
    492 
    493 
    494 ASM_GLOBAL ASM_PFX(GasketX11CheckPointer)
    495 ASM_PFX(GasketX11CheckPointer):
    496   pushl %ebp
    497   movl  %esp, %ebp
    498   subl  $24, %esp      // sub extra 16 from the stack for alignment
    499   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    500   movl  8(%ebp), %eax
    501   movl  %eax, (%esp)
    502 
    503   call    ASM_PFX(X11CheckPointer)
    504 
    505   leave
    506   ret
    507 
    508 
    509 ASM_GLOBAL ASM_PFX(GasketX11GetPointerState)
    510 ASM_PFX(GasketX11GetPointerState):
    511   pushl %ebp
    512   movl  %esp, %ebp
    513   subl  $24, %esp      // sub extra 16 from the stack for alignment
    514   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    515   movl  12(%ebp), %eax
    516   movl  %eax, 4(%esp)
    517   movl  8(%ebp), %eax
    518   movl  %eax, (%esp)
    519 
    520   call    ASM_PFX(X11GetPointerState)
    521 
    522   leave
    523   ret
    524 
    525 
    526 ASM_GLOBAL ASM_PFX(GasketX11GraphicsWindowOpen)
    527 ASM_PFX(GasketX11GraphicsWindowOpen):
    528   pushl %ebp
    529   movl  %esp, %ebp
    530   subl  $24, %esp      // sub extra 16 from the stack for alignment
    531   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    532   movl  8(%ebp), %eax
    533   movl  %eax, (%esp)
    534 
    535   call    ASM_PFX(X11GraphicsWindowOpen)
    536 
    537   leave
    538   ret
    539 
    540 
    541 ASM_GLOBAL ASM_PFX(GasketX11GraphicsWindowClose)
    542 ASM_PFX(GasketX11GraphicsWindowClose):
    543   pushl %ebp
    544   movl  %esp, %ebp
    545   subl  $24, %esp      // sub extra 16 from the stack for alignment
    546   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    547   movl  12(%ebp), %eax
    548   movl  %eax, 4(%esp)
    549   movl  8(%ebp), %eax
    550   movl  %eax, (%esp)
    551 
    552   call    ASM_PFX(X11GraphicsWindowClose)
    553 
    554   leave
    555   ret
    556 
    557 
    558 // Pthreads
    559 
    560 ASM_GLOBAL ASM_PFX(GasketPthreadMutexLock)
    561 ASM_PFX(GasketPthreadMutexLock):
    562   pushl %ebp
    563   movl  %esp, %ebp
    564   subl  $24, %esp      // sub extra 16 from the stack for alignment
    565   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    566   movl  8(%ebp), %eax
    567   movl  %eax, (%esp)
    568 
    569   call    ASM_PFX(PthreadMutexLock)
    570 
    571   leave
    572   ret
    573 
    574 
    575 ASM_GLOBAL ASM_PFX(GasketPthreadMutexUnLock)
    576 ASM_PFX(GasketPthreadMutexUnLock):
    577   pushl %ebp
    578   movl  %esp, %ebp
    579   subl  $24, %esp      // sub extra 16 from the stack for alignment
    580   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    581   movl  8(%ebp), %eax
    582   movl  %eax, (%esp)
    583 
    584   call    ASM_PFX(PthreadMutexUnLock)
    585 
    586   leave
    587   ret
    588 
    589 ASM_GLOBAL ASM_PFX(GasketPthreadMutexTryLock)
    590 ASM_PFX(GasketPthreadMutexTryLock):
    591   pushl %ebp
    592   movl  %esp, %ebp
    593   subl  $24, %esp      // sub extra 16 from the stack for alignment
    594   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    595   movl  8(%ebp), %eax
    596   movl  %eax, (%esp)
    597 
    598   call    ASM_PFX(PthreadMutexTryLock)
    599 
    600   leave
    601   ret
    602 
    603 ASM_GLOBAL ASM_PFX(GasketPthreadMutexInit)
    604 ASM_PFX(GasketPthreadMutexInit):
    605   pushl %ebp
    606   movl  %esp, %ebp
    607   subl  $24, %esp      // sub extra 16 from the stack for alignment
    608   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    609 
    610   call    ASM_PFX(PthreadMutexInit)
    611 
    612   leave
    613   ret
    614 
    615 
    616 
    617 ASM_GLOBAL ASM_PFX(GasketPthreadMutexDestroy)
    618 ASM_PFX(GasketPthreadMutexDestroy):
    619   pushl %ebp
    620   movl  %esp, %ebp
    621   subl  $24, %esp      // sub extra 16 from the stack for alignment
    622   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    623   movl  8(%ebp), %eax
    624   movl  %eax, (%esp)
    625 
    626   call    ASM_PFX(PthreadMutexDestroy)
    627 
    628   leave
    629   ret
    630 
    631 
    632 ASM_GLOBAL ASM_PFX(GasketPthreadCreate)
    633 ASM_PFX(GasketPthreadCreate):
    634 	pushl	%ebp
    635 	movl	%esp, %ebp
    636   subl  $40, %esp      // sub extra 16 from the stack for alignment
    637   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    638 	movl	20(%ebp), %eax
    639 	movl	%eax, 12(%esp)
    640 	movl	16(%ebp), %eax
    641 	movl	%eax, 8(%esp)
    642 	movl	12(%ebp), %eax
    643 	movl	%eax, 4(%esp)
    644 	movl	8(%ebp), %eax
    645 	movl	%eax, (%esp)
    646 
    647   call    ASM_PFX(PthreadCreate)
    648 
    649   leave
    650   ret
    651 
    652 
    653 ASM_GLOBAL ASM_PFX(GasketPthreadExit)
    654 ASM_PFX(GasketPthreadExit):
    655   pushl %ebp
    656   movl  %esp, %ebp
    657   subl  $24, %esp      // sub extra 16 from the stack for alignment
    658   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    659   movl  8(%ebp), %eax
    660   movl  %eax, (%esp)
    661 
    662   call    ASM_PFX(PthreadExit)
    663 
    664   leave
    665   ret
    666 
    667 
    668 
    669 ASM_GLOBAL ASM_PFX(GasketPthreadSelf)
    670 ASM_PFX(GasketPthreadSelf):
    671   pushl %ebp
    672   movl  %esp, %ebp
    673   subl  $24, %esp      // sub extra 16 from the stack for alignment
    674   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    675 
    676   call    ASM_PFX(PthreadSelf)
    677 
    678   leave
    679   ret
    680 
    681 
    682 ASM_GLOBAL ASM_PFX(GasketPthreadOpen)
    683 ASM_PFX(GasketPthreadOpen):
    684   pushl %ebp
    685   movl  %esp, %ebp
    686   subl  $24, %esp      // sub extra 16 from the stack for alignment
    687   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    688   movl  8(%ebp), %eax
    689   movl  %eax, (%esp)
    690 
    691   call    ASM_PFX(PthreadOpen)
    692 
    693   leave
    694   ret
    695 
    696 
    697 ASM_GLOBAL ASM_PFX(GasketPthreadClose)
    698 ASM_PFX(GasketPthreadClose):
    699   pushl %ebp
    700   movl  %esp, %ebp
    701   subl  $24, %esp      // sub extra 16 from the stack for alignment
    702   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    703   movl  8(%ebp), %eax
    704   movl  %eax, (%esp)
    705 
    706   call    ASM_PFX(PthreadClose)
    707 
    708   leave
    709   ret
    710 
    711 
    712 
    713 
    714 //
    715 // UNIX ABI to EFI ABI call
    716 //
    717 // UINTN
    718 // ReverseGasketUint64 (
    719 //   void *Api,
    720 //   UINTN Arg1
    721 //   );
    722 ASM_GLOBAL ASM_PFX(ReverseGasketUint64)
    723 ASM_PFX(ReverseGasketUint64):
    724 	pushl	%ebp
    725 	movl	%esp, %ebp
    726 	subl	$8, %esp
    727 	movl	16(%ebp), %eax
    728 	movl	%eax, 4(%esp)
    729 	movl	12(%ebp), %eax
    730 	movl	%eax, (%esp)
    731 	calll	*8(%ebp)
    732 	addl	$8, %esp
    733 	popl	%ebp
    734 	ret
    735 
    736 
    737 
    738 //
    739 // UNIX ABI to EFI ABI call
    740 //
    741 // UINTN
    742 // ReverseGasketUint64Uint64 (
    743 //   void *Api,
    744 //   UINTN Arg1
    745 //   UINTN Arg2
    746 //   );
    747 ASM_GLOBAL ASM_PFX(ReverseGasketUint64Uint64)
    748 ASM_PFX(ReverseGasketUint64Uint64):
    749 	pushl	%ebp
    750 	movl	%esp, %ebp
    751 	subl	$24, %esp
    752 	movl	24(%ebp), %eax
    753 	movl	%eax, 12(%esp)
    754 	movl	20(%ebp), %eax
    755 	movl	%eax, 8(%esp)
    756 	movl	16(%ebp), %eax
    757 	movl	%eax, 4(%esp)
    758 	movl	12(%ebp), %eax
    759 	movl	%eax, (%esp)
    760 	calll	*8(%ebp)
    761 	addl	$24, %esp
    762 	popl	%ebp
    763 	ret
    764 
    765 
    766 ASM_GLOBAL ASM_PFX(GasketSecUnixPeiAutoScan)
    767 ASM_PFX(GasketSecUnixPeiAutoScan):
    768 	pushl	%ebp
    769 	movl	%esp, %ebp
    770   subl  $40, %esp      // sub extra 16 from the stack for alignment
    771   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    772 	movl	16(%ebp), %eax
    773 	movl	%eax, 8(%esp)
    774 	movl	12(%ebp), %eax
    775 	movl	%eax, 4(%esp)
    776 	movl	8(%ebp), %eax
    777 	movl	%eax, (%esp)
    778 
    779   call    ASM_PFX(SecUnixPeiAutoScan)
    780 
    781   leave
    782   ret
    783 
    784 
    785 ASM_GLOBAL ASM_PFX(GasketSecUnixFdAddress)
    786 ASM_PFX(GasketSecUnixFdAddress):
    787 	pushl	%ebp
    788 	movl	%esp, %ebp
    789   subl  $40, %esp      // sub extra 16 from the stack for alignment
    790   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    791 	movl	20(%ebp), %eax
    792 	movl	%eax, 12(%esp)
    793 	movl	16(%ebp), %eax
    794 	movl	%eax, 8(%esp)
    795 	movl	12(%ebp), %eax
    796 	movl	%eax, 4(%esp)
    797 	movl	8(%ebp), %eax
    798 	movl	%eax, (%esp)
    799 
    800   call    ASM_PFX(SecUnixFdAddress)
    801 
    802   leave
    803   ret
    804 
    805 
    806 // EmuIoThunk SimpleFileSystem
    807 
    808 ASM_GLOBAL ASM_PFX(GasketPosixOpenVolume)
    809 ASM_PFX(GasketPosixOpenVolume):
    810 	pushl	%ebp
    811 	movl	%esp, %ebp
    812   subl  $40, %esp      // sub extra 16 from the stack for alignment
    813   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    814 	movl	20(%ebp), %eax
    815 	movl	%eax, 12(%esp)
    816 	movl	16(%ebp), %eax
    817 	movl	%eax, 8(%esp)
    818 	movl	12(%ebp), %eax
    819 	movl	%eax, 4(%esp)
    820 	movl	8(%ebp), %eax
    821 	movl	%eax, (%esp)
    822 
    823   call    ASM_PFX(PosixOpenVolume)
    824 
    825   leave
    826   ret
    827 
    828 
    829 ASM_GLOBAL ASM_PFX(GasketPosixFileOpen)
    830 ASM_PFX(GasketPosixFileOpen):
    831 	pushl	%ebp
    832 	movl	%esp, %ebp
    833   subl  $56, %esp      // sub extra 16 from the stack for alignment
    834   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    835 	movl	28(%ebp), %eax
    836 	movl	32(%ebp), %ecx
    837 	movl	%ecx, 24(%esp)
    838 	movl	%eax, 20(%esp)
    839 	movl	20(%ebp), %eax
    840 	movl	24(%ebp), %ecx
    841 	movl	%ecx, 16(%esp)
    842 	movl	%eax, 12(%esp)
    843 	movl	16(%ebp), %eax
    844 	movl	%eax, 8(%esp)
    845 	movl	12(%ebp), %eax
    846 	movl	%eax, 4(%esp)
    847 	movl	8(%ebp), %eax
    848 	movl	%eax, (%esp)
    849 
    850   call    ASM_PFX(PosixFileOpen)
    851 
    852   leave
    853   ret
    854 
    855 
    856 ASM_GLOBAL ASM_PFX(GasketPosixFileCLose)
    857 ASM_PFX(GasketPosixFileCLose):
    858   pushl %ebp
    859   movl  %esp, %ebp
    860   subl  $24, %esp      // sub extra 16 from the stack for alignment
    861   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    862   movl  8(%ebp), %eax
    863   movl  %eax, (%esp)
    864 
    865   call    ASM_PFX(PosixFileCLose)
    866 
    867   leave
    868   ret
    869 
    870 
    871 ASM_GLOBAL ASM_PFX(GasketPosixFileDelete)
    872 ASM_PFX(GasketPosixFileDelete):
    873   pushl %ebp
    874   movl  %esp, %ebp
    875   subl  $24, %esp      // sub extra 16 from the stack for alignment
    876   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    877   movl  8(%ebp), %eax
    878   movl  %eax, (%esp)
    879 
    880   call    ASM_PFX(PosixFileDelete)
    881 
    882   leave
    883   ret
    884 
    885 
    886 ASM_GLOBAL ASM_PFX(GasketPosixFileRead)
    887 ASM_PFX(GasketPosixFileRead):
    888 	pushl	%ebp
    889 	movl	%esp, %ebp
    890   subl  $40, %esp      // sub extra 16 from the stack for alignment
    891   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    892 	movl	16(%ebp), %eax
    893 	movl	%eax, 8(%esp)
    894 	movl	12(%ebp), %eax
    895 	movl	%eax, 4(%esp)
    896 	movl	8(%ebp), %eax
    897 	movl	%eax, (%esp)
    898 
    899   call    ASM_PFX(PosixFileRead)
    900 
    901   leave
    902   ret
    903 
    904 
    905 ASM_GLOBAL ASM_PFX(GasketPosixFileWrite)
    906 ASM_PFX(GasketPosixFileWrite):
    907 	pushl	%ebp
    908 	movl	%esp, %ebp
    909   subl  $40, %esp      // sub extra 16 from the stack for alignment
    910   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    911 	movl	16(%ebp), %eax
    912 	movl	%eax, 8(%esp)
    913 	movl	12(%ebp), %eax
    914 	movl	%eax, 4(%esp)
    915 	movl	8(%ebp), %eax
    916 	movl	%eax, (%esp)
    917 
    918   call    ASM_PFX(PosixFileWrite)
    919 
    920   leave
    921   ret
    922 
    923 
    924 ASM_GLOBAL ASM_PFX(GasketPosixFileSetPossition)
    925 ASM_PFX(GasketPosixFileSetPossition):
    926   pushl %ebp
    927   movl  %esp, %ebp
    928   subl  $40, %esp      // sub extra 16 from the stack for alignment
    929   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    930 	movl	12(%ebp), %eax
    931 	movl	16(%ebp), %ecx
    932 	movl	%ecx, 8(%esp)
    933 	movl	%eax, 4(%esp)
    934 	movl	8(%ebp), %eax
    935 	movl	%eax, (%esp)
    936 
    937   call    ASM_PFX(PosixFileSetPossition)
    938 
    939   leave
    940   ret
    941 
    942 
    943 ASM_GLOBAL ASM_PFX(GasketPosixFileGetPossition)
    944 ASM_PFX(GasketPosixFileGetPossition):
    945   pushl %ebp
    946   movl  %esp, %ebp
    947   subl  $24, %esp      // sub extra 16 from the stack for alignment
    948   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    949   movl  12(%ebp), %eax
    950   movl  %eax, 4(%esp)
    951   movl  8(%ebp), %eax
    952   movl  %eax, (%esp)
    953 
    954   call    ASM_PFX(PosixFileGetPossition)
    955 
    956   leave
    957   ret
    958 
    959 
    960 ASM_GLOBAL ASM_PFX(GasketPosixFileGetInfo)
    961 ASM_PFX(GasketPosixFileGetInfo):
    962 	pushl	%ebp
    963 	movl	%esp, %ebp
    964   subl  $40, %esp      // sub extra 16 from the stack for alignment
    965   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    966 	movl	20(%ebp), %eax
    967 	movl	%eax, 12(%esp)
    968 	movl	16(%ebp), %eax
    969 	movl	%eax, 8(%esp)
    970 	movl	12(%ebp), %eax
    971 	movl	%eax, 4(%esp)
    972 	movl	8(%ebp), %eax
    973 	movl	%eax, (%esp)
    974 
    975   call    ASM_PFX(PosixFileGetInfo)
    976 
    977   leave
    978   ret
    979 
    980 
    981 ASM_GLOBAL ASM_PFX(GasketPosixFileSetInfo)
    982 ASM_PFX(GasketPosixFileSetInfo):
    983 	pushl	%ebp
    984 	movl	%esp, %ebp
    985   subl  $40, %esp      // sub extra 16 from the stack for alignment
    986   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
    987 	movl	20(%ebp), %eax
    988 	movl	%eax, 12(%esp)
    989 	movl	16(%ebp), %eax
    990 	movl	%eax, 8(%esp)
    991 	movl	12(%ebp), %eax
    992 	movl	%eax, 4(%esp)
    993 	movl	8(%ebp), %eax
    994 	movl	%eax, (%esp)
    995 
    996   call    ASM_PFX(PosixFileSetInfo)
    997 
    998   leave
    999   ret
   1000 
   1001 
   1002 ASM_GLOBAL ASM_PFX(GasketPosixFileFlush)
   1003 ASM_PFX(GasketPosixFileFlush):
   1004   pushl %ebp
   1005   movl  %esp, %ebp
   1006   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1007   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1008   movl  8(%ebp), %eax
   1009   movl  %eax, (%esp)
   1010 
   1011   call    ASM_PFX(PosixFileFlush)
   1012 
   1013   leave
   1014   ret
   1015 
   1016 
   1017 ASM_GLOBAL ASM_PFX(GasketPosixFileSystmeThunkOpen)
   1018 ASM_PFX(GasketPosixFileSystmeThunkOpen):
   1019   pushl %ebp
   1020   movl  %esp, %ebp
   1021   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1022   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1023   movl  8(%ebp), %eax
   1024   movl  %eax, (%esp)
   1025 
   1026   call    ASM_PFX(PosixFileSystmeThunkOpen)
   1027 
   1028   leave
   1029   ret
   1030 
   1031 
   1032 ASM_GLOBAL ASM_PFX(GasketPosixFileSystmeThunkClose)
   1033 ASM_PFX(GasketPosixFileSystmeThunkClose):
   1034   pushl %ebp
   1035   movl  %esp, %ebp
   1036   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1037   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1038   movl  8(%ebp), %eax
   1039   movl  %eax, (%esp)
   1040 
   1041   call    ASM_PFX(PosixFileSystmeThunkClose)
   1042 
   1043   leave
   1044   ret
   1045 
   1046 ASM_GLOBAL ASM_PFX(GasketEmuBlockIoReset)
   1047 ASM_PFX(GasketEmuBlockIoReset):
   1048   pushl %ebp
   1049   movl  %esp, %ebp
   1050   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1051   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1052   movl  12(%ebp), %eax
   1053   movl  %eax, 4(%esp)
   1054   movl  8(%ebp), %eax
   1055   movl  %eax, (%esp)
   1056 
   1057   call    ASM_PFX(EmuBlockIoReset)
   1058 
   1059   leave
   1060   ret
   1061 
   1062 
   1063 ASM_GLOBAL ASM_PFX(GasketEmuBlockIoReadBlocks)
   1064 ASM_PFX(GasketEmuBlockIoReadBlocks):
   1065 	pushl	%ebp
   1066 	movl	%esp, %ebp
   1067   subl  $56, %esp      // sub extra 16 from the stack for alignment
   1068   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1069 	movl	32(%ebp), %eax
   1070 	movl	%eax, 24(%esp)
   1071 	movl	28(%ebp), %eax
   1072 	movl	%eax, 20(%esp)
   1073 	movl	24(%ebp), %eax
   1074 	movl	%eax, 16(%esp)
   1075 	movl	16(%ebp), %eax
   1076 	movl	20(%ebp), %edx
   1077 	movl	%edx, 12(%esp)
   1078 	movl	%eax, 8(%esp)
   1079 	movl	12(%ebp), %eax
   1080 	movl	%eax, 4(%esp)
   1081 	movl	8(%ebp), %eax
   1082 	movl	%eax, (%esp)
   1083 
   1084   call    ASM_PFX(EmuBlockIoReadBlocks)
   1085 
   1086   leave
   1087   ret
   1088 
   1089 
   1090 ASM_GLOBAL ASM_PFX(GasketEmuBlockIoWriteBlocks)
   1091 ASM_PFX(GasketEmuBlockIoWriteBlocks):
   1092 	pushl	%ebp
   1093 	movl	%esp, %ebp
   1094   subl  $56, %esp      // sub extra 16 from the stack for alignment
   1095   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1096 	movl	32(%ebp), %eax
   1097 	movl	%eax, 24(%esp)
   1098 	movl	28(%ebp), %eax
   1099 	movl	%eax, 20(%esp)
   1100 	movl	24(%ebp), %eax
   1101 	movl	%eax, 16(%esp)
   1102 	movl	16(%ebp), %eax
   1103 	movl	20(%ebp), %edx
   1104 	movl	%edx, 12(%esp)
   1105 	movl	%eax, 8(%esp)
   1106 	movl	12(%ebp), %eax
   1107 	movl	%eax, 4(%esp)
   1108 	movl	8(%ebp), %eax
   1109 	movl	%eax, (%esp)
   1110 
   1111   call    ASM_PFX(EmuBlockIoWriteBlocks)
   1112 
   1113   leave
   1114   ret
   1115 
   1116 
   1117 ASM_GLOBAL ASM_PFX(GasketEmuBlockIoFlushBlocks)
   1118 ASM_PFX(GasketEmuBlockIoFlushBlocks):  pushl %ebp
   1119   movl  %esp, %ebp
   1120   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1121   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1122   movl  12(%ebp), %eax
   1123   movl  %eax, 4(%esp)
   1124   movl  8(%ebp), %eax
   1125   movl  %eax, (%esp)
   1126 
   1127 
   1128   call    ASM_PFX(EmuBlockIoFlushBlocks)
   1129 
   1130   leave
   1131   ret
   1132 
   1133 
   1134 ASM_GLOBAL ASM_PFX(GasketEmuBlockIoCreateMapping)
   1135 ASM_PFX(GasketEmuBlockIoCreateMapping):
   1136   pushl %ebp
   1137   movl  %esp, %ebp
   1138   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1139   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1140   movl  12(%ebp), %eax
   1141   movl  %eax, 4(%esp)
   1142   movl  8(%ebp), %eax
   1143   movl  %eax, (%esp)
   1144 
   1145   call    ASM_PFX(EmuBlockIoCreateMapping)
   1146 
   1147   leave
   1148   ret
   1149 
   1150 
   1151 ASM_GLOBAL ASM_PFX(GasketBlockIoThunkOpen)
   1152 ASM_PFX(GasketBlockIoThunkOpen):
   1153   pushl %ebp
   1154   movl  %esp, %ebp
   1155   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1156   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1157   movl  8(%ebp), %eax
   1158   movl  %eax, (%esp)
   1159 
   1160   call    ASM_PFX(EmuBlockIoThunkOpen)
   1161 
   1162   leave
   1163   ret
   1164 
   1165 
   1166 ASM_GLOBAL ASM_PFX(GasketBlockIoThunkClose)
   1167 ASM_PFX(GasketBlockIoThunkClose):
   1168   pushl %ebp
   1169   movl  %esp, %ebp
   1170   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1171   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1172   movl  8(%ebp), %eax
   1173   movl  %eax, (%esp)
   1174 
   1175   call    ASM_PFX(EmuBlockIoThunkClose)
   1176 
   1177   leave
   1178   ret
   1179 
   1180 
   1181 
   1182 ASM_GLOBAL ASM_PFX(GasketSnpCreateMapping)
   1183 ASM_PFX(GasketSnpCreateMapping):
   1184   pushl %ebp
   1185   movl  %esp, %ebp
   1186   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1187   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1188   movl  12(%ebp), %eax
   1189   movl  %eax, 4(%esp)
   1190   movl  8(%ebp), %eax
   1191   movl  %eax, (%esp)
   1192 
   1193   call    ASM_PFX(EmuSnpCreateMapping)
   1194 
   1195   leave
   1196   ret
   1197 
   1198 
   1199 ASM_GLOBAL ASM_PFX(GasketSnpStart)
   1200 ASM_PFX(GasketSnpStart):
   1201   pushl %ebp
   1202   movl  %esp, %ebp
   1203   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1204   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1205   movl  8(%ebp), %eax
   1206   movl  %eax, (%esp)
   1207 
   1208   call    ASM_PFX(EmuSnpStart)
   1209 
   1210   leave
   1211   ret
   1212 
   1213 
   1214 ASM_GLOBAL ASM_PFX(GasketSnpStop)
   1215 ASM_PFX(GasketSnpStop):
   1216   pushl %ebp
   1217   movl  %esp, %ebp
   1218   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1219   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1220   movl  8(%ebp), %eax
   1221   movl  %eax, (%esp)
   1222 
   1223   call    ASM_PFX(EmuSnpStop)
   1224 
   1225   leave
   1226   ret
   1227 
   1228 
   1229 ASM_GLOBAL ASM_PFX(GasketSnpInitialize)
   1230 ASM_PFX(GasketSnpInitialize):
   1231 	pushl	%ebp
   1232 	movl	%esp, %ebp
   1233   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1234   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1235 	movl	16(%ebp), %eax
   1236 	movl	%eax, 8(%esp)
   1237 	movl	12(%ebp), %eax
   1238 	movl	%eax, 4(%esp)
   1239 	movl	8(%ebp), %eax
   1240 	movl	%eax, (%esp)
   1241 
   1242   call    ASM_PFX(EmuSnpInitialize)
   1243 
   1244   leave
   1245   ret
   1246 
   1247 
   1248 ASM_GLOBAL ASM_PFX(GasketSnpReset)
   1249 ASM_PFX(GasketSnpReset):
   1250   pushl %ebp
   1251   movl  %esp, %ebp
   1252   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1253   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1254   movl  12(%ebp), %eax
   1255   movl  %eax, 4(%esp)
   1256   movl  8(%ebp), %eax
   1257   movl  %eax, (%esp)
   1258 
   1259   call    ASM_PFX(EmuSnpReset)
   1260 
   1261   leave
   1262   ret
   1263 
   1264 
   1265 ASM_GLOBAL ASM_PFX(GasketSnpShutdown)
   1266 ASM_PFX(GasketSnpShutdown):
   1267   pushl %ebp
   1268   movl  %esp, %ebp
   1269   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1270   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1271   movl  8(%ebp), %eax
   1272   movl  %eax, (%esp)
   1273 
   1274   call    ASM_PFX(EmuSnpShutdown)
   1275 
   1276   leave
   1277   ret
   1278 
   1279 
   1280 ASM_GLOBAL ASM_PFX(GasketSnpReceiveFilters)
   1281 ASM_PFX(GasketSnpReceiveFilters):
   1282 	pushl	%ebp
   1283 	movl	%esp, %ebp
   1284   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1285   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1286 	movl	28(%ebp), %eax
   1287 	movl	%eax, 20(%esp)
   1288 	movl	24(%ebp), %eax
   1289 	movl	%eax, 16(%esp)
   1290 	movl	20(%ebp), %eax
   1291 	movl	%eax, 12(%esp)
   1292 	movl	16(%ebp), %eax
   1293 	movl	%eax, 8(%esp)
   1294 	movl	12(%ebp), %eax
   1295 	movl	%eax, 4(%esp)
   1296 	movl	8(%ebp), %eax
   1297 	movl	%eax, (%esp)
   1298 
   1299   call    ASM_PFX(EmuSnpReceiveFilters)
   1300 
   1301   leave
   1302   ret
   1303 
   1304 
   1305 ASM_GLOBAL ASM_PFX(GasketSnpStationAddress)
   1306 ASM_PFX(GasketSnpStationAddress):
   1307 	pushl	%ebp
   1308 	movl	%esp, %ebp
   1309   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1310   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1311 	movl	16(%ebp), %eax
   1312 	movl	%eax, 8(%esp)
   1313 	movl	12(%ebp), %eax
   1314 	movl	%eax, 4(%esp)
   1315 	movl	8(%ebp), %eax
   1316 	movl	%eax, (%esp)
   1317 
   1318   leave
   1319   ret
   1320 
   1321 
   1322 
   1323 ASM_GLOBAL ASM_PFX(GasketSnpStatistics)
   1324 ASM_PFX(GasketSnpStatistics):
   1325 	pushl	%ebp
   1326 	movl	%esp, %ebp
   1327   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1328   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1329 	movl	20(%ebp), %eax
   1330 	movl	%eax, 12(%esp)
   1331 	movl	16(%ebp), %eax
   1332 	movl	%eax, 8(%esp)
   1333 	movl	12(%ebp), %eax
   1334 	movl	%eax, 4(%esp)
   1335 	movl	8(%ebp), %eax
   1336 	movl	%eax, (%esp)
   1337 
   1338   call    ASM_PFX(EmuSnpStatistics)
   1339 
   1340   leave
   1341   ret
   1342 
   1343 
   1344 ASM_GLOBAL ASM_PFX(GasketSnpMCastIpToMac)
   1345 ASM_PFX(GasketSnpMCastIpToMac):
   1346 	pushl	%ebp
   1347 	movl	%esp, %ebp
   1348   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1349   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1350 	movl	20(%ebp), %eax
   1351 	movl	%eax, 12(%esp)
   1352 	movl	16(%ebp), %eax
   1353 	movl	%eax, 8(%esp)
   1354 	movl	12(%ebp), %eax
   1355 	movl	%eax, 4(%esp)
   1356 	movl	8(%ebp), %eax
   1357 	movl	%eax, (%esp)
   1358 
   1359   call    ASM_PFX(EmuSnpMCastIpToMac)
   1360 
   1361   leave
   1362   ret
   1363 
   1364 
   1365 ASM_GLOBAL ASM_PFX(GasketSnpNvData)
   1366 ASM_PFX(GasketSnpNvData):
   1367 	pushl	%ebp
   1368 	movl	%esp, %ebp
   1369   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1370   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1371 	movl	24(%ebp), %eax
   1372 	movl	%eax, 16(%esp)
   1373 	movl	20(%ebp), %eax
   1374 	movl	%eax, 12(%esp)
   1375 	movl	16(%ebp), %eax
   1376 	movl	%eax, 8(%esp)
   1377 	movl	12(%ebp), %eax
   1378 	movl	%eax, 4(%esp)
   1379 	movl	8(%ebp), %eax
   1380 	movl	%eax, (%esp)
   1381 
   1382   call    ASM_PFX(EmuSnpNvData)
   1383 
   1384   leave
   1385   ret
   1386 
   1387 
   1388 ASM_GLOBAL ASM_PFX(GasketSnpGetStatus)
   1389 ASM_PFX(GasketSnpGetStatus):
   1390 	pushl	%ebp
   1391 	movl	%esp, %ebp
   1392   subl  $40, %esp      // sub extra 16 from the stack for alignment
   1393   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1394 	movl	16(%ebp), %eax
   1395 	movl	%eax, 8(%esp)
   1396 	movl	12(%ebp), %eax
   1397 	movl	%eax, 4(%esp)
   1398 	movl	8(%ebp), %eax
   1399 	movl	%eax, (%esp)
   1400 
   1401   call    ASM_PFX(EmuSnpGetStatus)
   1402 
   1403   leave
   1404   ret
   1405 
   1406 
   1407 
   1408 ASM_GLOBAL ASM_PFX(GasketSnpTransmit)
   1409 ASM_PFX(GasketSnpTransmit):
   1410 	pushl	%ebp
   1411 	movl	%esp, %ebp
   1412   subl  $56, %esp      // sub extra 16 from the stack for alignment
   1413   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1414 	movl	32(%ebp), %eax
   1415 	movl	%eax, 24(%esp)
   1416 	movl	28(%ebp), %eax
   1417 	movl	%eax, 20(%esp)
   1418 	movl	24(%ebp), %eax
   1419 	movl	%eax, 16(%esp)
   1420 	movl	20(%ebp), %eax
   1421 	movl	%eax, 12(%esp)
   1422 	movl	16(%ebp), %eax
   1423 	movl	%eax, 8(%esp)
   1424 	movl	12(%ebp), %eax
   1425 	movl	%eax, 4(%esp)
   1426 	movl	8(%ebp), %eax
   1427 	movl	%eax, (%esp)
   1428 
   1429   call    ASM_PFX(EmuSnpTransmit)
   1430 
   1431   leave
   1432   ret
   1433 
   1434 
   1435 
   1436 ASM_GLOBAL ASM_PFX(GasketSnpReceive)
   1437 ASM_PFX(GasketSnpReceive):
   1438 	pushl	%ebp
   1439 	movl	%esp, %ebp
   1440   subl  $56, %esp      // sub extra 16 from the stack for alignment
   1441   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1442 	movl	32(%ebp), %eax
   1443 	movl	%eax, 24(%esp)
   1444 	movl	28(%ebp), %eax
   1445 	movl	%eax, 20(%esp)
   1446 	movl	24(%ebp), %eax
   1447 	movl	%eax, 16(%esp)
   1448 	movl	20(%ebp), %eax
   1449 	movl	%eax, 12(%esp)
   1450 	movl	16(%ebp), %eax
   1451 	movl	%eax, 8(%esp)
   1452 	movl	12(%ebp), %eax
   1453 	movl	%eax, 4(%esp)
   1454 	movl	8(%ebp), %eax
   1455 	movl	%eax, (%esp)
   1456 
   1457   call    ASM_PFX(EmuSnpReceive)
   1458 
   1459   leave
   1460   ret
   1461 
   1462 
   1463 ASM_GLOBAL ASM_PFX(GasketSnpThunkOpen)
   1464 ASM_PFX(GasketSnpThunkOpen):
   1465   pushl %ebp
   1466   movl  %esp, %ebp
   1467   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1468   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1469   movl  8(%ebp), %eax
   1470   movl  %eax, (%esp)
   1471 
   1472   call    ASM_PFX(EmuSnpThunkOpen)
   1473 
   1474   leave
   1475   ret
   1476 
   1477 
   1478 ASM_GLOBAL ASM_PFX(GasketSnpThunkClose)
   1479 ASM_PFX(GasketSnpThunkClose):
   1480   pushl %ebp
   1481   movl  %esp, %ebp
   1482   subl  $24, %esp      // sub extra 16 from the stack for alignment
   1483   and   $-16, %esp    // stack needs to end in 0xFFFFFFF0 before call
   1484   movl  8(%ebp), %eax
   1485   movl  %eax, (%esp)
   1486 
   1487   call    ASM_PFX(EmuSnpThunkClose)
   1488 
   1489   leave
   1490   ret
   1491 
   1492 
   1493