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

[Leif Lindholm <leif.lindholm@linaro.org>]

(Apologies, missed out on this branch of the thread on first pass
since I was dropped from cc.)

On Sun, Jul 31, 2016 at 11:32:08PM -0700, Jordan Justen wrote:
> On 2016-07-31 19:12:03, Tian, Feng wrote:
> > I may not speak it clear. Sorry for that.
> > 
> > I saw the patch with commit log "Submitted on behalf of a
> > third-party: xxxx". But this is part of "TianoCore Contribution
> > Agreement 1.0 section 4".
> > 
> > And the Contributions.txt clearly says "the commit message must
> > include your "Signed-off-by" signature, and "Contributed-under"
> > message". But the commit log hasn't.
> > 
> > So I am total confused how to solve this case. What's the correct
> > format for this?
> 
> Yes, Contributed-under and Signed-off-by are required.
> 
> I think it is possible in some cases to submit a third party
> conribution, but you still have to add the Contributed-under and
> Signed-off-by. See Contribtions.txt under either package for the text
> of the 'TianoCore Contribution Agreement' to understand what the
> 'Contributed-under' tag is indicating. Basically you'd be asserting
> that you are sure that the contribuion can be used under the
> conditions specified in the TianoCore Contribution Agreement, despite
> the fact that you don't own the copyright.

Since I was not certain of how this was historically, or should in the
future, be interpreted I left the Contributed-under out from the
submission.

The bit that is unclear to me is "You may submit it to TianoCore site
separately from any Contribution".
- Should this read "separately from any other contribution"?
- For practical purposes, Does separately mean "in a separate commit"?

If the answers to the two above questions are "yes", then I'm happy to
resubmit it with a Contributed-under.

> Obviously it is easier if someone that owns the copyright makes the
> patch submission.

Don't get me started...

/
    Leif

> We've taken code into OvmfPkg that wasn't contributed directly by the
> copyright owner. (for example, some of the Xen .h files)

> -Jordan
> 
> > 
> > -----Original Message-----
> > From: Marvin H?user [mailto:Marvin.Haeuser@outlook.com] 
> > Sent: Monday, August 1, 2016 9:58 AM
> > To: edk2-devel@lists.01.org
> > Cc: Tian, Feng <feng.tian@intel.com>
> > Subject: RE: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support
> > 
> > Hey Feng,
> > 
> > According to the Contributions document, BSD 2-clause is one of the licenses that can be accepted, if the parent license cannot be used:
> > https://github.com/tianocore/edk2/blob/master/MdeModulePkg/Contributions.txt#L25
> > 
> > Regards,
> > Marvin.
> > 
> > > -----Original Message-----
> > > From: edk2-devel [mailto:edk2-devel-bounces@lists.01.org] On Behalf Of 
> > > Tian, Feng
> > > Sent: Monday, August 1, 2016 3:50 AM
> > > To: Leif Lindholm <leif.lindholm@linaro.org>; edk2-devel@lists.01.org
> > > Cc: Tian, Feng <feng.tian@intel.com>; Daniil Egranov 
> > > <daniil.egranov@linaro.org>; Jeff Brasen <jbrasen@codeaurora.org>; 
> > > Zeng, Star <star.zeng@intel.com>; Ard Biesheuvel 
> > > <ard.biesheuvel@linaro.org>
> > > Subject: Re: [edk2] [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM 
> > > support
> > > 
> > > Hi, Leif
> > > 
> > > If I understand correctly, EDKII doesn't allow such BSD license.
> > > 
> > > Correct me if anybody has different opinions.
> > > 
> > > Thanks
> > > Feng
> > > 
> > > -----Original Message-----
> > > From: Leif Lindholm [mailto:leif.lindholm@linaro.org]
> > > Sent: Saturday, July 30, 2016 12:06 AM
> > > To: edk2-devel@lists.01.org
> > > Cc: Jeff Brasen <jbrasen@codeaurora.org>; Ard Biesheuvel 
> > > <ard.biesheuvel@linaro.org>; Daniil Egranov 
> > > <daniil.egranov@linaro.org>; Tian, Feng <feng.tian@intel.com>; Zeng, 
> > > Star <star.zeng@intel.com>
> > > Subject: [RFC 1/2] MdeModulePkg/EbcDxe: Add AARCH64 EBC VM support
> > > 
> > > 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) 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 // #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
> > > +
> > > +};
> > > +
> > > +/**
> > > +  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);
> > > +
> > > +  //
> > > +  // 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);  //
> > > +  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
> > > --
> > > 2.1.4
> > > 
> > > _______________________________________________
> > > edk2-devel mailing list
> > > edk2-devel@lists.01.org
> > > https://lists.01.org/mailman/listinfo/edk2-devel
> _______________________________________________
> edk2-devel mailing list
> edk2-devel@lists.01.org
> https://lists.01.org/mailman/listinfo/edk2-devel