MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S

   1 #/** @file
   2 #
   3 #    This code provides low level routines that support the Virtual Machine
   4 #   for option ROMs.
   5 #
   6 #  Copyright (c) 2007 - 2008, Intel Corporation. <BR>
   7 #  All rights reserved. This program and the accompanying materials
   8 #  are licensed and made available under the terms and conditions of the BSD License
   9 #  which accompanies this distribution.  The full text of the license may be found at
  10 #  http://opensource.org/licenses/bsd-license.php
  11 #
  12 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14 #
  15 #**/
  16
  17 #---------------------------------------------------------------------------
  18 # Equate files needed.
  19 #---------------------------------------------------------------------------
  20
  21 #---------------------------------------------------------------------------
  22 ##GenericPostSegment      SEGMENT USE16
  23 #---------------------------------------------------------------------------
  24
  25 #****************************************************************************
  26 # EbcLLCALLEX
  27 #
  28 # This function is called to execute an EBC CALLEX instruction.
  29 # This instruction requires that we thunk out to external native
  30 # code. For x64, we switch stacks, copy the arguments to the stack
  31 # and jump to the specified function.
  32 # On return, we restore the stack pointer to its original location.
  33 #
  34 # Destroys no working registers.
  35 #****************************************************************************
  36 ASM_GLOBAL _CopyMem;
  37
  38 # VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
  39 ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
  40 ASM_PFX(EbcLLCALLEXNative):
  41       push   %rbp
  42       push   %rbx
  43       mov    %rsp, %rbp
  44       # Function prolog
  45
  46       # Copy FuncAddr to a preserved register.
  47       mov    %rcx, %rbx
  48
  49       # Set stack pointer to new value
  50       sub    %r8,  %rdx
  51       sub    %rsp, %r8
  52       mov    %rsp, %rcx
  53       sub    %rsp, 0x20
  54       call   ASM_PFX(CopyMem)
  55       add    %rsp, 0x20
  56
  57       # Considering the worst case, load 4 potiential arguments
  58       # into registers.
  59       mov    (%rsp), %rcx
  60       mov    8(%rsp), %rdx
  61       mov    10(%rsp), %r8
  62       mov    18(%rsp), %r9
  63
  64       # Now call the external routine
  65       call  *%rbx
  66
  67       # Function epilog
  68       mov      %rbp, %rsp
  69       pop      %rbx
  70       pop      %rbp
  71       ret
  72
  73
  74 # UINTN EbcLLGetEbcEntryPoint(VOID);
  75 # Routine Description:
  76 #   The VM thunk code stuffs an EBC entry point into a processor
  77 #   register. Since we can't use inline assembly to get it from
  78 #   the interpreter C code, stuff it into the return value
  79 #   register and return.
  80 #
  81 # Arguments:
  82 #     None.
  83 #
  84 # Returns:
  85 #     The contents of the register in which the entry point is passed.
  86 #
  87 ASM_GLOBAL ASM_PFX(EbcLLGetEbcEntryPoint);
  88 ASM_PFX(EbcLLGetEbcEntryPoint):
  89     ret
  90
  91 #/*++
  92 #
  93 #Routine Description:
  94 #
  95 #  Return the caller's value of the stack pointer.
  96 #
  97 #Arguments:
  98 #
  99 #  None.
 100 #
 101 #Returns:
 102 #
 103 #  The current value of the stack pointer for the caller. We
 104 #  adjust it by 4 here because when they called us, the return address
 105 #  is put on the stack, thereby lowering it by 4 bytes.
 106 #
 107 #--*/
 108
 109 # UINTN EbcLLGetStackPointer()
 110 ASM_GLOBAL ASM_PFX(EbcLLGetStackPointer);
 111 ASM_PFX(EbcLLGetStackPointer):
 112     mov    %rsp, %rax
 113     # Stack adjusted by this much when we were called,
 114     # For this function, it's 4.
 115     add   $4, %rax
 116     ret
 117
 118 ASM_GLOBAL ASM_PFX(EbcLLGetReturnValue);
 119 ASM_PFX(EbcLLGetReturnValue):
 120 # UINT64 EbcLLGetReturnValue(VOID);
 121 # Routine Description:
 122 #   When EBC calls native, on return the VM has to stuff the return
 123 #   value into a VM register. It's assumed here that the value is still
 124 #    in the register, so simply return and the caller should get the
 125 #   return result properly.
 126 #
 127 # Arguments:
 128 #     None.
 129 #
 130 # Returns:
 131 #     The unmodified value returned by the native code.
 132 #
 133     ret