diff options
Diffstat (limited to 'MdeModulePkg/Universal/EbcDxe/Ipf')
-rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s | 197 | ||||
-rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c | 869 | ||||
-rw-r--r-- | MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h | 56 |
3 files changed, 1122 insertions, 0 deletions
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s new file mode 100644 index 0000000..e329b68 --- /dev/null +++ b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcLowLevel.s @@ -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)
+
+
+
+
+
+
+
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c new file mode 100644 index 0000000..3647a12 --- /dev/null +++ b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.c @@ -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;
+ }
+}
diff --git a/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h new file mode 100644 index 0000000..f6c929b --- /dev/null +++ b/MdeModulePkg/Universal/EbcDxe/Ipf/EbcSupport.h @@ -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
|