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