#**/\r
\r
ASM_GLOBAL ASM_PFX(CopyMem)\r
+ASM_GLOBAL ASM_PFX(EbcInterpret)\r
+ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint)\r
\r
ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative)\r
ASM_PFX(EbcLLCALLEXNative):\r
pop %ebp\r
ret\r
\r
-ASM_GLOBAL ASM_PFX(EbcLLGetEbcEntryPoint)\r
-ASM_PFX(EbcLLGetEbcEntryPoint):\r
- ret\r
+ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret)\r
+ASM_PFX(EbcLLEbcInterpret):\r
+ # Construct new stack\r
+ push %ebp\r
+ mov %esp, %ebp\r
+ push %esi\r
+ push %edi\r
+ sub $0x40, %esp\r
+ push %eax\r
+ mov %ebp, %esi\r
+ add $0x8, %esi\r
+ mov %esp, %edi\r
+ add $0x4, %edi\r
+ mov $0x10, %ecx\r
+ rep movsd\r
+ \r
+ # call C-code\r
+ call ASM_PFX(EbcInterpret)\r
+ add $0x44, %esp\r
+ pop %edi\r
+ pop %esi\r
+ pop %ebp\r
+ ret\r
+\r
+ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint)\r
+ASM_PFX(EbcLLExecuteEbcImageEntryPoint):\r
+ # Construct new stack\r
+ mov %eax, -0xC(%esp)\r
+ mov 0x4(%esp), %eax\r
+ mov %eax, -0x8(%esp)\r
+ mov 0x8(%esp), %eax\r
+ mov %eax, -0x4(%esp)\r
+ # call C-code\r
+ sub $0xC, %esp\r
+ call ASM_PFX(ExecuteEbcImageEntryPoint)\r
+ add $0xC, %esp\r
+ ret\r
;---------------------------------------------------------------------------\r
\r
.686p\r
-.model flat\r
+.model flat, C\r
.code\r
-CopyMem PROTO C Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD\r
+CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD\r
+EbcInterpret PROTO\r
+ExecuteEbcImageEntryPoint PROTO\r
\r
;****************************************************************************\r
; EbcLLCALLEXNative\r
; Destroys no working registers.\r
;****************************************************************************\r
; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)\r
-_EbcLLCALLEXNative PROC PUBLIC\r
+EbcLLCALLEXNative PROC PUBLIC\r
push ebp\r
push ebx\r
mov ebp, esp ; standard function prolog\r
pop ebx\r
pop ebp\r
ret\r
-_EbcLLCALLEXNative ENDP\r
+EbcLLCALLEXNative ENDP\r
\r
-\r
-; UINTN EbcLLGetEbcEntryPoint(VOID);\r
-; Routine Description:\r
-; The VM thunk code stuffs an EBC entry point into a processor\r
-; register. Since we can't use inline assembly to get it from\r
-; the interpreter C code, stuff it into the return value\r
-; register and return.\r
-;\r
-; Arguments:\r
-; None.\r
+;****************************************************************************\r
+; EbcLLEbcInterpret\r
;\r
-; Returns:\r
-; The contents of the register in which the entry point is passed.\r
+; Begin executing an EBC image.\r
+;****************************************************************************\r
+; UINT64 EbcLLEbcInterpret(VOID)\r
+EbcLLEbcInterpret PROC PUBLIC\r
+ ;\r
+ ;; mov eax, 0xca112ebc\r
+ ;; mov eax, EbcEntryPoint\r
+ ;; mov ecx, EbcLLEbcInterpret\r
+ ;; jmp ecx\r
+ ;\r
+ ; Caller uses above instruction to jump here\r
+ ; The stack is below:\r
+ ; +-----------+\r
+ ; | RetAddr |\r
+ ; +-----------+\r
+ ; |EntryPoint | (EAX)\r
+ ; +-----------+\r
+ ; | Arg1 | <- EDI\r
+ ; +-----------+\r
+ ; | Arg2 |\r
+ ; +-----------+\r
+ ; | ... |\r
+ ; +-----------+\r
+ ; | Arg16 |\r
+ ; +-----------+\r
+ ; | EDI |\r
+ ; +-----------+\r
+ ; | ESI |\r
+ ; +-----------+\r
+ ; | EBP | <- EBP\r
+ ; +-----------+\r
+ ; | RetAddr | <- ESP is here\r
+ ; +-----------+\r
+ ; | Arg1 | <- ESI\r
+ ; +-----------+\r
+ ; | Arg2 |\r
+ ; +-----------+\r
+ ; | ... |\r
+ ; +-----------+\r
+ ; | Arg16 |\r
+ ; +-----------+\r
+ ; \r
+\r
+ ; Construct new stack\r
+ push ebp\r
+ mov ebp, esp\r
+ push esi\r
+ push edi\r
+ sub esp, 40h\r
+ push eax\r
+ mov esi, ebp\r
+ add esi, 8\r
+ mov edi, esp\r
+ add edi, 4\r
+ mov ecx, 16\r
+ rep movsd\r
+ \r
+ ; call C-code\r
+ call EbcInterpret\r
+ add esp, 44h\r
+ pop edi\r
+ pop esi\r
+ pop ebp\r
+ ret\r
+EbcLLEbcInterpret ENDP\r
+\r
+;****************************************************************************\r
+; EbcLLExecuteEbcImageEntryPoint\r
;\r
-_EbcLLGetEbcEntryPoint PROC PUBLIC\r
- ; The EbcEntryPoint is saved to EAX, so just return here.\r
+; Begin executing an EBC image.\r
+;****************************************************************************\r
+; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)\r
+EbcLLExecuteEbcImageEntryPoint PROC PUBLIC\r
+ ;\r
+ ;; mov eax, 0xca112ebc\r
+ ;; mov eax, EbcEntryPoint\r
+ ;; mov ecx, EbcLLExecuteEbcImageEntryPoint\r
+ ;; jmp ecx\r
+ ;\r
+ ; Caller uses above instruction to jump here\r
+ ; The stack is below:\r
+ ; +-----------+\r
+ ; | RetAddr |\r
+ ; +-----------+\r
+ ; |EntryPoint | (EAX)\r
+ ; +-----------+\r
+ ; |ImageHandle|\r
+ ; +-----------+\r
+ ; |SystemTable|\r
+ ; +-----------+\r
+ ; | RetAddr | <- ESP is here\r
+ ; +-----------+\r
+ ; |ImageHandle|\r
+ ; +-----------+\r
+ ; |SystemTable|\r
+ ; +-----------+\r
+ ; \r
+ \r
+ ; Construct new stack\r
+ mov [esp - 0Ch], eax\r
+ mov eax, [esp + 04h]\r
+ mov [esp - 08h], eax\r
+ mov eax, [esp + 08h]\r
+ mov [esp - 04h], eax\r
+ \r
+ ; call C-code\r
+ sub esp, 0Ch\r
+ call ExecuteEbcImageEntryPoint\r
+ add esp, 0Ch\r
ret\r
-_EbcLLGetEbcEntryPoint ENDP\r
+EbcLLExecuteEbcImageEntryPoint ENDP\r
\r
END\r
\r
#define STACK_REMAIN_SIZE (1024 * 4)\r
\r
+/**\r
+ Begin executing an EBC image.\r
+ This is used for Ebc Thunk call.\r
+\r
+ @return The value returned by the EBC application we're going to run.\r
+\r
+**/\r
+UINT64\r
+EFIAPI\r
+EbcLLEbcInterpret (\r
+ VOID\r
+ );\r
+\r
+/**\r
+ Begin executing an EBC image.\r
+ This is used for Ebc image entrypoint.\r
+\r
+ @return The value returned by the EBC application we're going to run.\r
+\r
+**/\r
+UINT64\r
+EFIAPI\r
+EbcLLExecuteEbcImageEntryPoint (\r
+ VOID\r
+ );\r
\r
/**\r
This function is called to execute an EBC CALLEX instruction.\r
\r
\r
/**\r
- Begin executing an EBC image. The address of the entry point is passed\r
- in via a processor register, so we'll need to make a call to get the\r
- value.\r
+ Begin executing an EBC image.\r
\r
This is a thunk function. Microsoft x64 compiler only provide fast_call\r
calling convention, so the first four arguments are passed by rcx, rdx,\r
r8, and r9, while other arguments are passed in stack.\r
\r
+ @param EntryPoint The entrypoint of EBC code.\r
@param Arg1 The 1st argument.\r
@param Arg2 The 2nd argument.\r
@param Arg3 The 3rd argument.\r
UINT64\r
EFIAPI\r
EbcInterpret (\r
- IN OUT UINTN Arg1,\r
- IN OUT UINTN Arg2,\r
- IN OUT UINTN Arg3,\r
- IN OUT UINTN Arg4,\r
- IN OUT UINTN Arg5,\r
- IN OUT UINTN Arg6,\r
- IN OUT UINTN Arg7,\r
- IN OUT UINTN Arg8,\r
- IN OUT UINTN Arg9,\r
- IN OUT UINTN Arg10,\r
- IN OUT UINTN Arg11,\r
- IN OUT UINTN Arg12,\r
- IN OUT UINTN Arg13,\r
- IN OUT UINTN Arg14,\r
- IN OUT UINTN Arg15,\r
- IN OUT UINTN Arg16\r
+ IN UINTN EntryPoint,\r
+ IN UINTN Arg1,\r
+ IN UINTN Arg2,\r
+ IN UINTN Arg3,\r
+ IN UINTN Arg4,\r
+ IN UINTN Arg5,\r
+ IN UINTN Arg6,\r
+ IN UINTN Arg7,\r
+ IN UINTN Arg8,\r
+ IN UINTN Arg9,\r
+ IN UINTN Arg10,\r
+ IN UINTN Arg11,\r
+ IN UINTN Arg12,\r
+ IN UINTN Arg13,\r
+ IN UINTN Arg14,\r
+ IN UINTN Arg15,\r
+ IN UINTN Arg16\r
)\r
{\r
//\r
UINTN StackIndex;\r
\r
//\r
- // Get the EBC entry point from the processor register.\r
+ // Get the EBC entry point\r
//\r
- Addr = EbcLLGetEbcEntryPoint ();\r
+ Addr = EntryPoint;\r
\r
//\r
// Now clear out our context\r
\r
\r
/**\r
- Begin executing an EBC image. The address of the entry point is passed\r
- in via a processor register, so we'll need to make a call to get the\r
- value.\r
+ Begin executing an EBC image.\r
\r
+ @param EntryPoint The entrypoint of EBC code.\r
@param ImageHandle image handle for the EBC application we're executing\r
@param SystemTable standard system table passed into an driver's entry\r
point\r
UINT64\r
EFIAPI\r
ExecuteEbcImageEntryPoint (\r
+ IN UINTN EntryPoint,\r
IN EFI_HANDLE ImageHandle,\r
IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
UINTN StackIndex;\r
\r
//\r
- // Get the EBC entry point from the processor register. Make sure you don't\r
- // call any functions before this or you could mess up the register the\r
- // entry point is passed in.\r
+ // Get the EBC entry point\r
//\r
- Addr = EbcLLGetEbcEntryPoint ();\r
+ Addr = EntryPoint;\r
\r
- //\r
- // Print(L"*** Thunked into EBC entry point - ImageHandle = 0x%X\n", (UINTN)ImageHandle);\r
- // Print(L"EBC entry point is 0x%X\n", (UINT32)(UINTN)Addr);\r
//\r
// Now clear out our context\r
//\r
// mov ecx 12345678h => 0xB9 0x78 0x56 0x34 0x12\r
//\r
if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {\r
- Addr = (UINT32) (UINTN) ExecuteEbcImageEntryPoint;\r
+ Addr = (UINT32) (UINTN) EbcLLExecuteEbcImageEntryPoint;\r
} else {\r
- Addr = (UINT32) (UINTN) EbcInterpret;\r
+ Addr = (UINT32) (UINTN) EbcLLEbcInterpret;\r
}\r
\r
//\r
#---------------------------------------------------------------------------\r
\r
ASM_GLOBAL ASM_PFX(CopyMem);\r
+ASM_GLOBAL ASM_PFX(EbcInterpret);\r
+ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint);\r
\r
#****************************************************************************\r
# EbcLLCALLEX\r
pop %rbp\r
ret\r
\r
+ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);\r
+ASM_PFX(EbcLLEbcInterpret):\r
+ # save old parameter to stack\r
+ mov %rcx, 0x8(%rsp)\r
+ mov %rdx, 0x10(%rsp)\r
+ mov %r8, 0x18(%rsp)\r
+ mov %r9, 0x20(%rsp)\r
\r
-# UINTN EbcLLGetEbcEntryPoint(VOID);\r
-# Routine Description:\r
-# The VM thunk code stuffs an EBC entry point into a processor\r
-# register. Since we can't use inline assembly to get it from\r
-# the interpreter C code, stuff it into the return value\r
-# register and return.\r
-#\r
-# Arguments:\r
-# None.\r
-#\r
-# Returns:\r
-# The contents of the register in which the entry point is passed.\r
-#\r
-ASM_GLOBAL ASM_PFX(EbcLLGetEbcEntryPoint);\r
-ASM_PFX(EbcLLGetEbcEntryPoint):\r
- mov %r10, %rax\r
+ # Construct new stack\r
+ push %rbp\r
+ mov %rsp, %rbp\r
+ push %rsi\r
+ push %rdi\r
+ push %rbx\r
+ sub $0x80, %rsp\r
+ push %r10\r
+ mov %rbp, %rsi\r
+ add $0x10, %rsi\r
+ mov %rsp, %rdi\r
+ add $0x8, %rdi\r
+ mov $0x10, %rcx\r
+ rep movsq\r
+ \r
+ # build new paramater calling convention\r
+ mov 0x18(%rsp), %r9\r
+ mov 0x10(%rsp), %r8\r
+ mov 0x8(%rsp), %rdx\r
+ mov %r10, %rcx\r
+\r
+ # call C-code\r
+ call ASM_PFX(EbcInterpret)\r
+ add $0x88, %esp\r
+ pop %rbx\r
+ pop %rdi\r
+ pop %rsi\r
+ pop %rbp\r
+ ret\r
+\r
+ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);\r
+ASM_PFX(EbcLLExecuteEbcImageEntryPoint):\r
+ # build new paramater calling convention\r
+ mov %rdx, %r8\r
+ mov %rcx, %rdx\r
+ mov %r10, %rcx\r
+\r
+ # call C-code\r
+ sub $0x28, %rsp\r
+ call ASM_PFX(ExecuteEbcImageEntryPoint)\r
+ add $0x28, %rsp\r
ret\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
ret\r
EbcLLCALLEXNative ENDP\r
\r
-\r
-; UINTN EbcLLGetEbcEntryPoint(VOID);\r
-; Routine Description:\r
-; The VM thunk code stuffs an EBC entry point into a processor\r
-; register. Since we can't use inline assembly to get it from\r
-; the interpreter C code, stuff it into the return value\r
-; register and return.\r
-;\r
-; Arguments:\r
-; None.\r
+;****************************************************************************\r
+; EbcLLEbcInterpret\r
;\r
-; Returns:\r
-; The contents of the register in which the entry point is passed.\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
-EbcLLGetEbcEntryPoint PROC PUBLIC\r
- ; The EbcEntryPoint is saved to R10.\r
- mov rax, r10\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
-EbcLLGetEbcEntryPoint ENDP\r
+EbcLLExecuteEbcImageEntryPoint ENDP\r
\r
END\r
\r
\r
#define STACK_REMAIN_SIZE (1024 * 4)\r
\r
+/**\r
+ Begin executing an EBC image.\r
+ This is used for Ebc Thunk call.\r
+\r
+ @return The value returned by the EBC application we're going to run.\r
+\r
+**/\r
+UINT64\r
+EFIAPI\r
+EbcLLEbcInterpret (\r
+ VOID\r
+ );\r
+\r
+/**\r
+ Begin executing an EBC image.\r
+ This is used for Ebc image entrypoint.\r
+\r
+ @return The value returned by the EBC application we're going to run.\r
+\r
+**/\r
+UINT64\r
+EFIAPI\r
+EbcLLExecuteEbcImageEntryPoint (\r
+ VOID\r
+ );\r
\r
/**\r
Pushes a 64 bit unsigned value to the VM stack.\r
\r
\r
/**\r
- Begin executing an EBC image. The address of the entry point is passed\r
- in via a processor register, so we'll need to make a call to get the\r
- value.\r
+ Begin executing an EBC image.\r
\r
This is a thunk function. Microsoft x64 compiler only provide fast_call\r
calling convention, so the first four arguments are passed by rcx, rdx,\r
r8, and r9, while other arguments are passed in stack.\r
\r
+ @param EntryPoint The entrypoint of EBC code.\r
@param Arg1 The 1st argument.\r
@param Arg2 The 2nd argument.\r
@param Arg3 The 3rd argument.\r
UINT64\r
EFIAPI\r
EbcInterpret (\r
- IN OUT UINTN Arg1,\r
- IN OUT UINTN Arg2,\r
- IN OUT UINTN Arg3,\r
- IN OUT UINTN Arg4,\r
- IN OUT UINTN Arg5,\r
- IN OUT UINTN Arg6,\r
- IN OUT UINTN Arg7,\r
- IN OUT UINTN Arg8,\r
- IN OUT UINTN Arg9,\r
- IN OUT UINTN Arg10,\r
- IN OUT UINTN Arg11,\r
- IN OUT UINTN Arg12,\r
- IN OUT UINTN Arg13,\r
- IN OUT UINTN Arg14,\r
- IN OUT UINTN Arg15,\r
- IN OUT UINTN Arg16\r
+ IN UINTN EntryPoint,\r
+ IN UINTN Arg1,\r
+ IN UINTN Arg2,\r
+ IN UINTN Arg3,\r
+ IN UINTN Arg4,\r
+ IN UINTN Arg5,\r
+ IN UINTN Arg6,\r
+ IN UINTN Arg7,\r
+ IN UINTN Arg8,\r
+ IN UINTN Arg9,\r
+ IN UINTN Arg10,\r
+ IN UINTN Arg11,\r
+ IN UINTN Arg12,\r
+ IN UINTN Arg13,\r
+ IN UINTN Arg14,\r
+ IN UINTN Arg15,\r
+ IN UINTN Arg16\r
)\r
{\r
//\r
UINTN StackIndex;\r
\r
//\r
- // Get the EBC entry point from the processor register.\r
- // Don't call any function before getting the EBC entry\r
- // point because this will collab the return register.\r
+ // Get the EBC entry point\r
//\r
- Addr = EbcLLGetEbcEntryPoint ();\r
+ Addr = EntryPoint;\r
\r
//\r
// Now clear out our context\r
\r
\r
/**\r
- Begin executing an EBC image. The address of the entry point is passed\r
- in via a processor register, so we'll need to make a call to get the\r
- value.\r
+ Begin executing an EBC image.\r
\r
+ @param EntryPoint The entrypoint of EBC code.\r
@param ImageHandle image handle for the EBC application we're executing\r
@param SystemTable standard system table passed into an driver's entry\r
point\r
UINT64\r
EFIAPI\r
ExecuteEbcImageEntryPoint (\r
+ IN UINTN EntryPoint,\r
IN EFI_HANDLE ImageHandle,\r
IN EFI_SYSTEM_TABLE *SystemTable\r
)\r
UINTN StackIndex;\r
\r
//\r
- // Get the EBC entry point from the processor register. Make sure you don't\r
- // call any functions before this or you could mess up the register the\r
- // entry point is passed in.\r
+ // Get the EBC entry point\r
//\r
- Addr = EbcLLGetEbcEntryPoint ();\r
+ Addr = EntryPoint;\r
\r
//\r
// Now clear out our context\r
// mov r11 123456789abcdef0h => 49 BB F0 DE BC 9A 78 56 34 12\r
//\r
if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {\r
- Addr = (UINTN) ExecuteEbcImageEntryPoint;\r
+ Addr = (UINTN) EbcLLExecuteEbcImageEntryPoint;\r
} else {\r
- Addr = (UINTN) EbcInterpret;\r
+ Addr = (UINTN) EbcLLEbcInterpret;\r
}\r
\r
//\r
projects / mirror_edk2.git / commitdiff