InOsEmuPkg/Unix/Sec/Ia32/Gasket.S

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