* [PATCH 1/1] MdeModulePkg/EbcDxe: add ARM support
@ 2016-09-22 9:43 Pete Batard
0 siblings, 0 replies; only message in thread
From: Pete Batard @ 2016-09-22 9:43 UTC (permalink / raw)
To: edk2-devel
This is a port of the AARCH64 implementation of the EBC runtime to ARM.
Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Pete Batard <pete@akeo.ie>
---
ArmVirtPkg/ArmVirt.dsc.inc | 2 +-
ArmVirtPkg/ArmVirtQemuFvMain.fdf.inc | 10 +-
ArmVirtPkg/ArmVirtXen.fdf | 10 +-
MdeModulePkg/Universal/EbcDxe/Arm/EbcLowLevel.S | 155 ++++++++
MdeModulePkg/Universal/EbcDxe/Arm/EbcSupport.c | 467
++++++++++++++++++++++++
MdeModulePkg/Universal/EbcDxe/EbcDxe.inf | 8 +-
6 files changed, 639 insertions(+), 13 deletions(-)
create mode 100644 MdeModulePkg/Universal/EbcDxe/Arm/EbcLowLevel.S
create mode 100644 MdeModulePkg/Universal/EbcDxe/Arm/EbcSupport.c
diff --git a/ArmVirtPkg/ArmVirt.dsc.inc b/ArmVirtPkg/ArmVirt.dsc.inc
index c624b3c..a2524c2 100644
--- a/ArmVirtPkg/ArmVirt.dsc.inc
+++ b/ArmVirtPkg/ArmVirt.dsc.inc
@@ -423,7 +423,7 @@
gEfiMdePkgTokenSpaceGuid.PcdUefiLibMaxPrintBufferSize|8000
}
-[Components.AARCH64]
+[Components]
#
# ACPI Support
#
diff --git a/ArmVirtPkg/ArmVirtQemuFvMain.fdf.inc
b/ArmVirtPkg/ArmVirtQemuFvMain.fdf.inc
index 2571884..6fc4f12 100644
--- a/ArmVirtPkg/ArmVirtQemuFvMain.fdf.inc
+++ b/ArmVirtPkg/ArmVirtQemuFvMain.fdf.inc
@@ -140,17 +140,17 @@ READ_LOCK_STATUS = TRUE
INF MdeModulePkg/Universal/SmbiosDxe/SmbiosDxe.inf
INF OvmfPkg/SmbiosPlatformDxe/SmbiosPlatformDxe.inf
+ #
+ # EBC support
+ #
+ INF MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
+
!if $(ARCH) == AARCH64
#
# ACPI Support
#
INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf
INF OvmfPkg/AcpiPlatformDxe/QemuFwCfgAcpiPlatformDxe.inf
-
- #
- # EBC support
- #
- INF MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
!endif
#
diff --git a/ArmVirtPkg/ArmVirtXen.fdf b/ArmVirtPkg/ArmVirtXen.fdf
index c997251..c87ebf4 100644
--- a/ArmVirtPkg/ArmVirtXen.fdf
+++ b/ArmVirtPkg/ArmVirtXen.fdf
@@ -181,16 +181,16 @@ READ_LOCK_STATUS = TRUE
INF OvmfPkg/XenPvBlkDxe/XenPvBlkDxe.inf
#
+ # EBC support
+ #
+ INF MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
+
+ #
# ACPI support
#
!if $(ARCH) == AARCH64
INF MdeModulePkg/Universal/Acpi/AcpiTableDxe/AcpiTableDxe.inf
INF ArmVirtPkg/XenAcpiPlatformDxe/XenAcpiPlatformDxe.inf
-
- #
- # EBC support
- #
- INF MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
!endif
#
diff --git a/MdeModulePkg/Universal/EbcDxe/Arm/EbcLowLevel.S
b/MdeModulePkg/Universal/EbcDxe/Arm/EbcLowLevel.S
new file mode 100644
index 0000000..f33cdc4
--- /dev/null
+++ b/MdeModulePkg/Universal/EbcDxe/Arm/EbcLowLevel.S
@@ -0,0 +1,155 @@
+///** @file
+//
+// This code provides low level routines that support the Virtual Machine
+// for option ROMs.
+//
+// Copyright (c) 2016, Linaro, Ltd. All rights reserved.<BR>
+// Copyright (c) 2015, The Linux Foundation. All rights reserved.<BR>
+// Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+//
+// This program and the accompanying materials
+// are licensed and made available under the terms and conditions of
the BSD License
+// which accompanies this distribution. The full text of the license
may be found at
+// http://opensource.org/licenses/bsd-license.php
+//
+// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS
OR IMPLIED.
+//
+//**/
+
+.syntax unified
+
+ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
+ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);
+ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);
+ASM_GLOBAL ASM_PFX(CopyMem);
+
+ASM_GLOBAL ASM_PFX(mEbcInstructionBufferTemplate);
+
+//****************************************************************************
+// EbcLLCALLEX
+//
+// This function is called to execute an EBC CALLEX instruction.
+// This instruction requires that we thunk out to external native
+// code. For ARM, we copy the VM stack into the main stack and then pop
+// the first 4 arguments off according to the ARM Procedure Call Standard
+// On return, we restore the stack pointer to its original location.
+//
+//****************************************************************************
+// UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID
*FramePtr)
+ .type EbcLLCALLEXNative, %function
+ASM_PFX(EbcLLCALLEXNative):
+ mov ip, r1 // Preserve r1
+
+ //
+ // If the EBC stack frame is smaller than or equal to 16 bytes, we
know there
+ // are no stacked arguments #5 and beyond that we need to copy to
the native
+ // stack. In this case, we can perform a tail call which is much more
+ // efficient, since there is no need to touch the native stack at all.
+ //
+ sub r3, r2, r1 // Length = NewStackPointer - FramePtr
+ cmp r3, #16
+ bgt 4f
+
+ // Be weary of trying to optimize the branching below...
+ cmp r3, #0
+ beq 0f
+ cmp r3, #4
+ beq 1f
+ cmp r3, #8
+ beq 2f
+ cmp r3, #12
+ beq 3f
+ ldr r3, [ip, #12]
+3: ldr r2, [ip, #8]
+2: ldr r1, [ip, #4]
+1: ldr ip, [ip]
+
+0: eor r0, r0, ip // Swap r0 and ip
+ eor ip, r0, ip
+ eor r0, r0, ip
+
+ bx ip
+
+ //
+ // More than 16 bytes: we need to build the full native stack frame
and copy
+ // the part of the VM stack exceeding 16 bytes (which may contain
stacked
+ // arguments) to the native stack
+ //
+4: stmdb sp!, {r4-r6, lr}
+ mov r4, sp // Preserve the orginal stack address
+ mov r5, r0
+ mov r6, ip
+
+ sub r2, r3, #16 // Size without reg params
+ sub sp, sp, r2 // Allocate required space on the
native stack
+ and sp, sp, #0xfffffff8 // Ensure that the stack pointer
remains 8 byte aligned
+ mov r0, sp
+ add r1, r1, #16
+ bl ASM_PFX(CopyMem)
+ mov ip, r6
+ ldrd r0, r1, [ip]
+ ldrd r2, r3, [ip, #8]
+
+ blx r5
+
+ mov sp, r4
+ ldmia sp!, {r4-r6, pc}
+
+//****************************************************************************
+// EbcLLEbcInterpret
+//
+// This function is called by the thunk code to handle an Native to EBC
call
+// This can handle up to 16 arguments (1-4 on in r0-r3, 5-16 are on the
stack)
+// ip contains the Entry point that will be the first argument when
+// EBCInterpret is called.
+//
+//****************************************************************************
+ .type EbcLLEbcInterpret, %function
+ASM_PFX(EbcLLEbcInterpret):
+ stmdb sp!, {r4, lr}
+
+ // push the entry point and the address of args #5 - #16 onto the stack
+ add r4, sp, #8
+ str ip, [sp, #-8]!
+ str r4, [sp, #4]
+
+ // call C-code
+ bl ASM_PFX(EbcInterpret)
+
+ add sp, sp, #8
+ ldmia sp!, {r4, pc}
+
+//****************************************************************************
+// EbcLLExecuteEbcImageEntryPoint
+//
+// This function is called by the thunk code to handle the image entry
point
+// ip contains the Entry point that will be the third argument when
+// ExecuteEbcImageEntryPoint is called.
+//
+//****************************************************************************
+ .thumb
+ .type EbcLLExecuteEbcImageEntryPoint, %function
+ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
+ mov r2, ip
+
+ // tail call to C code
+ b.w ASM_PFX(ExecuteEbcImageEntryPoint)
+
+//****************************************************************************
+// mEbcInstructionBufferTemplate
+//****************************************************************************
+ .section ".rodata", "a"
+ .align 2
+ .arm
+ASM_PFX(mEbcInstructionBufferTemplate):
+ ldr ip, 0f
+ ldr pc, 1f
+
+ //
+ // Add a magic code here to help the VM recognize the thunk.
+ //
+ .long 0xCA112EBC
+
+0: .long 0 // EBC_ENTRYPOINT_SIGNATURE
+1: .long 0 // EBC_LL_EBC_ENTRYPOINT_SIGNATURE
diff --git a/MdeModulePkg/Universal/EbcDxe/Arm/EbcSupport.c
b/MdeModulePkg/Universal/EbcDxe/Arm/EbcSupport.c
new file mode 100644
index 0000000..2b41026
--- /dev/null
+++ b/MdeModulePkg/Universal/EbcDxe/Arm/EbcSupport.c
@@ -0,0 +1,467 @@
+/** @file
+ This module contains EBC support routines that are customized based on
+ the target Arm processor.
+
+Copyright (c) 2016, Linaro, Ltd. All rights reserved.<BR>
+Copyright (c) 2015, The Linux Foundation. All rights reserved.<BR>
+Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
+
+This program and the accompanying materials
+are licensed and made available under the terms and conditions of the
BSD License
+which accompanies this distribution. The full text of the license may
be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED.
+
+**/
+
+#include "EbcInt.h"
+#include "EbcExecute.h"
+
+//
+// Amount of space that is not used in the stack
+//
+#define STACK_REMAIN_SIZE (1024 * 4)
+
+#pragma pack(1)
+typedef struct {
+ UINT32 Instr[2];
+ UINT32 Magic;
+ UINT32 EbcEntryPoint;
+ UINT32 EbcLlEntryPoint;
+} EBC_INSTRUCTION_BUFFER;
+#pragma pack()
+
+extern CONST EBC_INSTRUCTION_BUFFER mEbcInstructionBufferTemplate;
+
+/**
+ Begin executing an EBC image.
+ This is used for Ebc Thunk call.
+
+ @return The value returned by the EBC application we're going to run.
+
+**/
+UINT64
+EFIAPI
+EbcLLEbcInterpret (
+ VOID
+ );
+
+/**
+ Begin executing an EBC image.
+ This is used for Ebc image entrypoint.
+
+ @return The value returned by the EBC application we're going to run.
+
+**/
+UINT64
+EFIAPI
+EbcLLExecuteEbcImageEntryPoint (
+ VOID
+ );
+
+/**
+ Pushes a 32 bit unsigned value to the VM stack.
+
+ @param VmPtr The pointer to current VM context.
+ @param Arg The value to be pushed.
+
+**/
+VOID
+PushU32 (
+ IN VM_CONTEXT *VmPtr,
+ IN UINT32 Arg
+ )
+{
+ //
+ // Advance the VM stack down, and then copy the argument to the stack.
+ // Hope it's aligned.
+ //
+ VmPtr->Gpr[0] -= sizeof (UINT32);
+ *(UINT32 *)(UINTN)VmPtr->Gpr[0] = Arg;
+}
+
+
+/**
+ Begin executing an EBC image.
+
+ This is a thunk function.
+
+ @param Arg1 The 1st argument.
+ @param Arg2 The 2nd argument.
+ @param Arg3 The 3rd argument.
+ @param Arg4 The 4th argument.
+ @param Arg8 The 8th argument.
+ @param EntryPoint The entrypoint of EBC code.
+ @param Args5_16[] Array containing arguments #5 to #16.
+
+ @return The value returned by the EBC application we're going to run.
+
+**/
+UINT64
+EFIAPI
+EbcInterpret (
+ IN UINTN Arg1,
+ IN UINTN Arg2,
+ IN UINTN Arg3,
+ IN UINTN Arg4,
+ IN UINTN EntryPoint,
+ IN UINTN Args5_16[]
+ )
+{
+ //
+ // Create a new VM context on the stack
+ //
+ VM_CONTEXT VmContext;
+ UINTN Addr;
+ EFI_STATUS Status;
+ UINTN StackIndex;
+
+ //
+ // Get the EBC entry point
+ //
+ Addr = EntryPoint;
+
+ //
+ // Now clear out our context
+ //
+ ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
+
+ //
+ // Set the VM instruction pointer to the correct location in memory.
+ //
+ VmContext.Ip = (VMIP) Addr;
+
+ //
+ // Initialize the stack pointer for the EBC. Get the current system stack
+ // pointer and adjust it down by the max needed for the interpreter.
+ //
+
+ //
+ // Adjust the VM's stack pointer down.
+ //
+
+ Status = GetEBCStack((EFI_HANDLE)(UINTN)-1, &VmContext.StackPool,
&StackIndex);
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+ VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
+ VmContext.Gpr[0] = (UINT32) ((UINT8*)VmContext.StackPool +
STACK_POOL_SIZE);
+ VmContext.HighStackBottom = (UINTN) VmContext.Gpr[0];
+ VmContext.Gpr[0] -= sizeof (UINTN);
+
+ //
+ // Align the stack on a natural boundary.
+ //
+ VmContext.Gpr[0] &= ~(VM_REGISTER)(sizeof (UINTN) - 1);
+
+ //
+ // Put a magic value in the stack gap, then adjust down again.
+ //
+ *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
+ VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
+
+ //
+ // The stack upper to LowStackTop belongs to the VM.
+ //
+ VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
+
+ //
+ // For the worst case, assume there are 4 arguments passed in
registers, store
+ // them to VM's stack.
+ //
+ PushU32 (&VmContext, (UINT32) Args5_16[11]);
+ PushU32 (&VmContext, (UINT32) Args5_16[10]);
+ PushU32 (&VmContext, (UINT32) Args5_16[9]);
+ PushU32 (&VmContext, (UINT32) Args5_16[8]);
+ PushU32 (&VmContext, (UINT32) Args5_16[7]);
+ PushU32 (&VmContext, (UINT32) Args5_16[6]);
+ PushU32 (&VmContext, (UINT32) Args5_16[5]);
+ PushU32 (&VmContext, (UINT32) Args5_16[4]);
+ PushU32 (&VmContext, (UINT32) Args5_16[3]);
+ PushU32 (&VmContext, (UINT32) Args5_16[2]);
+ PushU32 (&VmContext, (UINT32) Args5_16[1]);
+ PushU32 (&VmContext, (UINT32) Args5_16[0]);
+ PushU32 (&VmContext, (UINT32) Arg4);
+ PushU32 (&VmContext, (UINT32) Arg3);
+ PushU32 (&VmContext, (UINT32) Arg2);
+ PushU32 (&VmContext, (UINT32) Arg1);
+
+ //
+ // Interpreter assumes 64-bit return address is pushed on the stack.
+ // Arm does not do this so pad the stack accordingly.
+ //
+ PushU32 (&VmContext, 0x0UL);
+ PushU32 (&VmContext, 0x0UL);
+ PushU32 (&VmContext, 0x12345678UL);
+ PushU32 (&VmContext, 0x87654321UL);
+
+ //
+ // For Arm, this is where we say our return address is
+ //
+ VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
+
+ //
+ // We need to keep track of where the EBC stack starts. This way, if
the EBC
+ // accesses any stack variables above its initial stack setting, then
we know
+ // it's accessing variables passed into it, which means the data is
on the
+ // VM's stack.
+ // When we're called, on the stack (high to low) we have the
parameters, the
+ // return address, then the saved ebp. Save the pointer to the return
address.
+ // EBC code knows that's there, so should look above it for function
parameters.
+ // The offset is the size of locals (VMContext + Addr + saved ebp).
+ // Note that the interpreter assumes there is a 16 bytes of return
address on
+ // the stack too, so adjust accordingly.
+ // VmContext.HighStackBottom = (UINTN)(Addr + sizeof (VmContext) +
sizeof (Addr));
+ //
+
+ //
+ // Begin executing the EBC code
+ //
+ EbcExecute (&VmContext);
+
+ //
+ // Return the value in R[7] unless there was an error
+ //
+ ReturnEBCStack(StackIndex);
+ return (UINT64) VmContext.Gpr[7];
+}
+
+
+/**
+ Begin executing an EBC image.
+
+ @param ImageHandle image handle for the EBC application we're
executing
+ @param SystemTable standard system table passed into an
driver's entry
+ point
+ @param EntryPoint The entrypoint of EBC code.
+
+ @return The value returned by the EBC application we're going to run.
+
+**/
+UINT64
+EFIAPI
+ExecuteEbcImageEntryPoint (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable,
+ IN UINTN EntryPoint
+ )
+{
+ //
+ // Create a new VM context on the stack
+ //
+ VM_CONTEXT VmContext;
+ UINTN Addr;
+ EFI_STATUS Status;
+ UINTN StackIndex;
+
+ //
+ // Get the EBC entry point
+ //
+ Addr = EntryPoint;
+
+ //
+ // Now clear out our context
+ //
+ ZeroMem ((VOID *) &VmContext, sizeof (VM_CONTEXT));
+
+ //
+ // Save the image handle so we can track the thunks created for this
image
+ //
+ VmContext.ImageHandle = ImageHandle;
+ VmContext.SystemTable = SystemTable;
+
+ //
+ // Set the VM instruction pointer to the correct location in memory.
+ //
+ VmContext.Ip = (VMIP) Addr;
+
+ //
+ // Initialize the stack pointer for the EBC. Get the current system stack
+ // pointer and adjust it down by the max needed for the interpreter.
+ //
+
+ //
+ // Allocate stack pool
+ //
+ Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+ VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
+ VmContext.Gpr[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool +
STACK_POOL_SIZE);
+ VmContext.HighStackBottom = (UINTN)VmContext.Gpr[0];
+ VmContext.Gpr[0] -= sizeof (UINTN);
+
+ //
+ // Put a magic value in the stack gap, then adjust down again
+ //
+ *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) VM_STACK_KEY_VALUE;
+ VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
+
+ //
+ // Align the stack on a natural boundary
+ // VmContext.Gpr[0] &= ~(sizeof(UINTN) - 1);
+ //
+ VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
+ VmContext.Gpr[0] -= sizeof (UINTN);
+ *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) SystemTable;
+ VmContext.Gpr[0] -= sizeof (UINTN);
+ *(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) ImageHandle;
+
+ VmContext.Gpr[0] -= 16;
+ VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
+ //
+ // VM pushes 16-bytes for return address. Simulate that here.
+ //
+
+ //
+ // Begin executing the EBC code
+ //
+ EbcExecute (&VmContext);
+
+ //
+ // Return the value in R[7] unless there was an error
+ //
+ ReturnEBCStack(StackIndex);
+ return (UINT64) VmContext.Gpr[7];
+}
+
+
+/**
+ Create thunks for an EBC image entry point, or an EBC protocol service.
+
+ @param ImageHandle Image handle for the EBC image. If not
null, then
+ we're creating a thunk for an image
entry point.
+ @param EbcEntryPoint Address of the EBC code that the thunk
is to call
+ @param Thunk Returned thunk we create here
+ @param Flags Flags indicating options for creating
the thunk
+
+ @retval EFI_SUCCESS The thunk was created successfully.
+ @retval EFI_INVALID_PARAMETER The parameter of EbcEntryPoint is not
16-bit
+ aligned.
+ @retval EFI_OUT_OF_RESOURCES There is not enough memory to created
the EBC
+ Thunk.
+ @retval EFI_BUFFER_TOO_SMALL EBC_THUNK_SIZE is not larger enough.
+
+**/
+EFI_STATUS
+EbcCreateThunks (
+ IN EFI_HANDLE ImageHandle,
+ IN VOID *EbcEntryPoint,
+ OUT VOID **Thunk,
+ IN UINT32 Flags
+ )
+{
+ EBC_INSTRUCTION_BUFFER *InstructionBuffer;
+
+ //
+ // Check alignment of pointer to EBC code
+ //
+ if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ InstructionBuffer = AllocatePool (sizeof (EBC_INSTRUCTION_BUFFER));
+ if (InstructionBuffer == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ //
+ // Give them the address of our buffer we're going to fix up
+ //
+ *Thunk = InstructionBuffer;
+
+ //
+ // Copy whole thunk instruction buffer template
+ //
+ CopyMem (InstructionBuffer, &mEbcInstructionBufferTemplate,
+ sizeof (EBC_INSTRUCTION_BUFFER));
+
+ //
+ // Patch EbcEntryPoint and EbcLLEbcInterpret
+ //
+ InstructionBuffer->EbcEntryPoint = (UINT32)EbcEntryPoint;
+ if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
+ InstructionBuffer->EbcLlEntryPoint =
(UINT32)EbcLLExecuteEbcImageEntryPoint;
+ } else {
+ InstructionBuffer->EbcLlEntryPoint = (UINT32)EbcLLEbcInterpret;
+ }
+
+ //
+ // Add the thunk to the list for this image. Do this last since the add
+ // function flushes the cache for us.
+ //
+ EbcAddImageThunk (ImageHandle, InstructionBuffer,
+ sizeof (EBC_INSTRUCTION_BUFFER));
+
+ return EFI_SUCCESS;
+}
+
+
+/**
+ This function is called to execute an EBC CALLEX instruction.
+ The function check the callee's content to see whether it is common
native
+ code or a thunk to another piece of EBC code.
+ If the callee is common native code, use EbcLLCAllEXASM to manipulate,
+ otherwise, set the VM->IP to target EBC code directly to avoid another VM
+ be startup which cost time and stack space.
+
+ @param VmPtr Pointer to a VM context.
+ @param FuncAddr Callee's address
+ @param NewStackPointer New stack pointer after the call
+ @param FramePtr New frame pointer after the call
+ @param Size The size of call instruction
+
+**/
+VOID
+EbcLLCALLEX (
+ IN VM_CONTEXT *VmPtr,
+ IN UINTN FuncAddr,
+ IN UINTN NewStackPointer,
+ IN VOID *FramePtr,
+ IN UINT8 Size
+ )
+{
+ CONST EBC_INSTRUCTION_BUFFER *InstructionBuffer;
+
+ //
+ // Processor specific code to check whether the callee is a thunk to EBC.
+ //
+ InstructionBuffer = (EBC_INSTRUCTION_BUFFER *)FuncAddr;
+
+ if (CompareMem (InstructionBuffer, &mEbcInstructionBufferTemplate,
+ sizeof(EBC_INSTRUCTION_BUFFER) - 2 * sizeof (UINT32)) == 0) {
+ //
+ // The callee is a thunk to EBC, adjust the stack pointer down 16
bytes and
+ // put our return address and frame pointer on the VM stack.
+ // Then set the VM's IP to new EBC code.
+ //
+ VmPtr->Gpr[0] -= 8;
+ VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);
+ VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];
+ VmPtr->Gpr[0] -= 8;
+ VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN)
(VmPtr->Ip + Size));
+
+ VmPtr->Ip = (VMIP) InstructionBuffer->EbcEntryPoint;
+ } else {
+ //
+ // The callee is not a thunk to EBC, call native code,
+ // and get return value.
+ //
+ // Note that we are not able to distinguish which part of the interval
+ // [NewStackPointer, FramePtr] consists of stacked function
arguments for
+ // this call, and which part simply consists of locals in the caller's
+ // stack frame. All we know is that there is an 8 byte gap at the
top that
+ // we can ignore.
+ //
+ VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer,
FramePtr - 8);
+
+ //
+ // Advance the IP.
+ //
+ VmPtr->Ip += Size;
+ }
+}
+
diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
index e9a0b28..8cc5a38 100644
--- a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
+++ b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
@@ -29,7 +29,7 @@
#
# The following information is for reference only and not required by
the build tools.
#
-# VALID_ARCHITECTURES = IA32 X64 IPF AARCH64
+# VALID_ARCHITECTURES = IA32 X64 IPF ARM AARCH64
#
[Sources]
@@ -55,6 +55,10 @@
Ipf/EbcSupport.c
Ipf/EbcLowLevel.s
+[Sources.ARM]
+ Arm/EbcSupport.c
+ Arm/EbcLowLevel.S
+
[Sources.AARCH64]
AArch64/EbcSupport.c
AArch64/EbcLowLevel.S
@@ -88,4 +92,4 @@
# EVENT_TYPE_PERIODIC_TIMER ## CONSUMES
[UserExtensions.TianoCore."ExtraFiles"]
- EbcDxeExtra.uni
\ No newline at end of file
+ EbcDxeExtra.uni
--
2.9.3
^ permalink raw reply related [flat|nested] only message in thread
only message in thread, other threads:[~2016-09-22 9:43 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2016-09-22 9:43 [PATCH 1/1] MdeModulePkg/EbcDxe: add ARM support Pete Batard
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox