Re: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support

[Ard Biesheuvel <ard.biesheuvel@linaro.org>]

On 29 July 2016 at 23:58, Daniil Egranov <daniil.egranov@arm.com> wrote:
> Hi Leif,
>
>
>
> On 07/29/2016 11:06 AM, Leif Lindholm wrote:
>>
>> From: Jeff Brasen <jbrasen@codeaurora.org>
>>
>> Adds support for the EBC VM for AARCH64 platforms
>>
>> Submitted on behalf of a third-party: The Linux Foundation
>> This contribution is licensed under the BSD license as found at
>> http://opensource.org/licenses/bsd-license.php
>>
>> [Taken from https://source.codeaurora.org/external/server/edk2-blue/]
>> Signed-off-by: Leif Lindholm <leif.lindholm@linaro.org>
>> ---
>>   .../Universal/EbcDxe/AArch64/EbcLowLevel.S         | 135 +++++
>>   MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c | 563
>> +++++++++++++++++++++
>>   MdeModulePkg/Universal/EbcDxe/EbcDxe.inf           |   6 +-
>>   3 files changed, 703 insertions(+), 1 deletion(-)
>>   create mode 100644 MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
>>   create mode 100644 MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
>>
>> diff --git a/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
>> b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
>> new file mode 100644
>> index 0000000..e858227
>> --- /dev/null
>> +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcLowLevel.S
>> @@ -0,0 +1,135 @@
>> +#/** @file
>> +#
>> +#    This code provides low level routines that support the Virtual
>> Machine
>> +#   for option ROMs.
>> +#
>> +#  Copyright (c) 2015, The Linux Foundation. All rights reserved.
>> +#  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.
>> +#
>> +#**/
>> +
>>
>> +#---------------------------------------------------------------------------
>> +# Equate files needed.
>>
>> +#---------------------------------------------------------------------------
>> +
>> +ASM_GLOBAL ASM_PFX(CopyMem);
>> +ASM_GLOBAL ASM_PFX(EbcInterpret);
>> +ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint);
>> +
>>
>> +#****************************************************************************
>> +# EbcLLCALLEX
>> +#
>> +# This function is called to execute an EBC CALLEX instruction.
>> +# This instruction requires that we thunk out to external native
>> +# code. For AArch64, we copy the VM stack into the main stack and then
>> pop
>> +# the first 8 arguments off according to the AArch64 Procedure Call
>> Standard
>> +# On return, we restore the stack pointer to its original location.
>> +#
>>
>> +#****************************************************************************
>> +# UINTN EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID
>> *FramePtr)
>
> The code has a mix of using UINTN and UINT64 types. Even the ProcessorBind.h
> defines UINTN as UINT64 for Aarch64, this code is specific for the Aarch64
> architecture. Should the UINT64 type be explicitly used instead of UINTN and
> avoid mixing of this types?
>

I don't object to using UINTN and UINT64 interchangeably in a file
that is specific to an architecture where they resolve to the same
thing.

>> +ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
>> +ASM_PFX(EbcLLCALLEXNative):
>> +      stp  x19, x20, [sp, #-16]!
>> +      stp  x29, x30, [sp, #-16]!
>> +
>> +      mov  x19, x0
>> +      mov  x20, sp
>> +      sub  x2, x2, x1   // Length = NewStackPointer-FramePtr
>> +      sub  sp, sp, x2
>> +      sub  sp, sp, #64  // Make sure there is room for at least 8 args in
>> the new stack
>> +      mov  x0, sp
>> +
>> +      bl   CopyMem      // Sp, NewStackPointer, Length
>> +
>> +      ldp  x0, x1, [sp], #16
>> +      ldp  x2, x3, [sp], #16
>> +      ldp  x4, x5, [sp], #16
>> +      ldp  x6, x7, [sp], #16
>> +
>> +      blr  x19
>> +
>> +      mov  sp,  x20
>> +      ldp  x29, x30, [sp], #16
>> +      ldp  x19, x20, [sp], #16
>> +
>> +      ret
>> +
>>
>> +#****************************************************************************
>> +# EbcLLEbcInterpret
>> +#
>> +# This function is called by the thunk code to handle an Native to EBC
>> call
>> +# This can handle up to 16 arguments (1-8 on in x0-x7, 9-16 are on the
>> stack)
>> +# x9 contains the Entry point that will be the first argument when
>> +# EBCInterpret is called.
>> +#
>>
>> +#****************************************************************************
>> +ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);
>> +ASM_PFX(EbcLLEbcInterpret):
>> +    stp  x29, x30, [sp, #-16]!
>> +
>> +    // copy the current arguments 9-16 from old location and add arg 7 to
>> stack
>> +    // keeping 16 byte stack alignment
>> +    sub sp, sp, #80
>> +    str x7, [sp]
>> +    ldr x11, [sp, #96]
>> +    str x11, [sp, #8]
>> +    ldr x11, [sp, #104]
>> +    str x11, [sp, #16]
>> +    ldr x11, [sp, #112]
>> +    str x11, [sp, #24]
>> +    ldr x11, [sp, #120]
>> +    str x11, [sp, #32]
>> +    ldr x11, [sp, #128]
>> +    str x11, [sp, #40]
>> +    ldr x11, [sp, #136]
>> +    str x11, [sp, #48]
>> +    ldr x11, [sp, #144]
>> +    str x11, [sp, #56]
>> +    ldr x11, [sp, #152]
>> +    str x11, [sp, #64]
>> +
>> +    // Shift arguments and add entry point and as argument 1
>> +    mov x7, x6
>> +    mov x6, x5
>> +    mov x5, x4
>> +    mov x4, x3
>> +    mov x3, x2
>> +    mov x2, x1
>> +    mov x1, x0
>> +    mov x0, x9
>> +
>> +    # call C-code
>> +    bl ASM_PFX(EbcInterpret)
>> +    add sp, sp, #80
>> +
>> +    ldp  x29, x30, [sp], #16
>> +
>> +    ret
>> +
>>
>> +#****************************************************************************
>> +# EbcLLExecuteEbcImageEntryPoint
>> +#
>> +# This function is called by the thunk code to handle the image entry
>> point
>> +# x9 contains the Entry point that will be the first argument when
>> +# ExecuteEbcImageEntryPoint is called.
>> +#
>>
>> +#****************************************************************************
>> +ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);
>> +ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
>> +    stp  x29, x30, [sp, #-16]!
>> +    # build new paramater calling convention
>> +    mov  x2, x1
>> +    mov  x1, x0
>> +    mov  x0, x9
>> +
>> +    # call C-code
>> +    bl ASM_PFX(ExecuteEbcImageEntryPoint)
>> +    ldp  x29, x30, [sp], #16
>> +    ret
>> diff --git a/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
>> b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
>> new file mode 100644
>> index 0000000..23261a0
>> --- /dev/null
>> +++ b/MdeModulePkg/Universal/EbcDxe/AArch64/EbcSupport.c
>> @@ -0,0 +1,563 @@
>> +/** @file
>> +  This module contains EBC support routines that are customized based on
>> +  the target AArch64 processor.
>> +
>> +Copyright (c) 2015, The Linux Foundation. All rights reserved.
>> +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
>> +//
>
> The "#define VM_STACK_SIZE ()" exists in Ia32, X64 and Ipf code but not
> here. However, it's not been used anywhere in the code directly. Is it safe
> to ignore it?
>
>> +#define STACK_REMAIN_SIZE (1024 * 4)
>> +
>> +//
>> +// This is instruction buffer used to create EBC thunk
>> +//
>> +#define EBC_MAGIC_SIGNATURE                0xCA112EBCCA112EBCull
>> +#define EBC_ENTRYPOINT_SIGNATURE           0xAFAFAFAFAFAFAFAFull
>> +#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE    0xFAFAFAFAFAFAFAFAull
>> +UINT8  mInstructionBufferTemplate[] = {
>> +  0x03,  0x00, 0x00, 0x14, //b pc+16
>> +  //
>> +  // Add a magic code here to help the VM recognize the thunk..
>> +  //
>> +    (UINT8)(EBC_MAGIC_SIGNATURE & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 8) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 16) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 24) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 32) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 40) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 48) & 0xFF),
>> +    (UINT8)((EBC_MAGIC_SIGNATURE >> 56) & 0xFF),
>> +  0x69, 0x00, 0x00, 0x58, //ldr x9, #32
>> +  0x8A, 0x00, 0x00, 0x58, //ldr x10, #40
>> +  0x05, 0x00, 0x00, 0x14, //b pc+32
>> +    (UINT8)(EBC_ENTRYPOINT_SIGNATURE & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
>> +    (UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
>> +    (UINT8)(EBC_LL_EBC_ENTRYPOINT_SIGNATURE & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 32) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 40) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 48) & 0xFF),
>> +    (UINT8)((EBC_LL_EBC_ENTRYPOINT_SIGNATURE >> 56) & 0xFF),
>> +  0x40, 0x01, 0x1F, 0xD6 //br x10
>> +
>> +};
>
> This template may need additional comments explaining the code. There are
> couple of branching in the template above with jumping to PC+16 and PC+32.
> Are the 16 and 32 correct values?
>
> Assuming that this template should have a similar functionality as x64
> template:
> mov rax, 0xca112ebcca112ebc //store a magic signature (EBC_MAGIC_SIGNATURE)
> mov r10, XXXXXXXXXXXXXXXX // store EBC entry point, the dummy address
> replaced with a valid address during runtime (EBC_ENTRYPOINT_SIGNATURE
> marker)
> mov r11, XXXXXXXXXXXXXXXX //store VM function address,  the dummy address
> replaced with a valid address during runtime
> (EBC_LL_EBC_ENTRYPOINT_SIGNATURE marker)
> jmp r11
>

The thunking code is a bit clunky, and tries to deal with variable
length instructions which makes no sense on AARCH64. I rewrote some
parts of it. I will send it out as soon as I have managed to test it.

>> +
>> +/**
>> +  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 64 bit unsigned value to the VM stack.
>> +
>> +  @param VmPtr  The pointer to current VM context.
>> +  @param Arg    The value to be pushed.
>> +
>> +**/
>> +VOID
>> +PushU64 (
>> +  IN VM_CONTEXT *VmPtr,
>> +  IN UINT64     Arg
>> +  )
>> +{
>> +  //
>> +  // Advance the VM stack down, and then copy the argument to the stack.
>> +  // Hope it's aligned.
>> +  //
>> +  VmPtr->Gpr[0] -= sizeof (UINT64);
>> +  *(UINT64 *) VmPtr->Gpr[0] = Arg;
>> +  return;
>> +}
>> +
>> +
>> +/**
>> +  Begin executing an EBC image.
>> +
>> +  This is a thunk function.
>> +
>> +  @param  EntryPoint            The entrypoint of EBC code.
>> +  @param  Arg1                  The 1st argument.
>> +  @param  Arg2                  The 2nd argument.
>> +  @param  Arg3                  The 3rd argument.
>> +  @param  Arg4                  The 4th argument.
>> +  @param  Arg5                  The 5th argument.
>> +  @param  Arg6                  The 6th argument.
>> +  @param  Arg7                  The 7th argument.
>> +  @param  Arg8                  The 8th argument.
>> +  @param  Arg9                  The 9th argument.
>> +  @param  Arg10                 The 10th argument.
>> +  @param  Arg11                 The 11th argument.
>> +  @param  Arg12                 The 12th argument.
>> +  @param  Arg13                 The 13th argument.
>> +  @param  Arg14                 The 14th argument.
>> +  @param  Arg15                 The 15th argument.
>> +  @param  Arg16                 The 16th argument.
>> +
>> +  @return The value returned by the EBC application we're going to run.
>> +
>> +**/
>> +UINT64
>> +EFIAPI
>> +EbcInterpret (
>> +  IN UINTN      EntryPoint,
>> +  IN UINTN      Arg1,
>> +  IN UINTN      Arg2,
>> +  IN UINTN      Arg3,
>> +  IN UINTN      Arg4,
>> +  IN UINTN      Arg5,
>> +  IN UINTN      Arg6,
>> +  IN UINTN      Arg7,
>> +  IN UINTN      Arg8,
>> +  IN UINTN      Arg9,
>> +  IN UINTN      Arg10,
>> +  IN UINTN      Arg11,
>> +  IN UINTN      Arg12,
>> +  IN UINTN      Arg13,
>> +  IN UINTN      Arg14,
>> +  IN UINTN      Arg15,
>> +  IN UINTN      Arg16
>> +  )
>> +{
>> +  //
>> +  // 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] = (UINT64) ((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);
>
> This code is the same as x64. Is this correct alignment for Aarch64?
>

This is the VM stack alignment, not the native stack alignment.

>> +
>> +  //
>> +  // 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 is belong 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.
>> +  //
>> +  PushU64 (&VmContext, (UINT64) Arg16);
>> +  PushU64 (&VmContext, (UINT64) Arg15);
>> +  PushU64 (&VmContext, (UINT64) Arg14);
>> +  PushU64 (&VmContext, (UINT64) Arg13);
>> +  PushU64 (&VmContext, (UINT64) Arg12);
>> +  PushU64 (&VmContext, (UINT64) Arg11);
>> +  PushU64 (&VmContext, (UINT64) Arg10);
>> +  PushU64 (&VmContext, (UINT64) Arg9);
>> +  PushU64 (&VmContext, (UINT64) Arg8);
>> +  PushU64 (&VmContext, (UINT64) Arg7);
>> +  PushU64 (&VmContext, (UINT64) Arg6);
>> +  PushU64 (&VmContext, (UINT64) Arg5);
>> +  PushU64 (&VmContext, (UINT64) Arg4);
>> +  PushU64 (&VmContext, (UINT64) Arg3);
>> +  PushU64 (&VmContext, (UINT64) Arg2);
>> +  PushU64 (&VmContext, (UINT64) Arg1);
>> +
>> +  //
>> +  // Interpreter assumes 64-bit return address is pushed on the stack.
>> +  // AArch64 does not do this so pad the stack accordingly.
>> +  //
>> +  PushU64 (&VmContext, (UINT64) 0);
>> +  PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
>> +
>> +  //
>> +  // For AArch64, 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  EntryPoint       The entrypoint of EBC code.
>> +  @param  ImageHandle      image handle for the EBC application we're
>> executing
>> +  @param  SystemTable      standard system table passed into an driver's
>> entry
>> +                           point
>> +
>> +  @return The value returned by the EBC application we're going to run.
>> +
>> +**/
>> +UINT64
>> +EFIAPI
>> +ExecuteEbcImageEntryPoint (
>> +  IN UINTN                EntryPoint,
>> +  IN EFI_HANDLE           ImageHandle,
>> +  IN EFI_SYSTEM_TABLE     *SystemTable
>> +  )
>> +{
>> +  //
>> +  // 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.
>> +  //
>> +
>> +  Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
>> +  if (EFI_ERROR(Status)) {
>> +    return Status;
>> +  }
>> +  VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
>> +  VmContext.Gpr[0] = (UINT64) ((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] &= ~(VM_REGISTER)(sizeof(UINTN) - 1);
>
> This code is the same as x64. Is this correct alignment for Aarch64?
>
>> +  //
>> +  VmContext.LowStackTop   = (UINTN) VmContext.Gpr[0];
>> +
>> +  //
>> +  // Simply copy the image handle and system table onto the EBC stack.
>> +  // Greatly simplifies things by not having to spill the args.
>> +  //
>> +  PushU64 (&VmContext, (UINT64) SystemTable);
>> +  PushU64 (&VmContext, (UINT64) ImageHandle);
>> +
>> +  //
>> +  // VM pushes 16-bytes for return address. Simulate that here.
>> +  //
>> +  PushU64 (&VmContext, (UINT64) 0);
>> +  PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
>> +
>> +  //
>> +  // For AArch64, this is where we say our return address is
>> +  //
>> +  VmContext.StackRetAddr  = (UINT64) VmContext.Gpr[0];
>> +
>> +  //
>> +  // Entry function needn't access high stack context, simply
>> +  // put the stack pointer 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
>> +  )
>> +{
>> +  UINT8       *Ptr;
>> +  UINT8       *ThunkBase;
>> +  UINT32      Index;
>> +  INT32       ThunkSize;
>> +
>> +  //
>> +  // Check alignment of pointer to EBC code
>> +  //
>> +  if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
>> +    return EFI_INVALID_PARAMETER;
>> +  }
>> +
>> +  ThunkSize = sizeof(mInstructionBufferTemplate);
>> +
>> +  Ptr = AllocatePool (sizeof(mInstructionBufferTemplate));
>> +
>> +  if (Ptr == NULL) {
>> +    return EFI_OUT_OF_RESOURCES;
>> +  }
>> +  //
>> +  //  Print(L"Allocate TH: 0x%X\n", (UINT32)Ptr);
>> +  //
>> +  // Save the start address so we can add a pointer to it to a list
>> later.
>> +  //
>> +  ThunkBase = Ptr;
>> +
>> +  //
>> +  // Give them the address of our buffer we're going to fix up
>> +  //
>> +  *Thunk = (VOID *) Ptr;
>> +
>> +  //
>> +  // Copy whole thunk instruction buffer template
>> +  //
>> +  CopyMem (Ptr, mInstructionBufferTemplate,
>> sizeof(mInstructionBufferTemplate));
>> +
>> +  //
>> +  // Patch EbcEntryPoint and EbcLLEbcInterpret
>> +  //
>> +  for (Index = 0; Index < sizeof(mInstructionBufferTemplate) -
>> sizeof(UINTN); Index++) {
>> +    if (*(UINTN *)&Ptr[Index] == EBC_ENTRYPOINT_SIGNATURE) {
>> +      *(UINTN *)&Ptr[Index] = (UINTN)EbcEntryPoint;
>> +    }
>> +    if (*(UINTN *)&Ptr[Index] == EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
>> +      if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
>> +        *(UINTN *)&Ptr[Index] = (UINTN)EbcLLExecuteEbcImageEntryPoint;
>> +      } else {
>> +        *(UINTN *)&Ptr[Index] = (UINTN)EbcLLEbcInterpret;
>> +      }
>> +    }
>> +  }
>> +
>> +  //
>> +  // Add the thunk to the list for this image. Do this last since the add
>> +  // function flushes the cache for us.
>> +  //
>> +  EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
>> +
>> +  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
>> +  )
>> +{
>> +  UINTN    IsThunk;
>> +  UINTN    TargetEbcAddr;
>> +  UINT8    InstructionBuffer[sizeof(mInstructionBufferTemplate)];
>> +  UINTN    Index;
>> +  UINTN    IndexOfEbcEntrypoint;
>> +
>> +  IsThunk       = 1;
>> +  TargetEbcAddr = 0;
>> +  IndexOfEbcEntrypoint = 0;
>> +
>> +  //
>> +  // Processor specific code to check whether the callee is a thunk to
>> EBC.
>> +  //
>> +  CopyMem (InstructionBuffer, (VOID *)FuncAddr,
>> sizeof(InstructionBuffer));
>> +  //
>> +  // Fill the signature according to mInstructionBufferTemplate
>> +  //
>> +  for (Index = 0; Index < sizeof(mInstructionBufferTemplate) -
>> sizeof(UINTN); Index++) {
>> +    if (*(UINTN *)&mInstructionBufferTemplate[Index] ==
>> EBC_ENTRYPOINT_SIGNATURE) {
>> +      *(UINTN *)&InstructionBuffer[Index] = EBC_ENTRYPOINT_SIGNATURE;
>> +      IndexOfEbcEntrypoint = Index;
>> +    }
>> +    if (*(UINTN *)&mInstructionBufferTemplate[Index] ==
>> EBC_LL_EBC_ENTRYPOINT_SIGNATURE) {
>> +      *(UINTN *)&InstructionBuffer[Index] =
>> EBC_LL_EBC_ENTRYPOINT_SIGNATURE;
>> +    }
>> +  }
>> +  //
>> +  // Check if we need thunk to native
>> +  //
>> +  if (CompareMem (InstructionBuffer, mInstructionBufferTemplate,
>> sizeof(mInstructionBufferTemplate)) != 0) {
>> +    IsThunk = 0;
>> +  }
>> +
>> +  if (IsThunk == 1){
>> +    //
>> +    // 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));
>> +
>> +    CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + IndexOfEbcEntrypoint,
>> sizeof(UINTN));
>> +    VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
>> +  } else {
>> +    //
>> +    // The callee is not a thunk to EBC, call native code,
>> +    // and get return value.
>> +    //
>> +    VmPtr->Gpr[7] = EbcLLCALLEXNative (FuncAddr, NewStackPointer,
>> FramePtr);
>> +
>> +    //
>> +    // Advance the IP.
>> +    //
>> +    VmPtr->Ip += Size;
>> +  }
>> +}
>> +
>> diff --git a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
>> b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
>> index 15dc01c..e9a0b28 100644
>> --- a/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
>> +++ b/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf
>> @@ -5,6 +5,7 @@
>>   #  platform and processor-independent mechanisms for loading and
>> executing EFI
>>   #  device drivers.
>>   #
>> +#  Copyright (c) 2015, The Linux Foundation. All rights reserved.
>>   #  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
>> @@ -28,7 +29,7 @@ [Defines]
>>   #
>>   # The following information is for reference only and not required by
>> the build tools.
>>   #
>> -#  VALID_ARCHITECTURES           = IA32 X64 IPF
>> +#  VALID_ARCHITECTURES           = IA32 X64 IPF AARCH64
>>   #
>>     [Sources]
>> @@ -54,6 +55,9 @@ [Sources.IPF]
>>     Ipf/EbcSupport.c
>>     Ipf/EbcLowLevel.s
>>   +[Sources.AARCH64]
>> +  AArch64/EbcSupport.c
>> +  AArch64/EbcLowLevel.S
>>     [Packages]
>>     MdePkg/MdePkg.dec
>
>
> Thanks,
> Daniil