Add EBC, FTW, Crc32SectionExtract, NullMemoryTest modules.
CrcSectionExtract cannot build for now for some missing definitions. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2813 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
197
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s
Normal file
197
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s
Normal file
@@ -0,0 +1,197 @@
|
||||
//++
|
||||
// Copyright (c) 2006, Intel Corporation
|
||||
// All rights reserved. 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.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// EbcLowLevel.s
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
// Contains low level routines for the Virtual Machine implementation
|
||||
// on an Itanium-based platform.
|
||||
//
|
||||
//
|
||||
//--
|
||||
|
||||
.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)
|
||||
|
||||
PROCEDURE_ENTRY(EbcLLCALLEXNative)
|
||||
NESTED_SETUP (3,6,3,0)
|
||||
|
||||
mov loc2 = in2;;
|
||||
mov loc3 = in1;;
|
||||
sub loc2 = loc2, loc3
|
||||
mov loc4 = r12;;
|
||||
or loc5 = r1, r0
|
||||
|
||||
sub r12 = r12, loc2
|
||||
mov out2 = loc2;;
|
||||
|
||||
and r12 = -0x10, r12
|
||||
mov out1 = in1;;
|
||||
mov out0 = r12;;
|
||||
adds r12 = -0x8, r12
|
||||
(p0) br.call.dptk.many b0 = CopyMem;;
|
||||
adds r12 = 0x8, r12
|
||||
|
||||
mov out0 = in0;;
|
||||
mov out1 = r12;;
|
||||
(p0) br.call.dptk.many b0 = EbcAsmLLCALLEX;;
|
||||
mov r12 = loc4;;
|
||||
or r1 = loc5, r0
|
||||
|
||||
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)
|
||||
|
||||
//
|
||||
// INT64 EbcLLGetReturnValue(VOID)
|
||||
//
|
||||
// Description:
|
||||
// This function is called to get the value returned by native code
|
||||
// to EBC. It simply returns because the return value should still
|
||||
// be in the register, so the caller just gets the unmodified value.
|
||||
//
|
||||
PROCEDURE_ENTRY(EbcLLGetReturnValue)
|
||||
br.ret.sptk b0 ;;
|
||||
PROCEDURE_EXIT(EbcLLGetReturnValue)
|
||||
|
||||
//
|
||||
// UINTN EbcLLGetStackPointer(VOID)
|
||||
//
|
||||
PROCEDURE_ENTRY(EbcLLGetStackPointer)
|
||||
mov r8 = r12 ;;
|
||||
br.ret.sptk b0 ;;
|
||||
br.sptk.few b6
|
||||
PROCEDURE_EXIT(EbcLLGetStackPointer)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
869
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c
Normal file
869
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c
Normal file
@@ -0,0 +1,869 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. 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.
|
||||
|
||||
Module Name:
|
||||
|
||||
EbcSupport.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This module contains EBC support routines that are customized based on
|
||||
the target processor.
|
||||
|
||||
--*/
|
||||
|
||||
#include "EbcInt.h"
|
||||
#include "EbcExecute.h"
|
||||
#include "EbcSupport.h"
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
WriteBundle (
|
||||
IN VOID *MemPtr,
|
||||
IN UINT8 Template,
|
||||
IN UINT64 Slot0,
|
||||
IN UINT64 Slot1,
|
||||
IN UINT64 Slot2
|
||||
);
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
PushU64 (
|
||||
VM_CONTEXT *VmPtr,
|
||||
UINT64 Arg
|
||||
)
|
||||
{
|
||||
//
|
||||
// Advance the VM stack down, and then copy the argument to the stack.
|
||||
// Hope it's aligned.
|
||||
//
|
||||
VmPtr->R[0] -= sizeof (UINT64);
|
||||
*(UINT64 *) VmPtr->R[0] = Arg;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT64
|
||||
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);
|
||||
//
|
||||
// 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.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
|
||||
VmContext.HighStackBottom = (UINTN) VmContext.R[0];
|
||||
VmContext.R[0] -= sizeof (UINTN);
|
||||
|
||||
|
||||
PushU64 (&VmContext, (UINT64) VM_STACK_KEY_VALUE);
|
||||
VmContext.StackMagicPtr = (UINTN *) VmContext.R[0];
|
||||
VmContext.LowStackTop = (UINTN) VmContext.R[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.R[0];
|
||||
//
|
||||
// Begin executing the EBC code
|
||||
//
|
||||
EbcExecute (&VmContext);
|
||||
//
|
||||
// Return the value in R[7] unless there was an error
|
||||
//
|
||||
ReturnEBCStack(StackIndex);
|
||||
return (UINT64) VmContext.R[7];
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT64
|
||||
ExecuteEbcImageEntryPoint (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN EFI_SYSTEM_TABLE *SystemTable
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
IPF implementation.
|
||||
|
||||
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.
|
||||
|
||||
Arguments:
|
||||
|
||||
ImageHandle - image handle for the EBC application we're executing
|
||||
SystemTable - standard system table passed into an driver's entry point
|
||||
|
||||
Returns:
|
||||
|
||||
The value returned by the EBC application we're going to run.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
Addr = EbcLLGetStackPointer ();
|
||||
|
||||
Status = GetEBCStack(ImageHandle, &VmContext.StackPool, &StackIndex);
|
||||
if (EFI_ERROR(Status)) {
|
||||
return Status;
|
||||
}
|
||||
VmContext.StackTop = (UINT8*)VmContext.StackPool + (STACK_REMAIN_SIZE);
|
||||
VmContext.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE);
|
||||
VmContext.HighStackBottom = (UINTN) VmContext.R[0];
|
||||
VmContext.R[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.R[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.R[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.R[0] &= (INT64)~0x0f;
|
||||
VmContext.LowStackTop = (UINTN) VmContext.R[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.R[0];
|
||||
|
||||
//
|
||||
// Begin executing the EBC code
|
||||
//
|
||||
EbcExecute (&VmContext);
|
||||
|
||||
//
|
||||
// Return the value in R[7] unless there was an error
|
||||
//
|
||||
ReturnEBCStack(StackIndex);
|
||||
return (UINT64) VmContext.R[7];
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EbcCreateThunks (
|
||||
IN EFI_HANDLE ImageHandle,
|
||||
IN VOID *EbcEntryPoint,
|
||||
OUT VOID **Thunk,
|
||||
IN UINT32 Flags
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Create thunks for an EBC image entry point, or an EBC protocol service.
|
||||
|
||||
Arguments:
|
||||
|
||||
ImageHandle - Image handle for the EBC image. If not null, then we're
|
||||
creating a thunk for an image entry point.
|
||||
EbcEntryPoint - Address of the EBC code that the thunk is to call
|
||||
Thunk - Returned thunk we create here
|
||||
Flags - Flags indicating options for creating the thunk
|
||||
|
||||
Returns:
|
||||
|
||||
Standard EFI status.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 *Ptr;
|
||||
UINT8 *ThunkBase;
|
||||
UINT64 Addr;
|
||||
UINT64 Code[3]; // Code in a bundle
|
||||
UINT64 RegNum; // register number for MOVL
|
||||
UINT64 I; // bits of MOVL immediate data
|
||||
UINT64 Ic; // bits of MOVL immediate data
|
||||
UINT64 Imm5c; // bits of MOVL immediate data
|
||||
UINT64 Imm9d; // bits of MOVL immediate data
|
||||
UINT64 Imm7b; // 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]
|
||||
//
|
||||
I = RShiftU64 (Addr, 63) & 0x01;
|
||||
//
|
||||
// ic = Addr[21:21]
|
||||
//
|
||||
Ic = RShiftU64 (Addr, 21) & 0x01;
|
||||
//
|
||||
// imm5c = Addr[20:16] for 5 bits
|
||||
//
|
||||
Imm5c = RShiftU64 (Addr, 16) & 0x1F;
|
||||
//
|
||||
// imm9d = Addr[15:7] for 9 bits
|
||||
//
|
||||
Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
|
||||
//
|
||||
// imm7b = Addr[6:0] for 7 bits
|
||||
//
|
||||
Imm7b = 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 (Imm7b, 13);
|
||||
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
|
||||
Code[2] = Code[2] | LShiftU64 (Ic, 21);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
|
||||
Code[2] = Code[2] | LShiftU64 (I, 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]
|
||||
//
|
||||
I = RShiftU64 (Addr, 63) & 0x01;
|
||||
//
|
||||
// ic = Addr[21:21]
|
||||
//
|
||||
Ic = RShiftU64 (Addr, 21) & 0x01;
|
||||
//
|
||||
// imm5c = Addr[20:16] for 5 bits
|
||||
//
|
||||
Imm5c = RShiftU64 (Addr, 16) & 0x1F;
|
||||
//
|
||||
// imm9d = Addr[15:7] for 9 bits
|
||||
//
|
||||
Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
|
||||
//
|
||||
// imm7b = Addr[6:0] for 7 bits
|
||||
//
|
||||
Imm7b = 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 (Imm7b, 13);
|
||||
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
|
||||
Code[2] = Code[2] | LShiftU64 (Ic, 21);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
|
||||
Code[2] = Code[2] | LShiftU64 (I, 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) {
|
||||
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]
|
||||
//
|
||||
I = RShiftU64 (Addr, 63) & 0x01;
|
||||
//
|
||||
// ic = Addr[21:21]
|
||||
//
|
||||
Ic = RShiftU64 (Addr, 21) & 0x01;
|
||||
//
|
||||
// imm5c = Addr[20:16] for 5 bits
|
||||
//
|
||||
Imm5c = RShiftU64 (Addr, 16) & 0x1F;
|
||||
//
|
||||
// imm9d = Addr[15:7] for 9 bits
|
||||
//
|
||||
Imm9d = RShiftU64 (Addr, 7) & 0x1FF;
|
||||
//
|
||||
// imm7b = Addr[6:0] for 7 bits
|
||||
//
|
||||
Imm7b = Addr & 0x7F;
|
||||
|
||||
//
|
||||
// Put it in r31, a scratch register
|
||||
//
|
||||
RegNum = 31;
|
||||
|
||||
//
|
||||
// Next is jumbled data, including opcode and rest of address
|
||||
//
|
||||
Code[2] = LShiftU64(Imm7b, 13);
|
||||
Code[2] = Code[2] | LShiftU64 (0x00, 20); // vc
|
||||
Code[2] = Code[2] | LShiftU64 (Ic, 21);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm5c, 22);
|
||||
Code[2] = Code[2] | LShiftU64 (Imm9d, 27);
|
||||
Code[2] = Code[2] | LShiftU64 (I, 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;
|
||||
}
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
WriteBundle (
|
||||
IN VOID *MemPtr,
|
||||
IN UINT8 Template,
|
||||
IN UINT64 Slot0,
|
||||
IN UINT64 Slot1,
|
||||
IN UINT64 Slot2
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Given raw bytes of Itanium based code, format them into a bundle and
|
||||
write them out.
|
||||
|
||||
Arguments:
|
||||
|
||||
MemPtr - pointer to memory location to write the bundles to
|
||||
Template - 5-bit template
|
||||
Slot0-2 - instruction slot data for the bundle
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_INVALID_PARAMETER - Pointer is not aligned
|
||||
- No more than 5 bits in template
|
||||
- More than 41 bits used in code
|
||||
EFI_SUCCESS - All data is written.
|
||||
|
||||
--*/
|
||||
{
|
||||
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) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify max of 41 bits used in code
|
||||
//
|
||||
if ((Slot0 | Slot1 | Slot2) &~0x1ffffffffff) {
|
||||
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;
|
||||
}
|
||||
|
||||
VOID
|
||||
EbcLLCALLEX (
|
||||
IN VM_CONTEXT *VmPtr,
|
||||
IN UINTN FuncAddr,
|
||||
IN UINTN NewStackPointer,
|
||||
IN VOID *FramePtr,
|
||||
IN UINT8 Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
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.
|
||||
|
||||
Arguments:
|
||||
|
||||
VmPtr - Pointer to a VM context.
|
||||
FuncAddr - Callee's address
|
||||
NewStackPointer - New stack pointer after the call
|
||||
FramePtr - New frame pointer after the call
|
||||
Size - The size of call instruction
|
||||
|
||||
Returns:
|
||||
|
||||
None.
|
||||
|
||||
--*/
|
||||
{
|
||||
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->R[0] -= 8;
|
||||
VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr);
|
||||
VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0];
|
||||
VmPtr->R[0] -= 8;
|
||||
VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (VmPtr->Ip + Size));
|
||||
|
||||
VmPtr->Ip = (VMIP) (UINTN) TargetEbcAddr;
|
||||
} else {
|
||||
//
|
||||
// The callee is not a thunk to EBC, call native code.
|
||||
//
|
||||
EbcLLCALLEXNative (FuncAddr, NewStackPointer, FramePtr);
|
||||
|
||||
//
|
||||
// Get return value and advance the IP.
|
||||
//
|
||||
VmPtr->R[7] = EbcLLGetReturnValue ();
|
||||
VmPtr->Ip += Size;
|
||||
}
|
||||
}
|
56
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h
Normal file
56
MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h
Normal file
@@ -0,0 +1,56 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. 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.
|
||||
|
||||
Module Name:
|
||||
|
||||
EbcSupport.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Definition of EBC Support function
|
||||
|
||||
Revision History
|
||||
|
||||
--*/
|
||||
|
||||
#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
|
||||
|
||||
VOID
|
||||
EbcAsmLLCALLEX (
|
||||
IN UINTN CallAddr,
|
||||
IN UINTN EbcSp
|
||||
);
|
||||
|
||||
#endif
|
Reference in New Issue
Block a user