Remove assumption on EAX and R10 usage for IA32 compiler and X64 compiler.

[mirror_edk2.git] / MdeModulePkg / Universal / EbcDxe / X64 / EbcLowLevel.asm

;/** @file\r
;  \r
;    This code provides low level routines that support the Virtual Machine.\r
;    for option ROMs.\r
;  \r
;  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>\r
;  This program and the accompanying materials\r
;  are licensed and made available under the terms and conditions of the BSD License\r
;  which accompanies this distribution.  The full text of the license may be found at\r
;  http://opensource.org/licenses/bsd-license.php\r
;  \r
;  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
;  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
;  \r
;**/\r
\r
  page    ,132\r
  title   VM ASSEMBLY LANGUAGE ROUTINES\r
\r
;---------------------------------------------------------------------------\r
; Equate files needed.\r
;---------------------------------------------------------------------------\r
\r
.CODE\r
\r
CopyMem  PROTO  Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD\r
EbcInterpret               PROTO\r
ExecuteEbcImageEntryPoint  PROTO\r
\r
;****************************************************************************\r
; EbcLLCALLEX\r
;\r
; This function is called to execute an EBC CALLEX instruction.\r
; This instruction requires that we thunk out to external native\r
; code. For x64, we switch stacks, copy the arguments to the stack\r
; and jump to the specified function.\r
; On return, we restore the stack pointer to its original location.\r
;\r
; Destroys no working registers.\r
;****************************************************************************\r
; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)\r
EbcLLCALLEXNative        PROC    PUBLIC\r
      push   rbp\r
      push   rbx\r
      mov    rbp, rsp\r
      ; Function prolog\r
\r
      ; Copy FuncAddr to a preserved register.\r
      mov    rbx, rcx\r
\r
      ; Set stack pointer to new value\r
      sub    r8,  rdx\r
      sub    rsp, r8\r
      mov    rcx, rsp\r
      sub    rsp, 20h\r
      call   CopyMem\r
      add    rsp, 20h\r
\r
      ; Considering the worst case, load 4 potiential arguments\r
      ; into registers.\r
      mov    rcx, qword ptr [rsp]\r
      mov    rdx, qword ptr [rsp+8h]\r
      mov    r8,  qword ptr [rsp+10h]\r
      mov    r9,  qword ptr [rsp+18h]\r
\r
      ; Now call the external routine\r
      call  rbx\r
\r
      ; Function epilog\r
      mov      rsp, rbp\r
      pop      rbx\r
      pop      rbp\r
      ret\r
EbcLLCALLEXNative    ENDP\r
\r
;****************************************************************************\r
; EbcLLEbcInterpret\r
;\r
; Begin executing an EBC image.\r
;****************************************************************************\r
; UINT64 EbcLLEbcInterpret(VOID)\r
EbcLLEbcInterpret PROC PUBLIC\r
    ;\r
    ;; mov rax, ca112ebccall2ebch\r
    ;; mov r10, EbcEntryPoint\r
    ;; mov r11, EbcLLEbcInterpret\r
    ;; jmp r11\r
    ;\r
    ; Caller uses above instruction to jump here\r
    ; The stack is below:\r
    ; +-----------+\r
    ; |  RetAddr  |\r
    ; +-----------+\r
    ; |EntryPoint | (R10)\r
    ; +-----------+\r
    ; |   Arg1    | <- RDI\r
    ; +-----------+\r
    ; |   Arg2    |\r
    ; +-----------+\r
    ; |   ...     |\r
    ; +-----------+\r
    ; |   Arg16   |\r
    ; +-----------+\r
    ; |   Dummy   |\r
    ; +-----------+\r
    ; |   RDI     |\r
    ; +-----------+\r
    ; |   RSI     |\r
    ; +-----------+\r
    ; |   RBP     | <- RBP\r
    ; +-----------+\r
    ; |  RetAddr  | <- RSP is here\r
    ; +-----------+\r
    ; |  Scratch1 | (RCX) <- RSI\r
    ; +-----------+\r
    ; |  Scratch2 | (RDX)\r
    ; +-----------+\r
    ; |  Scratch3 | (R8)\r
    ; +-----------+\r
    ; |  Scratch4 | (R9)\r
    ; +-----------+\r
    ; |   Arg5    |\r
    ; +-----------+\r
    ; |   Arg6    |\r
    ; +-----------+\r
    ; |   ...     |\r
    ; +-----------+\r
    ; |   Arg16   |\r
    ; +-----------+\r
    ;\r
\r
    ; save old parameter to stack\r
    mov  [rsp + 08h], rcx\r
    mov  [rsp + 10h], rdx\r
    mov  [rsp + 18h], r8\r
    mov  [rsp + 20h], r9\r
\r
    ; Construct new stack\r
    push rbp\r
    mov  rbp, rsp\r
    push rsi\r
    push rdi\r
    push rbx\r
    sub  rsp, 80h\r
    push r10\r
    mov  rsi, rbp\r
    add  rsi, 10h\r
    mov  rdi, rsp\r
    add  rdi, 8\r
    mov  rcx, 16\r
    rep  movsq\r
    \r
    ; build new paramater calling convention\r
    mov  r9,  [rsp + 18h]\r
    mov  r8,  [rsp + 10h]\r
    mov  rdx, [rsp + 08h]\r
    mov  rcx, r10\r
\r
    ; call C-code\r
    call EbcInterpret\r
    add  rsp, 88h\r
    pop  rbx\r
    pop  rdi\r
    pop  rsi\r
    pop  rbp\r
    ret\r
EbcLLEbcInterpret ENDP\r
\r
;****************************************************************************\r
; EbcLLExecuteEbcImageEntryPoint\r
;\r
; Begin executing an EBC image.\r
;****************************************************************************\r
; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)\r
EbcLLExecuteEbcImageEntryPoint PROC PUBLIC\r
    ;\r
    ;; mov rax, ca112ebccall2ebch\r
    ;; mov r10, EbcEntryPoint\r
    ;; mov r11, EbcLLExecuteEbcImageEntryPoint\r
    ;; jmp r11\r
    ;\r
    ; Caller uses above instruction to jump here\r
    ; The stack is below:\r
    ; +-----------+\r
    ; |  RetAddr  |\r
    ; +-----------+\r
    ; |EntryPoint | (R10)\r
    ; +-----------+\r
    ; |ImageHandle|\r
    ; +-----------+\r
    ; |SystemTable|\r
    ; +-----------+\r
    ; |   Dummy   |\r
    ; +-----------+\r
    ; |   Dummy   |\r
    ; +-----------+\r
    ; |  RetAddr  | <- RSP is here\r
    ; +-----------+\r
    ; |ImageHandle| (RCX)\r
    ; +-----------+\r
    ; |SystemTable| (RDX)\r
    ; +-----------+\r
    ; \r
\r
    ; build new paramater calling convention\r
    mov  r8, rdx\r
    mov  rdx, rcx\r
    mov  rcx, r10\r
\r
    ; call C-code\r
    sub  rsp, 28h\r
    call ExecuteEbcImageEntryPoint\r
    add  rsp, 28h\r
    ret\r
EbcLLExecuteEbcImageEntryPoint ENDP\r
\r
END\r
\r