fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part6

Browse source
This commit is contained in:
August 2018-08-08 17:48:24 +08:00
parent 421e214c7d
commit 4e516ec6ed
35396 changed files with 9188716 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

85
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcDxe.inf Normal file
View file

@ -0,0 +1,85 @@
## @file
# Module that produces EBC Interprete and EBC Debug Support protocols.
#
# This module implements EFI Byte Code (EBC) Virtual Machine that can provide
# platform and processor-independent mechanisms for loading and executing EFI
# device drivers.
#
# 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.
#
##
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = EbcDxe
MODULE_UNI_FILE = EbcDxe.uni
FILE_GUID = 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7
MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0
ENTRY_POINT = InitializeEbcDriver
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64 IPF
#
[Sources]
EbcExecute.h
EbcExecute.c
EbcInt.h
EbcInt.c
[Sources.Ia32]
Ia32/EbcSupport.c
Ia32/EbcLowLevel.S
Ia32/EbcLowLevel.asm
[Sources.X64]
X64/EbcSupport.c
X64/EbcLowLevel.S
X64/EbcLowLevel.asm
[Sources.IPF]
Ipf/EbcSupport.h
Ipf/EbcSupport.c
Ipf/EbcLowLevel.s
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
[LibraryClasses]
MemoryAllocationLib
UefiBootServicesTableLib
BaseMemoryLib
UefiDriverEntryPoint
DebugLib
BaseLib
[Protocols]
gEfiDebugSupportProtocolGuid ## PRODUCES
gEfiEbcProtocolGuid ## PRODUCES
gEfiEbcVmTestProtocolGuid ## SOMETIMES_PRODUCES
gEfiEbcSimpleDebuggerProtocolGuid ## SOMETIMES_CONSUMES
[Depex]
TRUE
# [Event]
#
# Periodic timer event to support EFI debug support protocol for EBC image.
#
# EVENT_TYPE_PERIODIC_TIMER ## CONSUMES
[UserExtensions.TianoCore."ExtraFiles"]
EbcDxeExtra.uni

24
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcDxe.uni Normal file
View file

@ -0,0 +1,24 @@
// /** @file
// Module that produces EBC Interprete and EBC Debug Support protocols.
//
// This module implements EFI Byte Code (EBC) Virtual Machine that can provide
// platform and processor-independent mechanisms for loading and executing EFI
// device drivers.
//
// 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.
//
// **/
#string STR_MODULE_ABSTRACT #language en-US "Produces EBC Interpreter and EBC Debug Support protocols"
#string STR_MODULE_DESCRIPTION #language en-US "This module implements EFI Byte Code (EBC) Virtual Machine that can provide platform and processor-independent mechanisms for loading and executing UEFI device drivers."

20
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcDxeExtra.uni Normal file
View file

@ -0,0 +1,20 @@
// /** @file
// EbcDxe Localized Strings and Content
//
// Copyright (c) 2013 - 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.
//
// **/
#string STR_PROPERTIES_MODULE_NAME
#language en-US
"EFI Byte Code DXE Interpreter"

5350
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcExecute.c Normal file
View file

File diff suppressed because it is too large Load diff

339
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcExecute.h Normal file
View file

@ -0,0 +1,339 @@
/** @file
Header file for Virtual Machine support. Contains EBC defines that can
be of use to a disassembler for the most part. Also provides function
prototypes for VM functions.
Copyright (c) 2006 - 2011, 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.
**/
#ifndef _EBC_EXECUTE_H_
#define _EBC_EXECUTE_H_
//
// VM major/minor version
//
#define VM_MAJOR_VERSION 1
#define VM_MINOR_VERSION 0
//
// Macros to check and set alignment
//
#define ASSERT_ALIGNED(addr, size) ASSERT (!((UINT32) (addr) & (size - 1)))
#define IS_ALIGNED(addr, size) !((UINT32) (addr) & (size - 1))
//
// Define a macro to get the operand. Then we can change it to be either a
// direct read or have it call a function to read memory.
//
#define GETOPERANDS(pVM) (UINT8) (*(UINT8 *) (pVM->Ip + 1))
#define GETOPCODE(pVM) (UINT8) (*(UINT8 *) pVM->Ip)
//
// Bit masks for opcode encodings
//
#define OPCODE_M_OPCODE 0x3F // bits of interest for first level decode
#define OPCODE_M_IMMDATA 0x80
#define OPCODE_M_IMMDATA64 0x40
#define OPCODE_M_64BIT 0x40 // for CMP
#define OPCODE_M_RELADDR 0x10 // for CALL instruction
#define OPCODE_M_CMPI32_DATA 0x80 // for CMPI
#define OPCODE_M_CMPI64 0x40 // for CMPI 32 or 64 bit comparison
#define OPERAND_M_MOVIN_N 0x80
#define OPERAND_M_CMPI_INDEX 0x10
//
// Masks for instructions that encode presence of indexes for operand1 and/or
// operand2.
//
#define OPCODE_M_IMMED_OP1 0x80
#define OPCODE_M_IMMED_OP2 0x40
//
// Bit masks for operand encodings
//
#define OPERAND_M_INDIRECT1 0x08
#define OPERAND_M_INDIRECT2 0x80
#define OPERAND_M_OP1 0x07
#define OPERAND_M_OP2 0x70
//
// Masks for data manipulation instructions
//
#define DATAMANIP_M_64 0x40 // 64-bit width operation
#define DATAMANIP_M_IMMDATA 0x80
//
// For MOV instructions, need a mask for the opcode when immediate
// data applies to R2.
//
#define OPCODE_M_IMMED_OP2 0x40
//
// The MOVI/MOVIn instructions use bit 6 of operands byte to indicate
// if an index is present. Then bits 4 and 5 are used to indicate the width
// of the move.
//
#define MOVI_M_IMMDATA 0x40
#define MOVI_M_DATAWIDTH 0xC0
#define MOVI_DATAWIDTH16 0x40
#define MOVI_DATAWIDTH32 0x80
#define MOVI_DATAWIDTH64 0xC0
#define MOVI_M_MOVEWIDTH 0x30
#define MOVI_MOVEWIDTH8 0x00
#define MOVI_MOVEWIDTH16 0x10
#define MOVI_MOVEWIDTH32 0x20
#define MOVI_MOVEWIDTH64 0x30
//
// Masks for CALL instruction encodings
//
#define OPERAND_M_RELATIVE_ADDR 0x10
#define OPERAND_M_NATIVE_CALL 0x20
//
// Masks for decoding push/pop instructions
//
#define PUSHPOP_M_IMMDATA 0x80 // opcode bit indicating immediate data
#define PUSHPOP_M_64 0x40 // opcode bit indicating 64-bit operation
//
// Mask for operand of JMP instruction
//
#define JMP_M_RELATIVE 0x10
#define JMP_M_CONDITIONAL 0x80
#define JMP_M_CS 0x40
//
// Macros to determine if a given operand is indirect
//
#define OPERAND1_INDIRECT(op) ((op) & OPERAND_M_INDIRECT1)
#define OPERAND2_INDIRECT(op) ((op) & OPERAND_M_INDIRECT2)
//
// Macros to extract the operands from second byte of instructions
//
#define OPERAND1_REGNUM(op) ((op) & OPERAND_M_OP1)
#define OPERAND2_REGNUM(op) (((op) & OPERAND_M_OP2) >> 4)
#define OPERAND1_CHAR(op) ('0' + OPERAND1_REGNUM (op))
#define OPERAND2_CHAR(op) ('0' + OPERAND2_REGNUM (op))
#define OPERAND1_REGDATA(pvm, op) pvm->Gpr[OPERAND1_REGNUM (op)]
#define OPERAND2_REGDATA(pvm, op) pvm->Gpr[OPERAND2_REGNUM (op)]
//
// Condition masks usually for byte 1 encodings of code
//
#define CONDITION_M_CONDITIONAL 0x80
#define CONDITION_M_CS 0x40
//
// Bits in the VM->StopFlags field
//
#define STOPFLAG_APP_DONE 0x0001
#define STOPFLAG_BREAKPOINT 0x0002
#define STOPFLAG_INVALID_BREAK 0x0004
#define STOPFLAG_BREAK_ON_CALLEX 0x0008
//
// Masks for working with the VM flags register
//
#define VMFLAGS_CC 0x0001 // condition flag
#define VMFLAGS_STEP 0x0002 // step instruction mode
#define VMFLAGS_ALL_VALID (VMFLAGS_CC | VMFLAGS_STEP)
//
// Macros for operating on the VM flags register
//
#define VMFLAG_SET(pVM, Flag) (pVM->Flags |= (Flag))
#define VMFLAG_ISSET(pVM, Flag) ((pVM->Flags & (Flag)) ? 1 : 0)
#define VMFLAG_CLEAR(pVM, Flag) (pVM->Flags &= ~(Flag))
//
// Debug macro
//
#define EBCMSG(s) gST->ConOut->OutputString (gST->ConOut, s)
//
// Define OPCODES
//
#define OPCODE_BREAK 0x00
#define OPCODE_JMP 0x01
#define OPCODE_JMP8 0x02
#define OPCODE_CALL 0x03
#define OPCODE_RET 0x04
#define OPCODE_CMPEQ 0x05
#define OPCODE_CMPLTE 0x06
#define OPCODE_CMPGTE 0x07
#define OPCODE_CMPULTE 0x08
#define OPCODE_CMPUGTE 0x09
#define OPCODE_NOT 0x0A
#define OPCODE_NEG 0x0B
#define OPCODE_ADD 0x0C
#define OPCODE_SUB 0x0D
#define OPCODE_MUL 0x0E
#define OPCODE_MULU 0x0F
#define OPCODE_DIV 0x10
#define OPCODE_DIVU 0x11
#define OPCODE_MOD 0x12
#define OPCODE_MODU 0x13
#define OPCODE_AND 0x14
#define OPCODE_OR 0x15
#define OPCODE_XOR 0x16
#define OPCODE_SHL 0x17
#define OPCODE_SHR 0x18
#define OPCODE_ASHR 0x19
#define OPCODE_EXTNDB 0x1A
#define OPCODE_EXTNDW 0x1B
#define OPCODE_EXTNDD 0x1C
#define OPCODE_MOVBW 0x1D
#define OPCODE_MOVWW 0x1E
#define OPCODE_MOVDW 0x1F
#define OPCODE_MOVQW 0x20
#define OPCODE_MOVBD 0x21
#define OPCODE_MOVWD 0x22
#define OPCODE_MOVDD 0x23
#define OPCODE_MOVQD 0x24
#define OPCODE_MOVSNW 0x25 // Move signed natural with word index
#define OPCODE_MOVSND 0x26 // Move signed natural with dword index
//
// #define OPCODE_27 0x27
//
#define OPCODE_MOVQQ 0x28 // Does this go away?
#define OPCODE_LOADSP 0x29
#define OPCODE_STORESP 0x2A
#define OPCODE_PUSH 0x2B
#define OPCODE_POP 0x2C
#define OPCODE_CMPIEQ 0x2D
#define OPCODE_CMPILTE 0x2E
#define OPCODE_CMPIGTE 0x2F
#define OPCODE_CMPIULTE 0x30
#define OPCODE_CMPIUGTE 0x31
#define OPCODE_MOVNW 0x32
#define OPCODE_MOVND 0x33
//
// #define OPCODE_34 0x34
//
#define OPCODE_PUSHN 0x35
#define OPCODE_POPN 0x36
#define OPCODE_MOVI 0x37
#define OPCODE_MOVIN 0x38
#define OPCODE_MOVREL 0x39
/**
Execute an EBC image from an entry point or from a published protocol.
@param VmPtr A pointer to a VM context.
@retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
@retval EFI_SUCCESS All of the instructions are executed successfully.
**/
EFI_STATUS
EbcExecute (
IN VM_CONTEXT *VmPtr
);
/**
Returns the version of the EBC virtual machine.
@return The 64-bit version of EBC virtual machine.
**/
UINT64
GetVmVersion (
VOID
);
/**
Writes UINTN data to memory address.
This routine is called by the EBC data
movement instructions that write to memory. Since these writes
may be to the stack, which looks like (high address on top) this,
[EBC entry point arguments]
[VM stack]
[EBC stack]
we need to detect all attempts to write to the EBC entry point argument
stack area and adjust the address (which will initially point into the
VM stack) to point into the EBC entry point arguments.
@param VmPtr A pointer to a VM context.
@param Addr Address to write to.
@param Data Value to write to Addr.
@retval EFI_SUCCESS The instruction is executed successfully.
@retval Other Some error occurs when writing data to the address.
**/
EFI_STATUS
VmWriteMemN (
IN VM_CONTEXT *VmPtr,
IN UINTN Addr,
IN UINTN Data
);
/**
Writes 64-bit data to memory address.
This routine is called by the EBC data
movement instructions that write to memory. Since these writes
may be to the stack, which looks like (high address on top) this,
[EBC entry point arguments]
[VM stack]
[EBC stack]
we need to detect all attempts to write to the EBC entry point argument
stack area and adjust the address (which will initially point into the
VM stack) to point into the EBC entry point arguments.
@param VmPtr A pointer to a VM context.
@param Addr Address to write to.
@param Data Value to write to Addr.
@retval EFI_SUCCESS The instruction is executed successfully.
@retval Other Some error occurs when writing data to the address.
**/
EFI_STATUS
VmWriteMem64 (
IN VM_CONTEXT *VmPtr,
IN UINTN Addr,
IN UINT64 Data
);
/**
Given a pointer to a new VM context, execute one or more instructions. This
function is only used for test purposes via the EBC VM test protocol.
@param This A pointer to the EFI_EBC_VM_TEST_PROTOCOL structure.
@param VmPtr A pointer to a VM context.
@param InstructionCount A pointer to a UINTN value holding the number of
instructions to execute. If it holds value of 0,
then the instruction to be executed is 1.
@retval EFI_UNSUPPORTED At least one of the opcodes is not supported.
@retval EFI_SUCCESS All of the instructions are executed successfully.
**/
EFI_STATUS
EFIAPI
EbcExecuteInstructions (
IN EFI_EBC_VM_TEST_PROTOCOL *This,
IN VM_CONTEXT *VmPtr,
IN OUT UINTN *InstructionCount
);
#endif // ifndef _EBC_EXECUTE_H_

1406
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcInt.c Normal file
View file

File diff suppressed because it is too large Load diff

278
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/EbcInt.h Normal file
View file

@ -0,0 +1,278 @@
/** @file
Main routines for the EBC interpreter. Includes the initialization and
main interpreter routines.
Copyright (c) 2006 - 2011, 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.
**/
#ifndef _EBC_INT_H_
#define _EBC_INT_H_
#include <Uefi.h>
#include <Protocol/DebugSupport.h>
#include <Protocol/Ebc.h>
#include <Protocol/EbcVmTest.h>
#include <Protocol/EbcSimpleDebugger.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
extern VM_CONTEXT *mVmPtr;
//
// Bits of exception flags field of VM context
//
#define EXCEPTION_FLAG_FATAL 0x80000000 // can't continue
#define EXCEPTION_FLAG_ERROR 0x40000000 // bad, but try to continue
#define EXCEPTION_FLAG_WARNING 0x20000000 // harmless problem
#define EXCEPTION_FLAG_NONE 0x00000000 // for normal return
//
// Flags passed to the internal create-thunks function.
//
#define FLAG_THUNK_ENTRY_POINT 0x01 // thunk for an image entry point
#define FLAG_THUNK_PROTOCOL 0x00 // thunk for an EBC protocol service
//
// Put this value at the bottom of the VM's stack gap so we can check it on
// occasion to make sure the stack has not been corrupted.
//
#define VM_STACK_KEY_VALUE 0xDEADBEEF
/**
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
);
/**
Add a thunk to our list of thunks for a given image handle.
Also flush the instruction cache since we've written thunk code
to memory that will be executed eventually.
@param ImageHandle The image handle to which the thunk is tied.
@param ThunkBuffer The buffer that has been created/allocated.
@param ThunkSize The size of the thunk memory allocated.
@retval EFI_OUT_OF_RESOURCES Memory allocation failed.
@retval EFI_SUCCESS The function completed successfully.
**/
EFI_STATUS
EbcAddImageThunk (
IN EFI_HANDLE ImageHandle,
IN VOID *ThunkBuffer,
IN UINT32 ThunkSize
);
//
// The interpreter calls these when an exception is detected,
// or as a periodic callback.
//
/**
The VM interpreter calls this function when an exception is detected.
@param ExceptionType Specifies the processor exception detected.
@param ExceptionFlags Specifies the exception context.
@param VmPtr Pointer to a VM context for passing info to the
EFI debugger.
@retval EFI_SUCCESS This function completed successfully.
**/
EFI_STATUS
EbcDebugSignalException (
IN EFI_EXCEPTION_TYPE ExceptionType,
IN EXCEPTION_FLAGS ExceptionFlags,
IN VM_CONTEXT *VmPtr
);
//
// Define a constant of how often to call the debugger periodic callback
// function.
//
#define EFI_TIMER_UNIT_1MS (1000 * 10)
#define EBC_VM_PERIODIC_CALLBACK_RATE (1000 * EFI_TIMER_UNIT_1MS)
#define STACK_POOL_SIZE (1024 * 1020)
#define MAX_STACK_NUM 4
//
// External low level functions that are native-processor dependent
//
/**
The VM thunk code stuffs an EBC entry point into a processor
register. Since we can't use inline assembly to get it from
the interpreter C code, stuff it into the return value
register and return.
@return The contents of the register in which the entry point is passed.
**/
UINTN
EFIAPI
EbcLLGetEbcEntryPoint (
VOID
);
/**
This function is called to execute an EBC CALLEX instruction.
This instruction requires that we thunk out to external native
code. For x64, we switch stacks, copy the arguments to the stack
and jump to the specified function.
On return, we restore the stack pointer to its original location.
Destroys no working registers.
@param CallAddr The function address.
@param EbcSp The new EBC stack pointer.
@param FramePtr The frame pointer.
@return The unmodified value returned by the native code.
**/
INT64
EFIAPI
EbcLLCALLEXNative (
IN UINTN CallAddr,
IN UINTN EbcSp,
IN VOID *FramePtr
);
/**
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
);
/**
Returns the stack index and buffer assosicated with the Handle parameter.
@param Handle The EFI handle as the index to the EBC stack.
@param StackBuffer A pointer to hold the returned stack buffer.
@param BufferIndex A pointer to hold the returned stack index.
@retval EFI_OUT_OF_RESOURCES The Handle parameter does not correspond to any
existing EBC stack.
@retval EFI_SUCCESS The stack index and buffer were found and
returned to the caller.
**/
EFI_STATUS
GetEBCStack(
IN EFI_HANDLE Handle,
OUT VOID **StackBuffer,
OUT UINTN *BufferIndex
);
/**
Returns from the EBC stack by stack Index.
@param Index Specifies which EBC stack to return from.
@retval EFI_SUCCESS The function completed successfully.
**/
EFI_STATUS
ReturnEBCStack(
IN UINTN Index
);
/**
Allocates memory to hold all the EBC stacks.
@retval EFI_SUCCESS The EBC stacks were allocated successfully.
@retval EFI_OUT_OF_RESOURCES Not enough memory available for EBC stacks.
**/
EFI_STATUS
InitEBCStack (
VOID
);
/**
Free all EBC stacks allocated before.
@retval EFI_SUCCESS All the EBC stacks were freed.
**/
EFI_STATUS
FreeEBCStack(
VOID
);
/**
Returns from the EBC stack associated with the Handle parameter.
@param Handle Specifies the EFI handle to find the EBC stack with.
@retval EFI_SUCCESS The function completed successfully.
**/
EFI_STATUS
ReturnEBCStackByHandle(
IN EFI_HANDLE Handle
);
typedef struct {
EFI_EBC_PROTOCOL *This;
VOID *EntryPoint;
EFI_HANDLE ImageHandle;
VM_CONTEXT VmContext;
} EFI_EBC_THUNK_DATA;
#define EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('e', 'b', 'c', 'p')
#define EBC_PROTOCOL_PRIVATE_DATA_FROM_THIS(a) \
CR(a, EBC_PROTOCOL_PRIVATE_DATA, EbcProtocol, EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE)
#endif // #ifndef _EBC_INT_H_

83
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.S Normal file
View file

@ -0,0 +1,83 @@
#/** @file
#
# Low level IA32 specific EBC support routines.
#
# Copyright (c) 2007 - 2011, 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.
#
#**/
ASM_GLOBAL ASM_PFX(CopyMem)
ASM_GLOBAL ASM_PFX(EbcInterpret)
ASM_GLOBAL ASM_PFX(ExecuteEbcImageEntryPoint)
ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative)
ASM_PFX(EbcLLCALLEXNative):
push %ebp
push %ebx
mov %esp,%ebp
mov 0xc(%esp),%ecx
mov 0x14(%esp),%eax
mov 0x10(%esp),%edx
sub %edx,%eax
sub %eax,%esp
mov %esp,%ebx
push %ecx
push %eax
push %edx
push %ebx
call ASM_PFX(CopyMem)
pop %eax
pop %eax
pop %eax
pop %ecx
call *%ecx
mov %ebp,%esp
mov %ebp,%esp
pop %ebx
pop %ebp
ret
ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret)
ASM_PFX(EbcLLEbcInterpret):
# Construct new stack
push %ebp
mov %esp, %ebp
push %esi
push %edi
sub $0x40, %esp
push %eax
mov %ebp, %esi
add $0x8, %esi
mov %esp, %edi
add $0x4, %edi
mov $0x10, %ecx
rep movsd
# call C-code
call ASM_PFX(EbcInterpret)
add $0x44, %esp
pop %edi
pop %esi
pop %ebp
ret
ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint)
ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
# Construct new stack
mov %eax, -0xC(%esp)
mov 0x4(%esp), %eax
mov %eax, -0x8(%esp)
mov 0x8(%esp), %eax
mov %eax, -0x4(%esp)
# call C-code
sub $0xC, %esp
call ASM_PFX(ExecuteEbcImageEntryPoint)
add $0xC, %esp
ret

207
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ia32/EbcLowLevel.asm Normal file
View file

@ -0,0 +1,207 @@
;/** @file
;
; This code provides low level routines that support the Virtual Machine
; for option ROMs.
;
; Copyright (c) 2006 - 2011, 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.
;
;**/
page ,132
title VM ASSEMBLY LANGUAGE ROUTINES
;---------------------------------------------------------------------------
; Equate files needed.
;---------------------------------------------------------------------------
.XLIST
.LIST
;---------------------------------------------------------------------------
; Assembler options
;---------------------------------------------------------------------------
.686p
.model flat, C
.code
CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD
EbcInterpret PROTO
ExecuteEbcImageEntryPoint PROTO
;****************************************************************************
; EbcLLCALLEXNative
;
; This function is called to execute an EBC CALLEX instruction
; to native code.
; This instruction requires that we thunk out to external native
; code. For IA32, we simply switch stacks and jump to the
; specified function. On return, we restore the stack pointer
; to its original location.
;
; Destroys no working registers.
;****************************************************************************
; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
EbcLLCALLEXNative PROC PUBLIC
push ebp
push ebx
mov ebp, esp ; standard function prolog
; Get function address in a register
; mov ecx, FuncAddr => mov ecx, dword ptr [FuncAddr]
mov ecx, dword ptr [esp]+0Ch
; Set stack pointer to new value
; mov eax, NewStackPointer => mov eax, dword ptr [NewSp]
mov eax, dword ptr [esp] + 14h
mov edx, dword ptr [esp] + 10h
sub eax, edx
sub esp, eax
mov ebx, esp
push ecx
push eax
push edx
push ebx
call CopyMem
pop eax
pop eax
pop eax
pop ecx
; Now call the external routine
call ecx
; ebp is preserved by the callee. In this function it
; equals the original esp, so set them equal
mov esp, ebp
; Standard function epilog
mov esp, ebp
pop ebx
pop ebp
ret
EbcLLCALLEXNative ENDP
;****************************************************************************
; EbcLLEbcInterpret
;
; Begin executing an EBC image.
;****************************************************************************
; UINT64 EbcLLEbcInterpret(VOID)
EbcLLEbcInterpret PROC PUBLIC
;
;; mov eax, 0xca112ebc
;; mov eax, EbcEntryPoint
;; mov ecx, EbcLLEbcInterpret
;; jmp ecx
;
; Caller uses above instruction to jump here
; The stack is below:
; +-----------+
; | RetAddr |
; +-----------+
; |EntryPoint | (EAX)
; +-----------+
; | Arg1 | <- EDI
; +-----------+
; | Arg2 |
; +-----------+
; | ... |
; +-----------+
; | Arg16 |
; +-----------+
; | EDI |
; +-----------+
; | ESI |
; +-----------+
; | EBP | <- EBP
; +-----------+
; | RetAddr | <- ESP is here
; +-----------+
; | Arg1 | <- ESI
; +-----------+
; | Arg2 |
; +-----------+
; | ... |
; +-----------+
; | Arg16 |
; +-----------+
;
; Construct new stack
push ebp
mov ebp, esp
push esi
push edi
sub esp, 40h
push eax
mov esi, ebp
add esi, 8
mov edi, esp
add edi, 4
mov ecx, 16
rep movsd
; call C-code
call EbcInterpret
add esp, 44h
pop edi
pop esi
pop ebp
ret
EbcLLEbcInterpret ENDP
;****************************************************************************
; EbcLLExecuteEbcImageEntryPoint
;
; Begin executing an EBC image.
;****************************************************************************
; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)
EbcLLExecuteEbcImageEntryPoint PROC PUBLIC
;
;; mov eax, 0xca112ebc
;; mov eax, EbcEntryPoint
;; mov ecx, EbcLLExecuteEbcImageEntryPoint
;; jmp ecx
;
; Caller uses above instruction to jump here
; The stack is below:
; +-----------+
; | RetAddr |
; +-----------+
; |EntryPoint | (EAX)
; +-----------+
; |ImageHandle|
; +-----------+
; |SystemTable|
; +-----------+
; | RetAddr | <- ESP is here
; +-----------+
; |ImageHandle|
; +-----------+
; |SystemTable|
; +-----------+
;
; Construct new stack
mov [esp - 0Ch], eax
mov eax, [esp + 04h]
mov [esp - 08h], eax
mov eax, [esp + 08h]
mov [esp - 04h], eax
; call C-code
sub esp, 0Ch
call ExecuteEbcImageEntryPoint
add esp, 0Ch
ret
EbcLLExecuteEbcImageEntryPoint ENDP
END

529
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ia32/EbcSupport.c Normal file
View file

@ -0,0 +1,529 @@
/** @file
This module contains EBC support routines that are customized based on
the target ia32 processor.
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"
//
// NOTE: This is the stack size allocated for the interpreter
// when it executes an EBC image. The requirements can change
// based on whether or not a debugger is present, and other
// platform-specific configurations.
//
#define VM_STACK_SIZE (1024 * 4)
#define STACK_REMAIN_SIZE (1024 * 4)
//
// This is instruction buffer used to create EBC thunk
//
#define EBC_ENTRYPOINT_SIGNATURE 0xAFAFAFAF
#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE 0xFAFAFAFA
UINT8 mInstructionBufferTemplate[] = {
//
// Add a magic code here to help the VM recognize the thunk..
// mov eax, 0xca112ebc => B8 BC 2E 11 CA
//
0xB8, 0xBC, 0x2E, 0x11, 0xCA,
//
// Add code bytes to load up a processor register with the EBC entry point.
// mov eax, EbcEntryPoint => B8 XX XX XX XX (To be fixed at runtime)
// These 4 bytes of the thunk entry is the address of the EBC
// entry point.
//
0xB8,
(UINT8)(EBC_ENTRYPOINT_SIGNATURE & 0xFF),
(UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 8) & 0xFF),
(UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 16) & 0xFF),
(UINT8)((EBC_ENTRYPOINT_SIGNATURE >> 24) & 0xFF),
//
// Stick in a load of ecx with the address of appropriate VM function.
// mov ecx, EbcLLEbcInterpret => B9 XX XX XX XX (To be fixed at runtime)
//
0xB9,
(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),
//
// Stick in jump opcode bytes
// jmp ecx => FF E1
//
0xFF, 0xE1,
};
/**
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
);
/**
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;
}
}
/**
Begin executing an EBC image.
This is a thunk function. Microsoft x64 compiler only provide fast_call
calling convention, so the first four arguments are passed by rcx, rdx,
r8, and r9, while other arguments are passed in stack.
@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.
//
//
// Align the stack on a natural boundary
//
//
// Allocate stack pool
//
Status = GetEBCStack((EFI_HANDLE)-1, &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] &= ~((VM_REGISTER)(sizeof (UINTN) - 1));
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];
VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
//
// For IA32, this is where we say our return address is
//
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg16;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg15;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg14;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg13;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg12;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg11;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg10;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg9;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg8;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg7;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg6;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg5;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg4;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg3;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg2;
VmContext.Gpr[0] -= sizeof (UINTN);
*(UINTN *) (UINTN) (VmContext.Gpr[0]) = (UINTN) Arg1;
VmContext.Gpr[0] -= 16;
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.
//
//
// 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
)
{
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;
}

206
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s Normal file
View file

@ -0,0 +1,206 @@
///** @file
//
// Contains low level routines for the Virtual Machine implementation
// on an Itanium-based platform.
//
// Copyright (c) 2006 - 2011, 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.
//
//**/
.file "EbcLowLevel.s"
#define PROCEDURE_ENTRY(name) .##text; \
.##type name, @function; \
.##proc name; \
name::
#define PROCEDURE_EXIT(name) .##endp name
// Note: use of NESTED_SETUP requires number of locals (l) >= 3
#define NESTED_SETUP(i,l,o,r) \
alloc loc1=ar##.##pfs,i,l,o,r ;\
mov loc0=b0
#define NESTED_RETURN \
mov b0=loc0 ;\
mov ar##.##pfs=loc1 ;;\
br##.##ret##.##dpnt b0;;
.type CopyMem, @function;
//-----------------------------------------------------------------------------
//++
// EbcAsmLLCALLEX
//
// Implements the low level EBC CALLEX instruction. Sets up the
// stack pointer, does the spill of function arguments, and
// calls the native function. On return it restores the original
// stack pointer and returns to the caller.
//
// Arguments :
//
// On Entry :
// in0 = Address of native code to call
// in1 = New stack pointer
//
// Return Value:
//
// As per static calling conventions.
//
//--
//---------------------------------------------------------------------------
;// void EbcAsmLLCALLEX (UINTN FunctionAddr, UINTN EbcStackPointer)
PROCEDURE_ENTRY(EbcAsmLLCALLEX)
NESTED_SETUP (2,6,8,0)
// NESTED_SETUP uses loc0 and loc1 for context save
//
// Save a copy of the EBC VM stack pointer
//
mov r8 = in1;;
//
// Copy stack arguments from EBC stack into registers.
// Assume worst case and copy 8.
//
ld8 out0 = [r8], 8;;
ld8 out1 = [r8], 8;;
ld8 out2 = [r8], 8;;
ld8 out3 = [r8], 8;;
ld8 out4 = [r8], 8;;
ld8 out5 = [r8], 8;;
ld8 out6 = [r8], 8;;
ld8 out7 = [r8], 8;;
//
// Save the original stack pointer
//
mov loc2 = r12;
//
// Save the gp
//
or loc3 = r1, r0
//
// Set the new aligned stack pointer. Reserve space for the required
// 16-bytes of scratch area as well.
//
add r12 = 48, in1
//
// Now call the function. Load up the function address from the descriptor
// pointed to by in0. Then get the gp from the descriptor at the following
// address in the descriptor.
//
ld8 r31 = [in0], 8;;
ld8 r30 = [in0];;
mov b1 = r31
mov r1 = r30
(p0) br.call.dptk.many b0 = b1;;
//
// Restore the original stack pointer and gp
//
mov r12 = loc2
or r1 = loc3, r0
//
// Now return
//
NESTED_RETURN
PROCEDURE_EXIT(EbcAsmLLCALLEX)
//-----------------------------------------------------------------------------
//++
// EbcLLCALLEXNative
//
// This function is called to execute an EBC CALLEX instruction.
// This instruction requires that we thunk out to external native
// code. On return, we restore the stack pointer to its original location.
// Destroys no working registers. For IPF, at least 8 register slots
// must be allocated on the stack frame to support any number of
// arguments beiung passed to the external native function. The
// size of the stack frame is FramePtr - EbcSp. If this size is less
// than 64-bytes, the amount of stack frame allocated is rounded up
// to 64-bytes
//
// Arguments On Entry :
// in0 = CallAddr The function address.
// in1 = EbcSp The new EBC stack pointer.
// in2 = FramePtr The frame pointer.
//
// Return Value:
// None
//
// C Function Prototype:
// VOID
// EFIAPI
// EbcLLCALLEXNative (
// IN UINTN CallAddr,
// IN UINTN EbcSp,
// IN VOID *FramePtr
// );
//--
//---------------------------------------------------------------------------
PROCEDURE_ENTRY(EbcLLCALLEXNative)
NESTED_SETUP (3,6,3,0)
mov loc2 = in2;; // loc2 = in2 = FramePtr
mov loc3 = in1;; // loc3 = in1 = EbcSp
sub loc2 = loc2, loc3;; // loc2 = loc2 - loc3 = FramePtr - EbcSp
mov out2 = loc2;; // out2 = loc2 = FramePtr - EbcSp
mov loc4 = 0x40;; // loc4 = 0x40
cmp.leu p6 = out2, loc4;; // IF out2 < loc4 THEN P6=1 ELSE P6=0; IF (FramePtr - EbcSp) < 0x40 THEN P6 = 1 ELSE P6=0
(p6) mov loc2 = loc4;; // IF P6==1 THEN loc2 = loc4 = 0x40
mov loc4 = r12;; // save sp
or loc5 = r1, r0 // save gp
sub r12 = r12, loc2;; // sp = sp - loc2 = sp - MAX (0x40, FramePtr - EbcSp)
and r12 = -0x10, r12 // Round sp down to the nearest 16-byte boundary
mov out1 = in1;; // out1 = EbcSp
mov out0 = r12;; // out0 = sp
adds r12 = -0x8, r12
(p0) br.call.dptk.many b0 = CopyMem;; // CopyMem (sp, EbcSp, (FramePtr - EbcSp))
adds r12 = 0x8, r12
mov out0 = in0;; // out0 = CallAddr
mov out1 = r12;; // out1 = sp
(p0) br.call.dptk.many b0 = EbcAsmLLCALLEX;; // EbcAsmLLCALLEX (CallAddr, sp)
mov r12 = loc4;; // restore sp
or r1 = loc5, r0 // restore gp
NESTED_RETURN
PROCEDURE_EXIT(EbcLLCALLEXNative)
//
// UINTN EbcLLGetEbcEntryPoint(VOID)
//
// Description:
// Simply return, so that the caller retrieves the return register
// contents (R8). That's where the thunk-to-ebc code stuffed the
// EBC entry point.
//
PROCEDURE_ENTRY(EbcLLGetEbcEntryPoint)
br.ret.sptk b0 ;;
PROCEDURE_EXIT(EbcLLGetEbcEntryPoint)

879
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c Normal file
View file

@ -0,0 +1,879 @@
/** @file
This module contains EBC support routines that are customized based on
the target processor.
Copyright (c) 2006 - 2012, 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"
#include "EbcSupport.h"
/**
Given raw bytes of Itanium based code, format them into a bundle and
write them out.
@param MemPtr pointer to memory location to write the bundles
to.
@param Template 5-bit template.
@param Slot0 Instruction slot 0 data for the bundle.
@param Slot1 Instruction slot 1 data for the bundle.
@param Slot2 Instruction slot 2 data for the bundle.
@retval EFI_INVALID_PARAMETER Pointer is not aligned
@retval EFI_INVALID_PARAMETER No more than 5 bits in template
@retval EFI_INVALID_PARAMETER More than 41 bits used in code
@retval EFI_SUCCESS All data is written.
**/
EFI_STATUS
WriteBundle (
IN VOID *MemPtr,
IN UINT8 Template,
IN UINT64 Slot0,
IN UINT64 Slot1,
IN UINT64 Slot2
);
/**
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;
}
/**
Begin executing an EBC image. The address of the entry point is passed
in via a processor register, so we'll need to make a call to get the
value.
This is a thunk function. Microsoft x64 compiler only provide fast_call
calling convention, so the first four arguments are passed by rcx, rdx,
r8, and r9, while other arguments are passed in stack.
@param Arg1 The 1st argument.
@param ... The variable arguments list.
@return The value returned by the EBC application we're going to run.
**/
UINT64
EFIAPI
EbcInterpret (
UINT64 Arg1,
...
)
{
//
// Create a new VM context on the stack
//
VM_CONTEXT VmContext;
UINTN Addr;
EFI_STATUS Status;
UINTN StackIndex;
VA_LIST List;
UINT64 Arg2;
UINT64 Arg3;
UINT64 Arg4;
UINT64 Arg5;
UINT64 Arg6;
UINT64 Arg7;
UINT64 Arg8;
UINT64 Arg9;
UINT64 Arg10;
UINT64 Arg11;
UINT64 Arg12;
UINT64 Arg13;
UINT64 Arg14;
UINT64 Arg15;
UINT64 Arg16;
//
// Get the EBC entry point from the processor register. Make sure you don't
// call any functions before this or you could mess up the register the
// entry point is passed in.
//
Addr = EbcLLGetEbcEntryPoint ();
//
// Need the args off the stack.
//
VA_START (List, Arg1);
Arg2 = VA_ARG (List, UINT64);
Arg3 = VA_ARG (List, UINT64);
Arg4 = VA_ARG (List, UINT64);
Arg5 = VA_ARG (List, UINT64);
Arg6 = VA_ARG (List, UINT64);
Arg7 = VA_ARG (List, UINT64);
Arg8 = VA_ARG (List, UINT64);
Arg9 = VA_ARG (List, UINT64);
Arg10 = VA_ARG (List, UINT64);
Arg11 = VA_ARG (List, UINT64);
Arg12 = VA_ARG (List, UINT64);
Arg13 = VA_ARG (List, UINT64);
Arg14 = VA_ARG (List, UINT64);
Arg15 = VA_ARG (List, UINT64);
Arg16 = VA_ARG (List, UINT64);
VA_END (List);
//
// 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.
//
//
// NOTE: Eventually we should have the interpreter allocate memory
// for stack space which it will use during its execution. This
// would likely improve performance because the interpreter would
// no longer be required to test each memory access and adjust
// those reading from the stack gap.
//
// For IPF, the stack looks like (assuming 10 args passed)
// arg10
// arg9 (Bottom of high stack)
// [ stack gap for interpreter execution ]
// [ magic value for detection of stack corruption ]
// arg8 (Top of low stack)
// arg7....
// arg1
// [ 64-bit return address ]
// [ ebc stack ]
// If the EBC accesses memory in the stack gap, then we assume that it's
// actually trying to access args9 and greater. Therefore we need to
// adjust memory accesses in this region to point above the stack gap.
//
//
// Now adjust the EBC stack pointer down to leave a gap for interpreter
// execution. Then stuff a magic value there.
//
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);
PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
VmContext.StackMagicPtr = (UINTN *) VmContext.Gpr[0];
VmContext.LowStackTop = (UINTN) VmContext.Gpr[0];
//
// Push the EBC arguments on the stack. Does not matter that they may not
// all be valid.
//
PushU64 (&VmContext, Arg16);
PushU64 (&VmContext, Arg15);
PushU64 (&VmContext, Arg14);
PushU64 (&VmContext, Arg13);
PushU64 (&VmContext, Arg12);
PushU64 (&VmContext, Arg11);
PushU64 (&VmContext, Arg10);
PushU64 (&VmContext, Arg9);
PushU64 (&VmContext, Arg8);
PushU64 (&VmContext, Arg7);
PushU64 (&VmContext, Arg6);
PushU64 (&VmContext, Arg5);
PushU64 (&VmContext, Arg4);
PushU64 (&VmContext, Arg3);
PushU64 (&VmContext, Arg2);
PushU64 (&VmContext, Arg1);
//
// Push a bogus return address on the EBC stack because the
// interpreter expects one there. For stack alignment purposes on IPF,
// EBC return addresses are always 16 bytes. Push a bogus value as well.
//
PushU64 (&VmContext, 0);
PushU64 (&VmContext, 0xDEADBEEFDEADBEEF);
VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
//
// 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. The address of the entry point is passed
in via a processor register, so we'll need to make a call to get the
value.
@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 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 from the processor register. Make sure you don't
// call any functions before this or you could mess up the register the
// entry point is passed in.
//
Addr = EbcLLGetEbcEntryPoint ();
//
// 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;
//
// Get the stack pointer. This is the bottom of the upper stack.
//
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);
//
// Allocate stack space for the interpreter. Then put a magic value
// at the bottom so we can detect stack corruption.
//
PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.Gpr[0];
//
// When we thunk to external native code, we copy the last 8 qwords from
// the EBC stack into the processor registers, and adjust the stack pointer
// up. If the caller is not passing 8 parameters, then we've moved the
// stack pointer up into the stack gap. If this happens, then the caller
// can mess up the stack gap contents (in particular our magic value).
// Therefore, leave another gap below the magic value. Pick 10 qwords down,
// just as a starting point.
//
VmContext.Gpr[0] -= 10 * sizeof (UINT64);
//
// Align the stack pointer such that after pushing the system table,
// image handle, and return address on the stack, it's aligned on a 16-byte
// boundary as required for IPF.
//
VmContext.Gpr[0] &= (INT64)~0x0f;
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);
//
// Interpreter assumes 64-bit return address is pushed on the stack.
// IPF does not do this so pad the stack accordingly. Also, a
// "return address" is 16 bytes as required for IPF stack alignments.
//
PushU64 (&VmContext, (UINT64) 0);
PushU64 (&VmContext, (UINT64) 0x1234567887654321);
VmContext.StackRetAddr = (UINT64) VmContext.Gpr[0];
//
// 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;
UINT64 Addr;
UINT64 Code[3]; // Code in a bundle
UINT64 RegNum; // register number for MOVL
UINT64 BitI; // bits of MOVL immediate data
UINT64 BitIc; // bits of MOVL immediate data
UINT64 BitImm5c; // bits of MOVL immediate data
UINT64 BitImm9d; // bits of MOVL immediate data
UINT64 BitImm7b; // bits of MOVL immediate data
UINT64 Br; // branch register for loading and jumping
UINT64 *Data64Ptr;
UINT32 ThunkSize;
UINT32 Size;
//
// Check alignment of pointer to EBC code, which must always be aligned
// on a 2-byte boundary.
//
if ((UINT32) (UINTN) EbcEntryPoint & 0x01) {
return EFI_INVALID_PARAMETER;
}
//
// Allocate memory for the thunk. Make the (most likely incorrect) assumption
// that the returned buffer is not aligned, so round up to the next
// alignment size.
//
Size = EBC_THUNK_SIZE + EBC_THUNK_ALIGNMENT - 1;
ThunkSize = Size;
Ptr = AllocatePool (Size);
if (Ptr == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// Save the start address of the buffer.
//
ThunkBase = Ptr;
//
// Make sure it's aligned for code execution. If not, then
// round up.
//
if ((UINT32) (UINTN) Ptr & (EBC_THUNK_ALIGNMENT - 1)) {
Ptr = (UINT8 *) (((UINTN) Ptr + (EBC_THUNK_ALIGNMENT - 1)) &~ (UINT64) (EBC_THUNK_ALIGNMENT - 1));
}
//
// Return the pointer to the thunk to the caller to user as the
// image entry point.
//
*Thunk = (VOID *) Ptr;
//
// Clear out the thunk entry
// ZeroMem(Ptr, Size);
//
// For IPF, when you do a call via a function pointer, the function pointer
// actually points to a function descriptor which consists of a 64-bit
// address of the function, followed by a 64-bit gp for the function being
// called. See the the Software Conventions and Runtime Architecture Guide
// for details.
// So first off in our thunk, create a descriptor for our actual thunk code.
// This means we need to create a pointer to the thunk code (which follows
// the descriptor we're going to create), followed by the gp of the Vm
// interpret function we're going to eventually execute.
//
Data64Ptr = (UINT64 *) Ptr;
//
// Write the function's entry point (which is our thunk code that follows
// this descriptor we're creating).
//
*Data64Ptr = (UINT64) (Data64Ptr + 2);
//
// Get the gp from the descriptor for EbcInterpret and stuff it in our thunk
// descriptor.
//
*(Data64Ptr + 1) = *(UINT64 *) ((UINT64 *) (UINTN) EbcInterpret + 1);
//
// Advance our thunk data pointer past the descriptor. Since the
// descriptor consists of 16 bytes, the pointer is still aligned for
// IPF code execution (on 16-byte boundary).
//
Ptr += sizeof (UINT64) * 2;
//
// *************************** MAGIC BUNDLE ********************************
//
// Write magic code bundle for: movl r8 = 0xca112ebcca112ebc to help the VM
// to recognize it is a thunk.
//
Addr = (UINT64) 0xCA112EBCCA112EBC;
//
// Now generate the code bytes. First is nop.m 0x0
//
Code[0] = OPCODE_NOP;
//
// Next is simply Addr[62:22] (41 bits) of the address
//
Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
//
// Extract bits from the address for insertion into the instruction
// i = Addr[63:63]
//
BitI = RShiftU64 (Addr, 63) & 0x01;
//
// ic = Addr[21:21]
//
BitIc = RShiftU64 (Addr, 21) & 0x01;
//
// imm5c = Addr[20:16] for 5 bits
//
BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
//
// imm9d = Addr[15:7] for 9 bits
//
BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
//
// imm7b = Addr[6:0] for 7 bits
//
BitImm7b = Addr & 0x7F;
//
// The EBC entry point will be put into r8, so r8 can be used here
// temporary. R8 is general register and is auto-serialized.
//
RegNum = 8;
//
// Next is jumbled data, including opcode and rest of address
//
Code[2] = LShiftU64 (BitImm7b, 13);
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
Code[2] = Code[2] | LShiftU64 (BitIc, 21);
Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
Code[2] = Code[2] | LShiftU64 (BitI, 36);
Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
//
// *************************** FIRST BUNDLE ********************************
//
// Write code bundle for: movl r8 = EBC_ENTRY_POINT so we pass
// the ebc entry point in to the interpreter function via a processor
// register.
// Note -- we could easily change this to pass in a pointer to a structure
// that contained, among other things, the EBC image's entry point. But
// for now pass it directly.
//
Ptr += 16;
Addr = (UINT64) EbcEntryPoint;
//
// Now generate the code bytes. First is nop.m 0x0
//
Code[0] = OPCODE_NOP;
//
// Next is simply Addr[62:22] (41 bits) of the address
//
Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
//
// Extract bits from the address for insertion into the instruction
// i = Addr[63:63]
//
BitI = RShiftU64 (Addr, 63) & 0x01;
//
// ic = Addr[21:21]
//
BitIc = RShiftU64 (Addr, 21) & 0x01;
//
// imm5c = Addr[20:16] for 5 bits
//
BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
//
// imm9d = Addr[15:7] for 9 bits
//
BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
//
// imm7b = Addr[6:0] for 7 bits
//
BitImm7b = Addr & 0x7F;
//
// Put the EBC entry point in r8, which is the location of the return value
// for functions.
//
RegNum = 8;
//
// Next is jumbled data, including opcode and rest of address
//
Code[2] = LShiftU64 (BitImm7b, 13);
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
Code[2] = Code[2] | LShiftU64 (BitIc, 21);
Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
Code[2] = Code[2] | LShiftU64 (BitI, 36);
Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
//
// *************************** NEXT BUNDLE *********************************
//
// Write code bundle for:
// movl rx = offset_of(EbcInterpret|ExecuteEbcImageEntryPoint)
//
// Advance pointer to next bundle, then compute the offset from this bundle
// to the address of the entry point of the interpreter.
//
Ptr += 16;
if ((Flags & FLAG_THUNK_ENTRY_POINT) != 0) {
Addr = (UINT64) ExecuteEbcImageEntryPoint;
} else {
Addr = (UINT64) EbcInterpret;
}
//
// Indirection on Itanium-based systems
//
Addr = *(UINT64 *) Addr;
//
// Now write the code to load the offset into a register
//
Code[0] = OPCODE_NOP;
//
// Next is simply Addr[62:22] (41 bits) of the address
//
Code[1] = RShiftU64 (Addr, 22) & 0x1ffffffffff;
//
// Extract bits from the address for insertion into the instruction
// i = Addr[63:63]
//
BitI = RShiftU64 (Addr, 63) & 0x01;
//
// ic = Addr[21:21]
//
BitIc = RShiftU64 (Addr, 21) & 0x01;
//
// imm5c = Addr[20:16] for 5 bits
//
BitImm5c = RShiftU64 (Addr, 16) & 0x1F;
//
// imm9d = Addr[15:7] for 9 bits
//
BitImm9d = RShiftU64 (Addr, 7) & 0x1FF;
//
// imm7b = Addr[6:0] for 7 bits
//
BitImm7b = Addr & 0x7F;
//
// Put it in r31, a scratch register
//
RegNum = 31;
//
// Next is jumbled data, including opcode and rest of address
//
Code[2] = LShiftU64(BitImm7b, 13);
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
Code[2] = Code[2] | LShiftU64 (BitIc, 21);
Code[2] = Code[2] | LShiftU64 (BitImm5c, 22);
Code[2] = Code[2] | LShiftU64 (BitImm9d, 27);
Code[2] = Code[2] | LShiftU64 (BitI, 36);
Code[2] = Code[2] | LShiftU64 ((UINT64)MOVL_OPCODE, 37);
Code[2] = Code[2] | LShiftU64 ((RegNum & 0x7F), 6);
WriteBundle ((VOID *) Ptr, 0x05, Code[0], Code[1], Code[2]);
//
// *************************** NEXT BUNDLE *********************************
//
// Load branch register with EbcInterpret() function offset from the bundle
// address: mov b6 = RegNum
//
// See volume 3 page 4-29 of the Arch. Software Developer's Manual.
//
// Advance pointer to next bundle
//
Ptr += 16;
Code[0] = OPCODE_NOP;
Code[1] = OPCODE_NOP;
Code[2] = OPCODE_MOV_BX_RX;
//
// Pick a branch register to use. Then fill in the bits for the branch
// register and user register (same user register as previous bundle).
//
Br = 6;
Code[2] |= LShiftU64 (Br, 6);
Code[2] |= LShiftU64 (RegNum, 13);
WriteBundle ((VOID *) Ptr, 0x0d, Code[0], Code[1], Code[2]);
//
// *************************** NEXT BUNDLE *********************************
//
// Now do the branch: (p0) br.cond.sptk.few b6
//
// Advance pointer to next bundle.
// Fill in the bits for the branch register (same reg as previous bundle)
//
Ptr += 16;
Code[0] = OPCODE_NOP;
Code[1] = OPCODE_NOP;
Code[2] = OPCODE_BR_COND_SPTK_FEW;
Code[2] |= LShiftU64 (Br, 13);
WriteBundle ((VOID *) Ptr, 0x1d, Code[0], Code[1], Code[2]);
//
// Add the thunk to our list of allocated thunks so we can do some cleanup
// when the image is unloaded. Do this last since the Add function flushes
// the instruction cache for us.
//
EbcAddImageThunk (ImageHandle, (VOID *) ThunkBase, ThunkSize);
//
// Done
//
return EFI_SUCCESS;
}
/**
Given raw bytes of Itanium based code, format them into a bundle and
write them out.
@param MemPtr pointer to memory location to write the bundles
to.
@param Template 5-bit template.
@param Slot0 Instruction slot 0 data for the bundle.
@param Slot1 Instruction slot 1 data for the bundle.
@param Slot2 Instruction slot 2 data for the bundle.
@retval EFI_INVALID_PARAMETER Pointer is not aligned
@retval EFI_INVALID_PARAMETER No more than 5 bits in template
@retval EFI_INVALID_PARAMETER More than 41 bits used in code
@retval EFI_SUCCESS All data is written.
**/
EFI_STATUS
WriteBundle (
IN VOID *MemPtr,
IN UINT8 Template,
IN UINT64 Slot0,
IN UINT64 Slot1,
IN UINT64 Slot2
)
{
UINT8 *BPtr;
UINT32 Index;
UINT64 Low64;
UINT64 High64;
//
// Verify pointer is aligned
//
if ((UINT64) MemPtr & 0xF) {
return EFI_INVALID_PARAMETER;
}
//
// Verify no more than 5 bits in template
//
if ((Template &~0x1F) != 0) {
return EFI_INVALID_PARAMETER;
}
//
// Verify max of 41 bits used in code
//
if (((Slot0 | Slot1 | Slot2) &~0x1ffffffffff) != 0) {
return EFI_INVALID_PARAMETER;
}
Low64 = LShiftU64 (Slot1, 46);
Low64 = Low64 | LShiftU64 (Slot0, 5) | Template;
High64 = RShiftU64 (Slot1, 18);
High64 = High64 | LShiftU64 (Slot2, 23);
//
// Now write it all out
//
BPtr = (UINT8 *) MemPtr;
for (Index = 0; Index < 8; Index++) {
*BPtr = (UINT8) Low64;
Low64 = RShiftU64 (Low64, 8);
BPtr++;
}
for (Index = 0; Index < 8; Index++) {
*BPtr = (UINT8) High64;
High64 = RShiftU64 (High64, 8);
BPtr++;
}
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;
UINTN CodeOne18;
UINTN CodeOne23;
UINTN CodeTwoI;
UINTN CodeTwoIc;
UINTN CodeTwo7b;
UINTN CodeTwo5c;
UINTN CodeTwo9d;
UINTN CalleeAddr;
IsThunk = 1;
TargetEbcAddr = 0;
//
// FuncAddr points to the descriptor of the target instructions.
//
CalleeAddr = *((UINT64 *)FuncAddr);
//
// Processor specific code to check whether the callee is a thunk to EBC.
//
if (*((UINT64 *)CalleeAddr) != 0xBCCA000100000005) {
IsThunk = 0;
goto Action;
}
if (*((UINT64 *)CalleeAddr + 1) != 0x697623C1004A112E) {
IsThunk = 0;
goto Action;
}
CodeOne18 = RShiftU64 (*((UINT64 *)CalleeAddr + 2), 46) & 0x3FFFF;
CodeOne23 = (*((UINT64 *)CalleeAddr + 3)) & 0x7FFFFF;
CodeTwoI = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 59) & 0x1;
CodeTwoIc = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 44) & 0x1;
CodeTwo7b = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 36) & 0x7F;
CodeTwo5c = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 45) & 0x1F;
CodeTwo9d = RShiftU64 (*((UINT64 *)CalleeAddr + 3), 50) & 0x1FF;
TargetEbcAddr = CodeTwo7b;
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo9d, 7);
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwo5c, 16);
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoIc, 21);
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne18, 22);
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeOne23, 40);
TargetEbcAddr = TargetEbcAddr | LShiftU64 (CodeTwoI, 63);
Action:
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) (VmPtr->Ip + Size));
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;
}
}

41
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h Normal file
View file

@ -0,0 +1,41 @@
/** @file
Definition of EBC Support function.
Copyright (c) 2006 - 2008, 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.
**/
#ifndef _IPF_EBC_SUPPORT_H_
#define _IPF_EBC_SUPPORT_H_
#define VM_STACK_SIZE (1024 * 32)
#define EBC_THUNK_SIZE 128
#define STACK_REMAIN_SIZE (1024 * 4)
//
// For code execution, thunks must be aligned on 16-byte boundary
//
#define EBC_THUNK_ALIGNMENT 16
//
// Opcodes for IPF instructions. We'll need to hand-create thunk code (stuffing
// bits) to insert a jump to the interpreter.
//
#define OPCODE_NOP (UINT64) 0x00008000000
#define OPCODE_BR_COND_SPTK_FEW (UINT64) 0x00100000000
#define OPCODE_MOV_BX_RX (UINT64) 0x00E00100000
//
// Opcode for MOVL instruction
//
#define MOVL_OPCODE 0x06
#endif

147
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.S Normal file
View file

@ -0,0 +1,147 @@
#/** @file
#
# This code provides low level routines that support the Virtual Machine
# for option ROMs.
#
# 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 x64, we switch stacks, copy the arguments to the stack
# and jump to the specified function.
# On return, we restore the stack pointer to its original location.
#
# Destroys no working registers.
#****************************************************************************
# VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
ASM_GLOBAL ASM_PFX(EbcLLCALLEXNative);
ASM_PFX(EbcLLCALLEXNative):
push %rbp
push %rbx
mov %rsp, %rbp
# Function prolog
# Copy FuncAddr to a preserved register.
mov %rcx, %rbx
# Set stack pointer to new value
sub %rdx, %r8
#
# Fix X64 native function call prolog. Prepare space for at least 4 arguments,
# even if the native function's arguments are less than 4.
#
# From MSDN x64 Software Conventions, Overview of x64 Calling Conventions:
# "The caller is responsible for allocating space for parameters to the
# callee, and must always allocate sufficient space for the 4 register
# parameters, even if the callee doesn't have that many parameters.
# This aids in the simplicity of supporting C unprototyped functions,
# and vararg C/C++ functions."
#
cmp $0x20, %r8
jae skip_expansion
mov $0x20, %r8
skip_expansion:
sub %r8, %rsp
#
# Fix X64 native function call 16-byte alignment.
#
# From MSDN x64 Software Conventions, Stack Usage:
# "The stack will always be maintained 16-byte aligned, except within
# the prolog (for example, after the return address is pushed)."
#
and $0xFFFFFFFFFFFFFFF0, %rsp
mov %rsp, %rcx
sub $0x20, %rsp
call ASM_PFX(CopyMem)
add $0x20, %rsp
# Considering the worst case, load 4 potiential arguments
# into registers.
mov (%rsp), %rcx
mov 0x8(%rsp), %rdx
mov 0x10(%rsp), %r8
mov 0x18(%rsp), %r9
# Now call the external routine
call *%rbx
# Function epilog
mov %rbp, %rsp
pop %rbx
pop %rbp
ret
ASM_GLOBAL ASM_PFX(EbcLLEbcInterpret);
ASM_PFX(EbcLLEbcInterpret):
# save old parameter to stack
mov %rcx, 0x8(%rsp)
mov %rdx, 0x10(%rsp)
mov %r8, 0x18(%rsp)
mov %r9, 0x20(%rsp)
# Construct new stack
push %rbp
mov %rsp, %rbp
push %rsi
push %rdi
push %rbx
sub $0x80, %rsp
push %r10
mov %rbp, %rsi
add $0x10, %rsi
mov %rsp, %rdi
add $0x8, %rdi
mov $0x10, %rcx
rep movsq
# build new paramater calling convention
mov 0x18(%rsp), %r9
mov 0x10(%rsp), %r8
mov 0x8(%rsp), %rdx
mov %r10, %rcx
# call C-code
call ASM_PFX(EbcInterpret)
add $0x88, %esp
pop %rbx
pop %rdi
pop %rsi
pop %rbp
ret
ASM_GLOBAL ASM_PFX(EbcLLExecuteEbcImageEntryPoint);
ASM_PFX(EbcLLExecuteEbcImageEntryPoint):
# build new paramater calling convention
mov %rdx, %r8
mov %rcx, %rdx
mov %r10, %rcx
# call C-code
sub $0x28, %rsp
call ASM_PFX(ExecuteEbcImageEntryPoint)
add $0x28, %rsp
ret

246
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/X64/EbcLowLevel.asm Normal file
View file

@ -0,0 +1,246 @@
;/** @file
;
; This code provides low level routines that support the Virtual Machine.
; for option ROMs.
;
; Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
; Copyright (c) 2014 Hewlett-Packard Development Company, L.P.<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.
;
;**/
page ,132
title VM ASSEMBLY LANGUAGE ROUTINES
;---------------------------------------------------------------------------
; Equate files needed.
;---------------------------------------------------------------------------
.CODE
CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD
EbcInterpret PROTO
ExecuteEbcImageEntryPoint PROTO
;****************************************************************************
; EbcLLCALLEX
;
; This function is called to execute an EBC CALLEX instruction.
; This instruction requires that we thunk out to external native
; code. For x64, we switch stacks, copy the arguments to the stack
; and jump to the specified function.
; On return, we restore the stack pointer to its original location.
;
; Destroys no working registers.
;****************************************************************************
; INT64 EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr)
EbcLLCALLEXNative PROC PUBLIC
push rbp
push rbx
mov rbp, rsp
; Function prolog
; Copy FuncAddr to a preserved register.
mov rbx, rcx
; Set stack pointer to new value
sub r8, rdx
;
; Fix X64 native function call prolog. Prepare space for at least 4 arguments,
; even if the native function's arguments are less than 4.
;
; From MSDN x64 Software Conventions, Overview of x64 Calling Conventions:
; "The caller is responsible for allocating space for parameters to the
; callee, and must always allocate sufficient space for the 4 register
; parameters, even if the callee doesn't have that many parameters.
; This aids in the simplicity of supporting C unprototyped functions,
; and vararg C/C++ functions."
;
cmp r8, 20h
jae skip_expansion
mov r8, 20h
skip_expansion:
sub rsp, r8
;
; Fix X64 native function call 16-byte alignment.
;
; From MSDN x64 Software Conventions, Stack Usage:
; "The stack will always be maintained 16-byte aligned, except within
; the prolog (for example, after the return address is pushed)."
;
and rsp, NOT 0fh
mov rcx, rsp
sub rsp, 20h
call CopyMem
add rsp, 20h
; Considering the worst case, load 4 potiential arguments
; into registers.
mov rcx, qword ptr [rsp]
mov rdx, qword ptr [rsp+8h]
mov r8, qword ptr [rsp+10h]
mov r9, qword ptr [rsp+18h]
; Now call the external routine
call rbx
; Function epilog
mov rsp, rbp
pop rbx
pop rbp
ret
EbcLLCALLEXNative ENDP
;****************************************************************************
; EbcLLEbcInterpret
;
; Begin executing an EBC image.
;****************************************************************************
; UINT64 EbcLLEbcInterpret(VOID)
EbcLLEbcInterpret PROC PUBLIC
;
;; mov rax, ca112ebccall2ebch
;; mov r10, EbcEntryPoint
;; mov r11, EbcLLEbcInterpret
;; jmp r11
;
; Caller uses above instruction to jump here
; The stack is below:
; +-----------+
; | RetAddr |
; +-----------+
; |EntryPoint | (R10)
; +-----------+
; | Arg1 | <- RDI
; +-----------+
; | Arg2 |
; +-----------+
; | ... |
; +-----------+
; | Arg16 |
; +-----------+
; | Dummy |
; +-----------+
; | RDI |
; +-----------+
; | RSI |
; +-----------+
; | RBP | <- RBP
; +-----------+
; | RetAddr | <- RSP is here
; +-----------+
; | Scratch1 | (RCX) <- RSI
; +-----------+
; | Scratch2 | (RDX)
; +-----------+
; | Scratch3 | (R8)
; +-----------+
; | Scratch4 | (R9)
; +-----------+
; | Arg5 |
; +-----------+
; | Arg6 |
; +-----------+
; | ... |
; +-----------+
; | Arg16 |
; +-----------+
;
; save old parameter to stack
mov [rsp + 08h], rcx
mov [rsp + 10h], rdx
mov [rsp + 18h], r8
mov [rsp + 20h], r9
; Construct new stack
push rbp
mov rbp, rsp
push rsi
push rdi
push rbx
sub rsp, 80h
push r10
mov rsi, rbp
add rsi, 10h
mov rdi, rsp
add rdi, 8
mov rcx, 16
rep movsq
; build new paramater calling convention
mov r9, [rsp + 18h]
mov r8, [rsp + 10h]
mov rdx, [rsp + 08h]
mov rcx, r10
; call C-code
call EbcInterpret
add rsp, 88h
pop rbx
pop rdi
pop rsi
pop rbp
ret
EbcLLEbcInterpret ENDP
;****************************************************************************
; EbcLLExecuteEbcImageEntryPoint
;
; Begin executing an EBC image.
;****************************************************************************
; UINT64 EbcLLExecuteEbcImageEntryPoint(VOID)
EbcLLExecuteEbcImageEntryPoint PROC PUBLIC
;
;; mov rax, ca112ebccall2ebch
;; mov r10, EbcEntryPoint
;; mov r11, EbcLLExecuteEbcImageEntryPoint
;; jmp r11
;
; Caller uses above instruction to jump here
; The stack is below:
; +-----------+
; | RetAddr |
; +-----------+
; |EntryPoint | (R10)
; +-----------+
; |ImageHandle|
; +-----------+
; |SystemTable|
; +-----------+
; | Dummy |
; +-----------+
; | Dummy |
; +-----------+
; | RetAddr | <- RSP is here
; +-----------+
; |ImageHandle| (RCX)
; +-----------+
; |SystemTable| (RDX)
; +-----------+
;
; build new paramater calling convention
mov r8, rdx
mov rdx, rcx
mov rcx, r10
; call C-code
sub rsp, 28h
call ExecuteEbcImageEntryPoint
add rsp, 28h
ret
EbcLLExecuteEbcImageEntryPoint ENDP
END

573
android/device/linaro/bootloader/edk2/MdeModulePkg/Universal/EbcDxe/X64/EbcSupport.c Normal file
View file

@ -0,0 +1,573 @@
/** @file
This module contains EBC support routines that are customized based on
the target x64 processor.
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"
//
// NOTE: This is the stack size allocated for the interpreter
// when it executes an EBC image. The requirements can change
// based on whether or not a debugger is present, and other
// platform-specific configurations.
//
#define VM_STACK_SIZE (1024 * 8)
#define STACK_REMAIN_SIZE (1024 * 4)
//
// This is instruction buffer used to create EBC thunk
//
#define EBC_ENTRYPOINT_SIGNATURE 0xAFAFAFAFAFAFAFAFull
#define EBC_LL_EBC_ENTRYPOINT_SIGNATURE 0xFAFAFAFAFAFAFAFAull
UINT8 mInstructionBufferTemplate[] = {
//
// Add a magic code here to help the VM recognize the thunk..
// mov rax, 0xca112ebcca112ebc => 48 B8 BC 2E 11 CA BC 2E 11 CA
//
0x48, 0xB8, 0xBC, 0x2E, 0x11, 0xCA, 0xBC, 0x2E, 0x11, 0xCA,
//
// Add code bytes to load up a processor register with the EBC entry point.
// mov r10, EbcEntryPoint => 49 BA XX XX XX XX XX XX XX XX (To be fixed at runtime)
// These 8 bytes of the thunk entry is the address of the EBC
// entry point.
//
0x49, 0xBA,
(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),
//
// Stick in a load of r11 with the address of appropriate VM function.
// mov r11, EbcLLEbcInterpret => 49 BB XX XX XX XX XX XX XX XX (To be fixed at runtime)
//
0x49, 0xBB,
(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),
//
// Stick in jump opcode bytes
// jmp r11 => 41 FF E3
//
0x41, 0xFF, 0xE3,
};
/**
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. Microsoft x64 compiler only provide fast_call
calling convention, so the first four arguments are passed by rcx, rdx,
r8, and r9, while other arguments are passed in stack.
@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.
// The x64 does not do this so pad the stack accordingly.
//
PushU64 (&VmContext, (UINT64) 0);
PushU64 (&VmContext, (UINT64) 0x1234567887654321ULL);
//
// For x64, 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 x64, 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;
}
}