From aa4165e44be6882b9262dbbc4df59f7caa9b8471 Mon Sep 17 00:00:00 2001 From: qhuang8 Date: Wed, 18 Jul 2007 14:39:46 +0000 Subject: [PATCH] Adjust directory structures. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3328 6f19259b-4bc3-4df7-8a09-765794883524 --- MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs | 25 - MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf | 115 - MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa | 80 - MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c | 4564 ----------------- MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h | 323 -- MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c | 1172 ----- MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h | 283 - .../Universal/Ebc/Dxe/Ia32/EbcLowLevel.S | 54 - .../Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm | 163 - .../Universal/Ebc/Dxe/Ia32/EbcSupport.c | 545 -- .../Universal/Ebc/Dxe/Ipf/EbcLowLevel.s | 197 - .../Universal/Ebc/Dxe/Ipf/EbcSupport.c | 869 ---- .../Universal/Ebc/Dxe/Ipf/EbcSupport.h | 56 - .../Universal/Ebc/Dxe/x64/EbcLowLevel.S | 144 - .../Universal/Ebc/Dxe/x64/EbcLowLevel.asm | 154 - .../Universal/Ebc/Dxe/x64/EbcSupport.c | 619 --- 16 files changed, 9363 deletions(-) delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm delete mode 100644 MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs deleted file mode 100644 index 4b083dd945..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.dxs +++ /dev/null @@ -1,25 +0,0 @@ -/*++ - -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: - - Ebc.dxs - -Abstract: - - Dependency expression file for EBC VM. - ---*/ -#include - -DEPENDENCY_START - TRUE -DEPENDENCY_END diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf deleted file mode 100644 index fe22f3a70b..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.inf +++ /dev/null @@ -1,115 +0,0 @@ -#/** @file -# Component description file for Ebc module. -# -# This module for the EBC virtual machine implementation produces -# EBC and EBC debug support protocols. -# Copyright (c) 2006 - 2007, 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. -# -# -#**/ - -################################################################################ -# -# Defines Section - statements that will be processed to create a Makefile. -# -################################################################################ -[Defines] - INF_VERSION = 0x00010005 - BASE_NAME = Ebc - FILE_GUID = 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7 - MODULE_TYPE = DXE_DRIVER - VERSION_STRING = 1.0 - EDK_RELEASE_VERSION = 0x00020000 - EFI_SPECIFICATION_VERSION = 0x00020000 - - ENTRY_POINT = InitializeEbcDriver - -# -# The following information is for reference only and not required by the build tools. -# -# VALID_ARCHITECTURES = IA32 X64 IPF -# - -################################################################################ -# -# Sources Section - list of files that are required for the build to succeed. -# -################################################################################ - -[Sources.common] - 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 - - -################################################################################ -# -# Package Dependency Section - list of Package files that are required for -# this module. -# -################################################################################ - -[Packages] - MdePkg/MdePkg.dec - - - -################################################################################ -# -# Library Class Section - list of Library Classes that are required for -# this module. -# -################################################################################ - -[LibraryClasses] - MemoryAllocationLib - UefiBootServicesTableLib - BaseMemoryLib - UefiDriverEntryPoint - DebugLib - BaseLib - - -################################################################################ -# -# Protocol C Name Section - list of Protocol and Protocol Notify C Names -# that this module uses or produces. -# -################################################################################ - -[Protocols] - gEfiDebugSupportProtocolGuid # PROTOCOL ALWAYS_PRODUCED - gEfiEbcProtocolGuid # PROTOCOL ALWAYS_PRODUCED - -################################################################################ -# -# Dependency Expression Section - list of Dependency expressions that are required for -# this module. -# -################################################################################ - -[Depex] - TRUE diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa b/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa deleted file mode 100644 index 957f7008db..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ebc.msa +++ /dev/null @@ -1,80 +0,0 @@ - - - - Ebc - DXE_DRIVER - 13AC6DD0-73D0-11D4-B06B-00AA00BD6DE7 - 1.0 - Component description file for Ebc module. - This module for the EBC virtual machine implementation produces - EBC and EBC debug support protocols. - Copyright (c) 2006 - 2007, 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. - FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052 - - - IA32 X64 IPF - false - Ebc - - - - BaseLib - - - DebugLib - - - UefiDriverEntryPoint - - - BaseMemoryLib - - - UefiBootServicesTableLib - - - MemoryAllocationLib - - - - EbcInt.c - EbcInt.h - EbcExecute.c - EbcExecute.h - Ebc.dxs - Ia32/EbcLowLevel.asm - Ia32/EbcLowLevel.S - Ia32/EbcSupport.c - x64/EbcLowLevel.asm - x64/EbcLowLevel.S - x64/EbcSupport.c - Ipf/EbcLowLevel.s - Ipf/EbcSupport.c - Ipf/EbcSupport.h - - - - - - - - gEfiEbcProtocolGuid - - - gEfiDebugSupportProtocolGuid - - - - EFI_SPECIFICATION_VERSION 0x00020000 - EDK_RELEASE_VERSION 0x00020000 - - InitializeEbcDriver - - - diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c deleted file mode 100644 index 174e774de3..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.c +++ /dev/null @@ -1,4564 +0,0 @@ -/*++ - -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: - - EbcExecute.c - -Abstract: - - Contains code that implements the virtual machine. - ---*/ - -#include "EbcInt.h" -#include "EbcExecute.h" - - -// -// Define some useful data size constants to allow switch statements based on -// size of operands or data. -// -#define DATA_SIZE_INVALID 0 -#define DATA_SIZE_8 1 -#define DATA_SIZE_16 2 -#define DATA_SIZE_32 4 -#define DATA_SIZE_64 8 -#define DATA_SIZE_N 48 // 4 or 8 -// -// Structure we'll use to dispatch opcodes to execute functions. -// -typedef struct { - EFI_STATUS (*ExecuteFunction) (IN VM_CONTEXT * VmPtr); -} -VM_TABLE_ENTRY; - -typedef -UINT64 -(*DATA_MANIP_EXEC_FUNCTION) ( - IN VM_CONTEXT * VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -INT16 -VmReadIndex16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ); - -STATIC -INT32 -VmReadIndex32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ); - -STATIC -INT64 -VmReadIndex64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ); - -STATIC -UINT8 -VmReadMem8 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -UINT16 -VmReadMem16 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -UINT32 -VmReadMem32 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -UINT64 -VmReadMem64 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -UINTN -VmReadMemN ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -EFI_STATUS -VmWriteMem8 ( - IN VM_CONTEXT *VmPtr, - UINTN Addr, - IN UINT8 Data - ); - -STATIC -EFI_STATUS -VmWriteMem16 ( - IN VM_CONTEXT *VmPtr, - UINTN Addr, - IN UINT16 Data - ); - -STATIC -EFI_STATUS -VmWriteMem32 ( - IN VM_CONTEXT *VmPtr, - UINTN Addr, - IN UINT32 Data - ); - -STATIC -UINT16 -VmReadCode16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -UINT32 -VmReadCode32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -UINT64 -VmReadCode64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -INT8 -VmReadImmed8 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -INT16 -VmReadImmed16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -INT32 -VmReadImmed32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -INT64 -VmReadImmed64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ); - -STATIC -UINTN -ConvertStackAddr ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ); - -STATIC -EFI_STATUS -ExecuteDataManip ( - IN VM_CONTEXT *VmPtr, - IN BOOLEAN IsSignedOperation - ); - -// -// Functions that execute VM opcodes -// -STATIC -EFI_STATUS -ExecuteBREAK ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteJMP ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteJMP8 ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteCALL ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteRET ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteCMP ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteCMPI ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVxx ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVI ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVIn ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVREL ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecutePUSHn ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecutePUSH ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecutePOPn ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecutePOP ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteSignedDataManip ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteUnsignedDataManip ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteLOADSP ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteSTORESP ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVsnd ( - IN VM_CONTEXT *VmPtr - ); - -STATIC -EFI_STATUS -ExecuteMOVsnw ( - IN VM_CONTEXT *VmPtr - ); - -// -// Data manipulation subfunctions -// -STATIC -UINT64 -ExecuteNOT ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteNEG ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteADD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteSUB ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteMUL ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteMULU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteDIV ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteDIVU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteMOD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteMODU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteAND ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteOR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteXOR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteSHL ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteSHR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteASHR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteEXTNDB ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteEXTNDW ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -STATIC -UINT64 -ExecuteEXTNDD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ); - -// -// Once we retrieve the operands for the data manipulation instructions, -// call these functions to perform the operation. -// -static CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = { - ExecuteNOT, - ExecuteNEG, - ExecuteADD, - ExecuteSUB, - ExecuteMUL, - ExecuteMULU, - ExecuteDIV, - ExecuteDIVU, - ExecuteMOD, - ExecuteMODU, - ExecuteAND, - ExecuteOR, - ExecuteXOR, - ExecuteSHL, - ExecuteSHR, - ExecuteASHR, - ExecuteEXTNDB, - ExecuteEXTNDW, - ExecuteEXTNDD, -}; - -static CONST VM_TABLE_ENTRY mVmOpcodeTable[] = { - { ExecuteBREAK }, // opcode 0x00 - { ExecuteJMP }, // opcode 0x01 - { ExecuteJMP8 }, // opcode 0x02 - { ExecuteCALL }, // opcode 0x03 - { ExecuteRET }, // opcode 0x04 - { ExecuteCMP }, // opcode 0x05 CMPeq - { ExecuteCMP }, // opcode 0x06 CMPlte - { ExecuteCMP }, // opcode 0x07 CMPgte - { ExecuteCMP }, // opcode 0x08 CMPulte - { ExecuteCMP }, // opcode 0x09 CMPugte - { ExecuteUnsignedDataManip }, // opcode 0x0A NOT - { ExecuteSignedDataManip }, // opcode 0x0B NEG - { ExecuteSignedDataManip }, // opcode 0x0C ADD - { ExecuteSignedDataManip }, // opcode 0x0D SUB - { ExecuteSignedDataManip }, // opcode 0x0E MUL - { ExecuteUnsignedDataManip }, // opcode 0x0F MULU - { ExecuteSignedDataManip }, // opcode 0x10 DIV - { ExecuteUnsignedDataManip }, // opcode 0x11 DIVU - { ExecuteSignedDataManip }, // opcode 0x12 MOD - { ExecuteUnsignedDataManip }, // opcode 0x13 MODU - { ExecuteUnsignedDataManip }, // opcode 0x14 AND - { ExecuteUnsignedDataManip }, // opcode 0x15 OR - { ExecuteUnsignedDataManip }, // opcode 0x16 XOR - { ExecuteUnsignedDataManip }, // opcode 0x17 SHL - { ExecuteUnsignedDataManip }, // opcode 0x18 SHR - { ExecuteSignedDataManip }, // opcode 0x19 ASHR - { ExecuteUnsignedDataManip }, // opcode 0x1A EXTNDB - { ExecuteUnsignedDataManip }, // opcode 0x1B EXTNDW - { ExecuteUnsignedDataManip }, // opcode 0x1C EXTNDD - { ExecuteMOVxx }, // opcode 0x1D MOVBW - { ExecuteMOVxx }, // opcode 0x1E MOVWW - { ExecuteMOVxx }, // opcode 0x1F MOVDW - { ExecuteMOVxx }, // opcode 0x20 MOVQW - { ExecuteMOVxx }, // opcode 0x21 MOVBD - { ExecuteMOVxx }, // opcode 0x22 MOVWD - { ExecuteMOVxx }, // opcode 0x23 MOVDD - { ExecuteMOVxx }, // opcode 0x24 MOVQD - { ExecuteMOVsnw }, // opcode 0x25 MOVsnw - { ExecuteMOVsnd }, // opcode 0x26 MOVsnd - { NULL }, // opcode 0x27 - { ExecuteMOVxx }, // opcode 0x28 MOVqq - { ExecuteLOADSP }, // opcode 0x29 LOADSP SP1, R2 - { ExecuteSTORESP }, // opcode 0x2A STORESP R1, SP2 - { ExecutePUSH }, // opcode 0x2B PUSH {@}R1 [imm16] - { ExecutePOP }, // opcode 0x2C POP {@}R1 [imm16] - { ExecuteCMPI }, // opcode 0x2D CMPIEQ - { ExecuteCMPI }, // opcode 0x2E CMPILTE - { ExecuteCMPI }, // opcode 0x2F CMPIGTE - { ExecuteCMPI }, // opcode 0x30 CMPIULTE - { ExecuteCMPI }, // opcode 0x31 CMPIUGTE - { ExecuteMOVxx }, // opcode 0x32 MOVN - { ExecuteMOVxx }, // opcode 0x33 MOVND - { NULL }, // opcode 0x34 - { ExecutePUSHn }, // opcode 0x35 - { ExecutePOPn }, // opcode 0x36 - { ExecuteMOVI }, // opcode 0x37 - mov immediate data - { ExecuteMOVIn }, // opcode 0x38 - mov immediate natural - { ExecuteMOVREL } // opcode 0x39 - move data relative to PC -}; - -// -// Length of JMP instructions, depending on upper two bits of opcode. -// -static CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 }; - -// -// Simple Debugger Protocol GUID -// -EFI_GUID mEbcSimpleDebuggerProtocolGuid = EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL_GUID; - -EFI_STATUS -EbcExecuteInstructions ( - IN EFI_EBC_VM_TEST_PROTOCOL *This, - IN VM_CONTEXT *VmPtr, - IN OUT UINTN *InstructionCount - ) -/*++ - -Routine Description: - - 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. - -Arguments: - - This - pointer to protocol interface - VmPtr - pointer to a VM context - InstructionCount - how many instructions to execute. 0 if don't count. - -Returns: - - EFI_UNSUPPORTED - EFI_SUCCESS - ---*/ -{ - UINTN ExecFunc; - EFI_STATUS Status; - UINTN InstructionsLeft; - UINTN SavedInstructionCount; - - Status = EFI_SUCCESS; - - if (*InstructionCount == 0) { - InstructionsLeft = 1; - } else { - InstructionsLeft = *InstructionCount; - } - - SavedInstructionCount = *InstructionCount; - *InstructionCount = 0; - - // - // Index into the opcode table using the opcode byte for this instruction. - // This gives you the execute function, which we first test for null, then - // call it if it's not null. - // - while (InstructionsLeft != 0) { - ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction; - if (ExecFunc == (UINTN) NULL) { - EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); - return EFI_UNSUPPORTED; - } else { - mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction (VmPtr); - *InstructionCount = *InstructionCount + 1; - } - - // - // Decrement counter if applicable - // - if (SavedInstructionCount != 0) { - InstructionsLeft--; - } - } - - return Status; -} - -EFI_STATUS -EbcExecute ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute an EBC image from an entry point or from a published protocol. - -Arguments: - - VmPtr - pointer to prepared VM context. - -Returns: - - Standard EBC status. - ---*/ -{ - UINTN ExecFunc; - UINT8 StackCorrupted; - EFI_STATUS Status; - EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL *EbcSimpleDebugger; - - mVmPtr = VmPtr; - EbcSimpleDebugger = NULL; - Status = EFI_SUCCESS; - StackCorrupted = 0; - - // - // Make sure the magic value has been put on the stack before we got here. - // - if (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE) { - StackCorrupted = 1; - } - - VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->R[0] + 8); - - // - // Try to get the debug support for EBC - // - DEBUG_CODE_BEGIN (); - Status = gBS->LocateProtocol ( - &mEbcSimpleDebuggerProtocolGuid, - NULL, - (VOID **) &EbcSimpleDebugger - ); - if (EFI_ERROR (Status)) { - EbcSimpleDebugger = NULL; - } - DEBUG_CODE_END (); - - // - // Save the start IP for debug. For example, if we take an exception we - // can print out the location of the exception relative to the entry point, - // which could then be used in a disassembly listing to find the problem. - // - VmPtr->EntryPoint = (VOID *) VmPtr->Ip; - - // - // We'll wait for this flag to know when we're done. The RET - // instruction sets it if it runs out of stack. - // - VmPtr->StopFlags = 0; - while (!(VmPtr->StopFlags & STOPFLAG_APP_DONE)) { - // - // If we've found a simple debugger protocol, call it - // - DEBUG_CODE_BEGIN (); - if (EbcSimpleDebugger != NULL) { - EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr); - } - DEBUG_CODE_END (); - - // - // Verify the opcode is in range. Otherwise generate an exception. - // - if ((*VmPtr->Ip & OPCODE_M_OPCODE) >= (sizeof (mVmOpcodeTable) / sizeof (mVmOpcodeTable[0]))) { - EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); - Status = EFI_UNSUPPORTED; - goto Done; - } - // - // Use the opcode bits to index into the opcode dispatch table. If the - // function pointer is null then generate an exception. - // - ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction; - if (ExecFunc == (UINTN) NULL) { - EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr); - Status = EFI_UNSUPPORTED; - goto Done; - } - // - // The EBC VM is a strongly ordered processor, so perform a fence operation before - // and after each instruction is executed. - // - MemoryFence (); - - mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr); - - MemoryFence (); - - // - // If the step flag is set, signal an exception and continue. We don't - // clear it here. Assuming the debugger is responsible for clearing it. - // - if (VMFLAG_ISSET (VmPtr, VMFLAGS_STEP)) { - EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr); - } - // - // Make sure stack has not been corrupted. Only report it once though. - // - if (!StackCorrupted && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) { - EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr); - StackCorrupted = 1; - } - if (!StackCorrupted && ((UINT64)VmPtr->R[0] <= (UINT64)(UINTN) VmPtr->StackTop)) { - EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr); - StackCorrupted = 1; - } - } - -Done: - mVmPtr = NULL; - - return Status; -} - -STATIC -EFI_STATUS -ExecuteMOVxx ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the MOVxx instructions. - -Arguments: - - VmPtr - pointer to a VM context. - -Returns: - - EFI_UNSUPPORTED - EFI_SUCCESS - -Instruction format: - - MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32} - MOVqq {@}R1 {Index64}, {@}R2 {Index64} - - Copies contents of [R2] -> [R1], zero extending where required. - - First character indicates the size of the move. - Second character indicates the size of the index(s). - - Invalid to have R1 direct with index. - ---*/ -{ - UINT8 Opcode; - UINT8 OpcMasked; - UINT8 Operands; - UINT8 Size; - UINT8 MoveSize; - INT16 Index16; - INT32 Index32; - INT64 Index64Op1; - INT64 Index64Op2; - UINT64 Data64; - UINT64 DataMask; - UINTN Source; - - Opcode = GETOPCODE (VmPtr); - OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE); - - // - // Get the operands byte so we can get R1 and R2 - // - Operands = GETOPERANDS (VmPtr); - - // - // Assume no indexes - // - Index64Op1 = 0; - Index64Op2 = 0; - Data64 = 0; - - // - // Determine if we have an index/immediate data. Base instruction size - // is 2 (opcode + operands). Add to this size each index specified. - // - Size = 2; - if (Opcode & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) { - // - // Determine size of the index from the opcode. Then get it. - // - if ((OpcMasked <= OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVNW)) { - // - // MOVBW, MOVWW, MOVDW, MOVQW, and MOVNW have 16-bit immediate index. - // Get one or both index values. - // - if (Opcode & OPCODE_M_IMMED_OP1) { - Index16 = VmReadIndex16 (VmPtr, 2); - Index64Op1 = (INT64) Index16; - Size += sizeof (UINT16); - } - - if (Opcode & OPCODE_M_IMMED_OP2) { - Index16 = VmReadIndex16 (VmPtr, Size); - Index64Op2 = (INT64) Index16; - Size += sizeof (UINT16); - } - } else if ((OpcMasked <= OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVND)) { - // - // MOVBD, MOVWD, MOVDD, MOVQD, and MOVND have 32-bit immediate index - // - if (Opcode & OPCODE_M_IMMED_OP1) { - Index32 = VmReadIndex32 (VmPtr, 2); - Index64Op1 = (INT64) Index32; - Size += sizeof (UINT32); - } - - if (Opcode & OPCODE_M_IMMED_OP2) { - Index32 = VmReadIndex32 (VmPtr, Size); - Index64Op2 = (INT64) Index32; - Size += sizeof (UINT32); - } - } else if (OpcMasked == OPCODE_MOVQQ) { - // - // MOVqq -- only form with a 64-bit index - // - if (Opcode & OPCODE_M_IMMED_OP1) { - Index64Op1 = VmReadIndex64 (VmPtr, 2); - Size += sizeof (UINT64); - } - - if (Opcode & OPCODE_M_IMMED_OP2) { - Index64Op2 = VmReadIndex64 (VmPtr, Size); - Size += sizeof (UINT64); - } - } else { - // - // Obsolete MOVBQ, MOVWQ, MOVDQ, and MOVNQ have 64-bit immediate index - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - } - // - // Determine the size of the move, and create a mask for it so we can - // clear unused bits. - // - if ((OpcMasked == OPCODE_MOVBW) || (OpcMasked == OPCODE_MOVBD)) { - MoveSize = DATA_SIZE_8; - DataMask = 0xFF; - } else if ((OpcMasked == OPCODE_MOVWW) || (OpcMasked == OPCODE_MOVWD)) { - MoveSize = DATA_SIZE_16; - DataMask = 0xFFFF; - } else if ((OpcMasked == OPCODE_MOVDW) || (OpcMasked == OPCODE_MOVDD)) { - MoveSize = DATA_SIZE_32; - DataMask = 0xFFFFFFFF; - } else if ((OpcMasked == OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVQQ)) { - MoveSize = DATA_SIZE_64; - DataMask = (UINT64)~0; - } else if ((OpcMasked == OPCODE_MOVNW) || (OpcMasked == OPCODE_MOVND)) { - MoveSize = DATA_SIZE_N; - DataMask = (UINT64)~0 >> (64 - 8 * sizeof (UINTN)); - } else { - // - // We were dispatched to this function and we don't recognize the opcode - // - EbcDebugSignalException (EXCEPT_EBC_UNDEFINED, EXCEPTION_FLAG_FATAL, VmPtr); - return EFI_UNSUPPORTED; - } - // - // Now get the source address - // - if (OPERAND2_INDIRECT (Operands)) { - // - // Indirect form @R2. Compute address of operand2 - // - Source = (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2); - // - // Now get the data from the source. Always 0-extend and let the compiler - // sign-extend where required. - // - switch (MoveSize) { - case DATA_SIZE_8: - Data64 = (UINT64) (UINT8) VmReadMem8 (VmPtr, Source); - break; - - case DATA_SIZE_16: - Data64 = (UINT64) (UINT16) VmReadMem16 (VmPtr, Source); - break; - - case DATA_SIZE_32: - Data64 = (UINT64) (UINT32) VmReadMem32 (VmPtr, Source); - break; - - case DATA_SIZE_64: - Data64 = (UINT64) VmReadMem64 (VmPtr, Source); - break; - - case DATA_SIZE_N: - Data64 = (UINT64) (UINTN) VmReadMemN (VmPtr, Source); - break; - - default: - // - // not reached - // - break; - } - } else { - // - // Not indirect source: MOVxx {@}Rx, Ry [Index] - // - Data64 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2; - // - // Did Operand2 have an index? If so, treat as two signed values since - // indexes are signed values. - // - if (Opcode & OPCODE_M_IMMED_OP2) { - // - // NOTE: need to find a way to fix this, most likely by changing the VM - // implementation to remove the stack gap. To do that, we'd need to - // allocate stack space for the VM and actually set the system - // stack pointer to the allocated buffer when the VM starts. - // - // Special case -- if someone took the address of a function parameter - // then we need to make sure it's not in the stack gap. We can identify - // this situation if (Operand2 register == 0) && (Operand2 is direct) - // && (Index applies to Operand2) && (Index > 0) && (Operand1 register != 0) - // Situations that to be aware of: - // * stack adjustments at beginning and end of functions R0 = R0 += stacksize - // - if ((OPERAND2_REGNUM (Operands) == 0) && - (!OPERAND2_INDIRECT (Operands)) && - (Index64Op2 > 0) && - (OPERAND1_REGNUM (Operands) == 0) && - (OPERAND1_INDIRECT (Operands)) - ) { - Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64); - } - } - } - // - // Now write it back - // - if (OPERAND1_INDIRECT (Operands)) { - // - // Reuse the Source variable to now be dest. - // - Source = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index64Op1); - // - // Do the write based on the size - // - switch (MoveSize) { - case DATA_SIZE_8: - VmWriteMem8 (VmPtr, Source, (UINT8) Data64); - break; - - case DATA_SIZE_16: - VmWriteMem16 (VmPtr, Source, (UINT16) Data64); - break; - - case DATA_SIZE_32: - VmWriteMem32 (VmPtr, Source, (UINT32) Data64); - break; - - case DATA_SIZE_64: - VmWriteMem64 (VmPtr, Source, Data64); - break; - - case DATA_SIZE_N: - VmWriteMemN (VmPtr, Source, (UINTN) Data64); - break; - - default: - // - // not reached - // - break; - } - } else { - // - // Operand1 direct. - // Make sure we didn't have an index on operand1. - // - if (Opcode & OPCODE_M_IMMED_OP1) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // Direct storage in register. Clear unused bits and store back to - // register. - // - VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 & DataMask; - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteBREAK ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC BREAK instruction - -Arguments: - - VmPtr - pointer to current VM context - -Returns: - - EFI_UNSUPPORTED - EFI_SUCCESS - ---*/ -{ - UINT8 Operands; - VOID *EbcEntryPoint; - VOID *Thunk; - UINT64 U64EbcEntryPoint; - INT32 Offset; - - Operands = GETOPERANDS (VmPtr); - switch (Operands) { - // - // Runaway program break. Generate an exception and terminate - // - case 0: - EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr); - break; - - // - // Get VM version -- return VM revision number in R7 - // - case 1: - // - // Bits: - // 63-17 = 0 - // 16-8 = Major version - // 7-0 = Minor version - // - VmPtr->R[7] = GetVmVersion (); - break; - - // - // Debugger breakpoint - // - case 3: - VmPtr->StopFlags |= STOPFLAG_BREAKPOINT; - // - // See if someone has registered a handler - // - EbcDebugSignalException ( - EXCEPT_EBC_BREAKPOINT, - EXCEPTION_FLAG_NONE, - VmPtr - ); - break; - - // - // System call, which there are none, so NOP it. - // - case 4: - break; - - // - // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot) - // "offset from self" pointer to the EBC entry point. - // After we're done, *(UINT64 *)R7 will be the address of the new thunk. - // - case 5: - Offset = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[7]); - U64EbcEntryPoint = (UINT64) (VmPtr->R[7] + Offset + 4); - EbcEntryPoint = (VOID *) (UINTN) U64EbcEntryPoint; - - // - // Now create a new thunk - // - EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0); - - // - // Finally replace the EBC entry point memory with the thunk address - // - VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[7], (UINT64) (UINTN) Thunk); - break; - - // - // Compiler setting version per value in R7 - // - case 6: - VmPtr->CompilerVersion = (UINT32) VmPtr->R[7]; - // - // Check compiler version against VM version? - // - break; - - // - // Unhandled break code. Signal exception. - // - default: - EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr); - break; - } - // - // Advance IP - // - VmPtr->Ip += 2; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteJMP ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the JMP instruction - -Arguments: - VmPtr - pointer to VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - JMP64{cs|cc} Immed64 - JMP32{cs|cc} {@}R1 {Immed32|Index32} - -Encoding: - b0.7 - immediate data present - b0.6 - 1 = 64 bit immediate data - 0 = 32 bit immediate data - b1.7 - 1 = conditional - b1.6 1 = CS (condition set) - 0 = CC (condition clear) - b1.4 1 = relative address - 0 = absolute address - b1.3 1 = operand1 indirect - b1.2-0 operand 1 - ---*/ -{ - UINT8 Opcode; - UINT8 CompareSet; - UINT8 ConditionFlag; - UINT8 Size; - UINT8 Operand; - UINT64 Data64; - INT32 Index32; - UINTN Addr; - - Operand = GETOPERANDS (VmPtr); - Opcode = GETOPCODE (VmPtr); - - // - // Get instruction length from the opcode. The upper two bits are used here - // to index into the length array. - // - Size = mJMPLen[(Opcode >> 6) & 0x03]; - - // - // Decode instruction conditions - // If we haven't met the condition, then simply advance the IP and return. - // - CompareSet = (UINT8) ((Operand & JMP_M_CS) ? 1 : 0); - ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC); - if (Operand & CONDITION_M_CONDITIONAL) { - if (CompareSet != ConditionFlag) { - VmPtr->Ip += Size; - return EFI_SUCCESS; - } - } - // - // Check for 64-bit form and do it right away since it's the most - // straight-forward form. - // - if (Opcode & OPCODE_M_IMMDATA64) { - // - // Double check for immediate-data, which is required. If not there, - // then signal an exception - // - if (!(Opcode & OPCODE_M_IMMDATA)) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_ERROR, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // 64-bit immediate data is full address. Read the immediate data, - // check for alignment, and jump absolute. - // - Data64 = VmReadImmed64 (VmPtr, 2); - if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) { - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - - return EFI_UNSUPPORTED; - } - - // - // Take jump -- relative or absolute - // - if (Operand & JMP_M_RELATIVE) { - VmPtr->Ip += (UINTN) Data64 + Size; - } else { - VmPtr->Ip = (VMIP) (UINTN) Data64; - } - - return EFI_SUCCESS; - } - // - // 32-bit forms: - // Get the index if there is one. May be either an index, or an immediate - // offset depending on indirect operand. - // JMP32 @R1 Index32 -- immediate data is an index - // JMP32 R1 Immed32 -- immedate data is an offset - // - if (Opcode & OPCODE_M_IMMDATA) { - if (OPERAND1_INDIRECT (Operand)) { - Index32 = VmReadIndex32 (VmPtr, 2); - } else { - Index32 = VmReadImmed32 (VmPtr, 2); - } - } else { - Index32 = 0; - } - // - // Get the register data. If R == 0, then special case where it's ignored. - // - if (OPERAND1_REGNUM (Operand) == 0) { - Data64 = 0; - } else { - Data64 = OPERAND1_REGDATA (VmPtr, Operand); - } - // - // Decode the forms - // - if (OPERAND1_INDIRECT (Operand)) { - // - // Form: JMP32 @Rx {Index32} - // - Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32); - if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) { - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - - return EFI_UNSUPPORTED; - } - - if (Operand & JMP_M_RELATIVE) { - VmPtr->Ip += (UINTN) Addr + Size; - } else { - VmPtr->Ip = (VMIP) Addr; - } - } else { - // - // Form: JMP32 Rx {Immed32} - // - Addr = (UINTN) (Data64 + Index32); - if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) { - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - - return EFI_UNSUPPORTED; - } - - if (Operand & JMP_M_RELATIVE) { - VmPtr->Ip += (UINTN) Addr + Size; - } else { - VmPtr->Ip = (VMIP) Addr; - } - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteJMP8 ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC JMP8 instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - JMP8{cs|cc} Offset/2 - ---*/ -{ - UINT8 Opcode; - UINT8 ConditionFlag; - UINT8 CompareSet; - INT8 Offset; - - // - // Decode instruction. - // - Opcode = GETOPCODE (VmPtr); - CompareSet = (UINT8) ((Opcode & JMP_M_CS) ? 1 : 0); - ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC); - - // - // If we haven't met the condition, then simply advance the IP and return - // - if (Opcode & CONDITION_M_CONDITIONAL) { - if (CompareSet != ConditionFlag) { - VmPtr->Ip += 2; - return EFI_SUCCESS; - } - } - // - // Get the offset from the instruction stream. It's relative to the - // following instruction, and divided by 2. - // - Offset = VmReadImmed8 (VmPtr, 1); - // - // Want to check for offset == -2 and then raise an exception? - // - VmPtr->Ip += (Offset * 2) + 2; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteMOVI ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC MOVI - -Arguments: - - VmPtr - pointer to a VM context - -Returns: - - Standard EFI_STATUS - -Instruction syntax: - - MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64 - - First variable character specifies the move size - Second variable character specifies size of the immediate data - - Sign-extend the immediate data to the size of the operation, and zero-extend - if storing to a register. - - Operand1 direct with index/immed is invalid. - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT16 Index16; - INT64 ImmData64; - UINT64 Op1; - UINT64 Mask64; - - // - // Get the opcode and operands byte so we can get R1 and R2 - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Get the index (16-bit) if present - // - if (Operands & MOVI_M_IMMDATA) { - Index16 = VmReadIndex16 (VmPtr, 2); - Size = 4; - } else { - Index16 = 0; - Size = 2; - } - // - // Extract the immediate data. Sign-extend always. - // - if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { - ImmData64 = (INT64) (INT16) VmReadImmed16 (VmPtr, Size); - Size += 2; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { - ImmData64 = (INT64) (INT32) VmReadImmed32 (VmPtr, Size); - Size += 4; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { - ImmData64 = (INT64) VmReadImmed64 (VmPtr, Size); - Size += 8; - } else { - // - // Invalid encoding - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // Now write back the result - // - if (!OPERAND1_INDIRECT (Operands)) { - // - // Operand1 direct. Make sure it didn't have an index. - // - if (Operands & MOVI_M_IMMDATA) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // Writing directly to a register. Clear unused bits. - // - if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) { - Mask64 = 0x000000FF; - } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) { - Mask64 = 0x0000FFFF; - } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) { - Mask64 = 0x00000000FFFFFFFF; - } else { - Mask64 = (UINT64)~0; - } - - VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64; - } else { - // - // Get the address then write back based on size of the move - // - Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; - if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) { - VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64); - } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) { - VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64); - } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) { - VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64); - } else { - VmWriteMem64 (VmPtr, (UINTN) Op1, ImmData64); - } - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteMOVIn ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC MOV immediate natural. This instruction moves an immediate - index value into a register or memory location. - -Arguments: - - VmPtr - pointer to a VM context - -Returns: - - Standard EFI_STATUS - -Instruction syntax: - - MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64 - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT16 Index16; - INT16 ImmedIndex16; - INT32 ImmedIndex32; - INT64 ImmedIndex64; - UINT64 Op1; - - // - // Get the opcode and operands byte so we can get R1 and R2 - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Get the operand1 index (16-bit) if present - // - if (Operands & MOVI_M_IMMDATA) { - Index16 = VmReadIndex16 (VmPtr, 2); - Size = 4; - } else { - Index16 = 0; - Size = 2; - } - // - // Extract the immediate data and convert to a 64-bit index. - // - if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { - ImmedIndex16 = VmReadIndex16 (VmPtr, Size); - ImmedIndex64 = (INT64) ImmedIndex16; - Size += 2; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { - ImmedIndex32 = VmReadIndex32 (VmPtr, Size); - ImmedIndex64 = (INT64) ImmedIndex32; - Size += 4; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { - ImmedIndex64 = VmReadIndex64 (VmPtr, Size); - Size += 8; - } else { - // - // Invalid encoding - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // Now write back the result - // - if (!OPERAND1_INDIRECT (Operands)) { - // - // Check for MOVIn R1 Index16, Immed (not indirect, with index), which - // is illegal - // - if (Operands & MOVI_M_IMMDATA) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - - VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmedIndex64; - } else { - // - // Get the address - // - Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; - VmWriteMemN (VmPtr, (UINTN) Op1, (INTN) ImmedIndex64); - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteMOVREL ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC MOVREL instruction. - Dest <- Ip + ImmData - -Arguments: - - VmPtr - pointer to a VM context - -Returns: - - Standard EFI_STATUS - -Instruction syntax: - - MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64 - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT16 Index16; - INT64 ImmData64; - UINT64 Op1; - UINT64 Op2; - - // - // Get the opcode and operands byte so we can get R1 and R2 - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Get the Operand 1 index (16-bit) if present - // - if (Operands & MOVI_M_IMMDATA) { - Index16 = VmReadIndex16 (VmPtr, 2); - Size = 4; - } else { - Index16 = 0; - Size = 2; - } - // - // Get the immediate data. - // - if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) { - ImmData64 = (INT64) VmReadImmed16 (VmPtr, Size); - Size += 2; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) { - ImmData64 = (INT64) VmReadImmed32 (VmPtr, Size); - Size += 4; - } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) { - ImmData64 = VmReadImmed64 (VmPtr, Size); - Size += 8; - } else { - // - // Invalid encoding - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - // - // Compute the value and write back the result - // - Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size); - if (!OPERAND1_INDIRECT (Operands)) { - // - // Check for illegal combination of operand1 direct with immediate data - // - if (Operands & MOVI_M_IMMDATA) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - - VmPtr->R[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2; - } else { - // - // Get the address = [Rx] + Index16 - // Write back the result. Always a natural size write, since - // we're talking addresses here. - // - Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; - VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2); - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteMOVsnw ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC MOVsnw instruction. This instruction loads a signed - natural value from memory or register to another memory or register. On - 32-bit machines, the value gets sign-extended to 64 bits if the destination - is a register. - -Arguments: - - VmPtr - pointer to a VM context - -Returns: - - Standard EFI_STATUS - -Instruction syntax: - - MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16} - - 0:7 1=>operand1 index present - 0:6 1=>operand2 index present - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT16 Op1Index; - INT16 Op2Index; - UINT64 Op2; - - // - // Get the opcode and operand bytes - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - Op1Index = Op2Index = 0; - - // - // Get the indexes if present. - // - Size = 2; - if (Opcode & OPCODE_M_IMMED_OP1) { - if (OPERAND1_INDIRECT (Operands)) { - Op1Index = VmReadIndex16 (VmPtr, 2); - } else { - // - // Illegal form operand1 direct with index: MOVsnw R1 Index16, {@}R2 - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - - Size += sizeof (UINT16); - } - - if (Opcode & OPCODE_M_IMMED_OP2) { - if (OPERAND2_INDIRECT (Operands)) { - Op2Index = VmReadIndex16 (VmPtr, Size); - } else { - Op2Index = VmReadImmed16 (VmPtr, Size); - } - - Size += sizeof (UINT16); - } - // - // Get the data from the source. - // - Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index)); - if (OPERAND2_INDIRECT (Operands)) { - Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2); - } - // - // Now write back the result. - // - if (!OPERAND1_INDIRECT (Operands)) { - VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; - } else { - VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2); - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteMOVsnd ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - Execute the EBC MOVsnw instruction. This instruction loads a signed - natural value from memory or register to another memory or register. On - 32-bit machines, the value gets sign-extended to 64 bits if the destination - is a register. - -Arguments: - - VmPtr - pointer to a VM context - -Returns: - - Standard EFI_STATUS - -Instruction syntax: - - MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32} - - 0:7 1=>operand1 index present - 0:6 1=>operand2 index present - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT32 Op1Index; - INT32 Op2Index; - UINT64 Op2; - - // - // Get the opcode and operand bytes - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - Op1Index = Op2Index = 0; - - // - // Get the indexes if present. - // - Size = 2; - if (Opcode & OPCODE_M_IMMED_OP1) { - if (OPERAND1_INDIRECT (Operands)) { - Op1Index = VmReadIndex32 (VmPtr, 2); - } else { - // - // Illegal form operand1 direct with index: MOVsnd R1 Index16,.. - // - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return EFI_UNSUPPORTED; - } - - Size += sizeof (UINT32); - } - - if (Opcode & OPCODE_M_IMMED_OP2) { - if (OPERAND2_INDIRECT (Operands)) { - Op2Index = VmReadIndex32 (VmPtr, Size); - } else { - Op2Index = VmReadImmed32 (VmPtr, Size); - } - - Size += sizeof (UINT32); - } - // - // Get the data from the source. - // - Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index)); - if (OPERAND2_INDIRECT (Operands)) { - Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2); - } - // - // Now write back the result. - // - if (!OPERAND1_INDIRECT (Operands)) { - VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; - } else { - VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2); - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecutePUSHn ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC PUSHn instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - PUSHn {@}R1 {Index16|Immed16} - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - INT16 Index16; - UINTN DataN; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Get index if present - // - if (Opcode & PUSHPOP_M_IMMDATA) { - if (OPERAND1_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - VmPtr->Ip += 4; - } else { - Index16 = 0; - VmPtr->Ip += 2; - } - // - // Get the data to push - // - if (OPERAND1_INDIRECT (Operands)) { - DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); - } else { - DataN = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16); - } - // - // Adjust the stack down. - // - VmPtr->R[0] -= sizeof (UINTN); - VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], DataN); - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecutePUSH ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC PUSH instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - PUSH[32|64] {@}R1 {Index16|Immed16} - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT32 Data32; - UINT64 Data64; - INT16 Index16; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - // - // Get immediate index if present, then advance the IP. - // - if (Opcode & PUSHPOP_M_IMMDATA) { - if (OPERAND1_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - VmPtr->Ip += 4; - } else { - Index16 = 0; - VmPtr->Ip += 2; - } - // - // Get the data to push - // - if (Opcode & PUSHPOP_M_64) { - if (OPERAND1_INDIRECT (Operands)) { - Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); - } else { - Data64 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; - } - // - // Adjust the stack down, then write back the data - // - VmPtr->R[0] -= sizeof (UINT64); - VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], Data64); - } else { - // - // 32-bit data - // - if (OPERAND1_INDIRECT (Operands)) { - Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16)); - } else { - Data32 = (UINT32) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16; - } - // - // Adjust the stack down and write the data - // - VmPtr->R[0] -= sizeof (UINT32); - VmWriteMem32 (VmPtr, (UINTN) VmPtr->R[0], Data32); - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecutePOPn ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC POPn instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - POPn {@}R1 {Index16|Immed16} - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - INT16 Index16; - UINTN DataN; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - // - // Get immediate data if present, and advance the IP - // - if (Opcode & PUSHPOP_M_IMMDATA) { - if (OPERAND1_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - VmPtr->Ip += 4; - } else { - Index16 = 0; - VmPtr->Ip += 2; - } - // - // Read the data off the stack, then adjust the stack pointer - // - DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]); - VmPtr->R[0] += sizeof (UINTN); - // - // Do the write-back - // - if (OPERAND1_INDIRECT (Operands)) { - VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), DataN); - } else { - VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) ((UINTN) DataN + Index16); - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecutePOP ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC POP instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - POP {@}R1 {Index16|Immed16} - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - INT16 Index16; - INT32 Data32; - UINT64 Data64; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - // - // Get immediate data if present, and advance the IP. - // - if (Opcode & PUSHPOP_M_IMMDATA) { - if (OPERAND1_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - VmPtr->Ip += 4; - } else { - Index16 = 0; - VmPtr->Ip += 2; - } - // - // Get the data off the stack, then write it to the appropriate location - // - if (Opcode & PUSHPOP_M_64) { - // - // Read the data off the stack, then adjust the stack pointer - // - Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]); - VmPtr->R[0] += sizeof (UINT64); - // - // Do the write-back - // - if (OPERAND1_INDIRECT (Operands)) { - VmWriteMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data64); - } else { - VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 + Index16; - } - } else { - // - // 32-bit pop. Read it off the stack and adjust the stack pointer - // - Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[0]); - VmPtr->R[0] += sizeof (UINT32); - // - // Do the write-back - // - if (OPERAND1_INDIRECT (Operands)) { - VmWriteMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data32); - } else { - VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16; - } - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteCALL ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Implements the EBC CALL instruction. - - Instruction format: - - CALL64 Immed64 - CALL32 {@}R1 {Immed32|Index32} - CALLEX64 Immed64 - CALLEX16 {@}R1 {Immed32} - - If Rx == R0, then it's a PC relative call to PC = PC + imm32. - -Arguments: - VmPtr - pointer to a VM context. - -Returns: - Standard EFI_STATUS - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - INT32 Immed32; - UINT8 Size; - INT64 Immed64; - VOID *FramePtr; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - // - // Assign these as well to avoid compiler warnings - // - Immed64 = 0; - Immed32 = 0; - - FramePtr = VmPtr->FramePtr; - // - // Determine the instruction size, and get immediate data if present - // - if (Opcode & OPCODE_M_IMMDATA) { - if (Opcode & OPCODE_M_IMMDATA64) { - Immed64 = VmReadImmed64 (VmPtr, 2); - Size = 10; - } else { - // - // If register operand is indirect, then the immediate data is an index - // - if (OPERAND1_INDIRECT (Operands)) { - Immed32 = VmReadIndex32 (VmPtr, 2); - } else { - Immed32 = VmReadImmed32 (VmPtr, 2); - } - - Size = 6; - } - } else { - Size = 2; - } - // - // If it's a call to EBC, adjust the stack pointer down 16 bytes and - // put our return address and frame pointer on the VM stack. - // - if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { - 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) (UINTN) (VmPtr->Ip + Size)); - } - // - // If 64-bit data, then absolute jump only - // - if (Opcode & OPCODE_M_IMMDATA64) { - // - // Native or EBC call? - // - if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { - VmPtr->Ip = (VMIP) (UINTN) Immed64; - } else { - // - // Call external function, get the return value, and advance the IP - // - EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size); - } - } else { - // - // Get the register data. If operand1 == 0, then ignore register and - // take immediate data as relative or absolute address. - // Compiler should take care of upper bits if 32-bit machine. - // - if (OPERAND1_REGNUM (Operands) != 0) { - Immed64 = (UINT64) (UINTN) VmPtr->R[OPERAND1_REGNUM (Operands)]; - } - // - // Get final address - // - if (OPERAND1_INDIRECT (Operands)) { - Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32)); - } else { - Immed64 += Immed32; - } - // - // Now determine if external call, and then if relative or absolute - // - if ((Operands & OPERAND_M_NATIVE_CALL) == 0) { - // - // EBC call. Relative or absolute? If relative, then it's relative to the - // start of the next instruction. - // - if (Operands & OPERAND_M_RELATIVE_ADDR) { - VmPtr->Ip += Immed64 + Size; - } else { - VmPtr->Ip = (VMIP) (UINTN) Immed64; - } - } else { - // - // Native call. Relative or absolute? - // - if (Operands & OPERAND_M_RELATIVE_ADDR) { - EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->R[0], FramePtr, Size); - } else { - if (VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) { - CpuBreakpoint (); - } - - EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size); - } - } - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteRET ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC RET instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - RET - ---*/ -{ - // - // If we're at the top of the stack, then simply set the done - // flag and return - // - if (VmPtr->StackRetAddr == (UINT64) VmPtr->R[0]) { - VmPtr->StopFlags |= STOPFLAG_APP_DONE; - } else { - // - // Pull the return address off the VM app's stack and set the IP - // to it - // - if (!IS_ALIGNED ((UINTN) VmPtr->R[0], sizeof (UINT16))) { - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - } - // - // Restore the IP and frame pointer from the stack - // - VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]); - VmPtr->R[0] += 8; - VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]); - VmPtr->R[0] += 8; - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteCMP ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC CMP instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - CMP[32|64][eq|lte|gte|ulte|ugte] R1, {@}R2 {Index16|Immed16} - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT16 Index16; - UINT32 Flag; - INT64 Op2; - INT64 Op1; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - // - // Get the register data we're going to compare to - // - Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; - // - // Get immediate data - // - if (Opcode & OPCODE_M_IMMDATA) { - if (OPERAND2_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - Size = 4; - } else { - Index16 = 0; - Size = 2; - } - // - // Now get Op2 - // - if (OPERAND2_INDIRECT (Operands)) { - if (Opcode & OPCODE_M_64BIT) { - Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16)); - } else { - // - // 32-bit operations. 0-extend the values for all cases. - // - Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16))); - } - } else { - Op2 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16; - } - // - // Now do the compare - // - Flag = 0; - if (Opcode & OPCODE_M_64BIT) { - // - // 64-bit compares - // - switch (Opcode & OPCODE_M_OPCODE) { - case OPCODE_CMPEQ: - if (Op1 == Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPLTE: - if (Op1 <= Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPGTE: - if (Op1 >= Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPULTE: - if ((UINT64) Op1 <= (UINT64) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPUGTE: - if ((UINT64) Op1 >= (UINT64) Op2) { - Flag = 1; - } - break; - - default: - ASSERT (0); - } - } else { - // - // 32-bit compares - // - switch (Opcode & OPCODE_M_OPCODE) { - case OPCODE_CMPEQ: - if ((INT32) Op1 == (INT32) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPLTE: - if ((INT32) Op1 <= (INT32) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPGTE: - if ((INT32) Op1 >= (INT32) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPULTE: - if ((UINT32) Op1 <= (UINT32) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPUGTE: - if ((UINT32) Op1 >= (UINT32) Op2) { - Flag = 1; - } - break; - - default: - ASSERT (0); - } - } - // - // Now set the flag accordingly for the comparison - // - if (Flag) { - VMFLAG_SET (VmPtr, VMFLAGS_CC); - } else { - VMFLAG_CLEAR (VmPtr, VMFLAGS_CC); - } - // - // Advance the IP - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteCMPI ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC CMPI instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - CMPI[32|64]{w|d}[eq|lte|gte|ulte|ugte] {@}Rx {Index16}, Immed16|Immed32 - ---*/ -{ - UINT8 Opcode; - UINT8 Operands; - UINT8 Size; - INT64 Op1; - INT64 Op2; - INT16 Index16; - UINT32 Flag; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Get operand1 index if present - // - Size = 2; - if (Operands & OPERAND_M_CMPI_INDEX) { - Index16 = VmReadIndex16 (VmPtr, 2); - Size += 2; - } else { - Index16 = 0; - } - // - // Get operand1 data we're going to compare to - // - Op1 = (INT64) VmPtr->R[OPERAND1_REGNUM (Operands)]; - if (OPERAND1_INDIRECT (Operands)) { - // - // Indirect operand1. Fetch 32 or 64-bit value based on compare size. - // - if (Opcode & OPCODE_M_CMPI64) { - Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16); - } else { - Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16); - } - } else { - // - // Better not have been an index with direct. That is, CMPI R1 Index,... - // is illegal. - // - if (Operands & OPERAND_M_CMPI_INDEX) { - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_ERROR, - VmPtr - ); - VmPtr->Ip += Size; - return EFI_UNSUPPORTED; - } - } - // - // Get immediate data -- 16- or 32-bit sign extended - // - if (Opcode & OPCODE_M_CMPI32_DATA) { - Op2 = (INT64) VmReadImmed32 (VmPtr, Size); - Size += 4; - } else { - // - // 16-bit immediate data. Sign extend always. - // - Op2 = (INT64) ((INT16) VmReadImmed16 (VmPtr, Size)); - Size += 2; - } - // - // Now do the compare - // - Flag = 0; - if (Opcode & OPCODE_M_CMPI64) { - // - // 64 bit comparison - // - switch (Opcode & OPCODE_M_OPCODE) { - case OPCODE_CMPIEQ: - if (Op1 == (INT64) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPILTE: - if (Op1 <= (INT64) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPIGTE: - if (Op1 >= (INT64) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPIULTE: - if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) { - Flag = 1; - } - break; - - case OPCODE_CMPIUGTE: - if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) { - Flag = 1; - } - break; - - default: - ASSERT (0); - } - } else { - // - // 32-bit comparisons - // - switch (Opcode & OPCODE_M_OPCODE) { - case OPCODE_CMPIEQ: - if ((INT32) Op1 == Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPILTE: - if ((INT32) Op1 <= Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPIGTE: - if ((INT32) Op1 >= Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPIULTE: - if ((UINT32) Op1 <= (UINT32) Op2) { - Flag = 1; - } - break; - - case OPCODE_CMPIUGTE: - if ((UINT32) Op1 >= (UINT32) Op2) { - Flag = 1; - } - break; - - default: - ASSERT (0); - } - } - // - // Now set the flag accordingly for the comparison - // - if (Flag) { - VMFLAG_SET (VmPtr, VMFLAGS_CC); - } else { - VMFLAG_CLEAR (VmPtr, VMFLAGS_CC); - } - // - // Advance the IP - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -UINT64 -ExecuteNOT ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC NOT instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - ~Op2 - -Instruction syntax: - NOT[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - return ~Op2; -} - -STATIC -UINT64 -ExecuteNEG ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC NEG instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op2 * -1 - -Instruction syntax: - NEG[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - return ~Op2 + 1; -} - -STATIC -UINT64 -ExecuteADD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - - Execute the EBC ADD instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 + Op2 - -Instruction syntax: - ADD[32|64] {@}R1, {@}R2 {Index16} - ---*/ -{ - return Op1 + Op2; -} - -STATIC -UINT64 -ExecuteSUB ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC SUB instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 - Op2 - Standard EFI_STATUS - -Instruction syntax: - SUB[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2)); - } else { - return (UINT64) ((INT64) ((INT32) Op1 - (INT32) Op2)); - } -} - -STATIC -UINT64 -ExecuteMUL ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - - Execute the EBC MUL instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 * Op2 - -Instruction syntax: - MUL[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return MultS64x64 ((INT64)Op1, (INT64)Op2); - } else { - return (UINT64) ((INT64) ((INT32) Op1 * (INT32) Op2)); - } -} - -STATIC -UINT64 -ExecuteMULU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC MULU instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - (unsigned)Op1 * (unsigned)Op2 - -Instruction syntax: - MULU[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return MultU64x64 (Op1, Op2); - } else { - return (UINT64) ((UINT32) Op1 * (UINT32) Op2); - } -} - -STATIC -UINT64 -ExecuteDIV ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - - Execute the EBC DIV instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1/Op2 - -Instruction syntax: - DIV[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - INT64 Remainder; - - // - // Check for divide-by-0 - // - if (Op2 == 0) { - EbcDebugSignalException ( - EXCEPT_EBC_DIVIDE_ERROR, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - - return 0; - } else { - if (*VmPtr->Ip & DATAMANIP_M_64) { - return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder)); - } else { - return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2)); - } - } -} - -STATIC -UINT64 -ExecuteDIVU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC DIVU instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - (unsigned)Op1 / (unsigned)Op2 - -Instruction syntax: - DIVU[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - UINT64 Remainder; - - // - // Check for divide-by-0 - // - if (Op2 == 0) { - EbcDebugSignalException ( - EXCEPT_EBC_DIVIDE_ERROR, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return 0; - } else { - // - // Get the destination register - // - if (*VmPtr->Ip & DATAMANIP_M_64) { - return (UINT64) (DivU64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder)); - } else { - return (UINT64) ((UINT32) Op1 / (UINT32) Op2); - } - } -} - -STATIC -UINT64 -ExecuteMOD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC MOD instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 MODULUS Op2 - -Instruction syntax: - MOD[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - INT64 Remainder; - - // - // Check for divide-by-0 - // - if (Op2 == 0) { - EbcDebugSignalException ( - EXCEPT_EBC_DIVIDE_ERROR, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return 0; - } else { - DivS64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder); - return Remainder; - } -} - -STATIC -UINT64 -ExecuteMODU ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC MODU instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 UNSIGNED_MODULUS Op2 - -Instruction syntax: - MODU[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - UINT64 Remainder; - - // - // Check for divide-by-0 - // - if (Op2 == 0) { - EbcDebugSignalException ( - EXCEPT_EBC_DIVIDE_ERROR, - EXCEPTION_FLAG_FATAL, - VmPtr - ); - return 0; - } else { - DivU64x64Remainder (Op1, Op2, &Remainder); - return Remainder; - } -} - -STATIC -UINT64 -ExecuteAND ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC AND instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 AND Op2 - -Instruction syntax: - AND[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - return Op1 & Op2; -} - -STATIC -UINT64 -ExecuteOR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC OR instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 OR Op2 - -Instruction syntax: - OR[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - return Op1 | Op2; -} - -STATIC -UINT64 -ExecuteXOR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC XOR instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 XOR Op2 - -Instruction syntax: - XOR[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - return Op1 ^ Op2; -} - -STATIC -UINT64 -ExecuteSHL ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - - Execute the EBC SHL shift left instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 << Op2 - -Instruction syntax: - SHL[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return LShiftU64 (Op1, (UINTN)Op2); - } else { - return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2)); - } -} - -STATIC -UINT64 -ExecuteSHR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC SHR instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 >> Op2 (unsigned operands) - -Instruction syntax: - SHR[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return RShiftU64 (Op1, (UINTN)Op2); - } else { - return (UINT64) ((UINT32) Op1 >> (UINT32) Op2); - } -} - -STATIC -UINT64 -ExecuteASHR ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC ASHR instruction - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - Op1 >> Op2 (signed) - -Instruction syntax: - ASHR[32|64] {@}R1, {@}R2 {Index16|Immed16} - ---*/ -{ - if (*VmPtr->Ip & DATAMANIP_M_64) { - return ARShiftU64 (Op1, (UINTN)Op2); - } else { - return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2)); - } -} - -STATIC -UINT64 -ExecuteEXTNDB ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC EXTNDB instruction to sign-extend a byte value. - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - (INT64)(INT8)Op2 - -Instruction syntax: - EXTNDB[32|64] {@}R1, {@}R2 {Index16|Immed16} - - ---*/ -{ - INT8 Data8; - INT64 Data64; - // - // Convert to byte, then return as 64-bit signed value to let compiler - // sign-extend the value - // - Data8 = (INT8) Op2; - Data64 = (INT64) Data8; - - return (UINT64) Data64; -} - -STATIC -UINT64 -ExecuteEXTNDW ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC EXTNDW instruction to sign-extend a 16-bit value. - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - (INT64)(INT16)Op2 - -Instruction syntax: - EXTNDW[32|64] {@}R1, {@}R2 {Index16|Immed16} - - ---*/ -{ - INT16 Data16; - INT64 Data64; - // - // Convert to word, then return as 64-bit signed value to let compiler - // sign-extend the value - // - Data16 = (INT16) Op2; - Data64 = (INT64) Data16; - - return (UINT64) Data64; -} -// -// Execute the EBC EXTNDD instruction. -// -// Format: EXTNDD {@}Rx, {@}Ry [Index16|Immed16] -// EXTNDD Dest, Source -// -// Operation: Dest <- SignExtended((DWORD)Source)) -// -STATIC -UINT64 -ExecuteEXTNDD ( - IN VM_CONTEXT *VmPtr, - IN UINT64 Op1, - IN UINT64 Op2 - ) -/*++ - -Routine Description: - Execute the EBC EXTNDD instruction to sign-extend a 32-bit value. - -Arguments: - VmPtr - pointer to a VM context - Op1 - Operand 1 from the instruction - Op2 - Operand 2 from the instruction - -Returns: - (INT64)(INT32)Op2 - -Instruction syntax: - EXTNDD[32|64] {@}R1, {@}R2 {Index16|Immed16} - - ---*/ -{ - INT32 Data32; - INT64 Data64; - // - // Convert to 32-bit value, then return as 64-bit signed value to let compiler - // sign-extend the value - // - Data32 = (INT32) Op2; - Data64 = (INT64) Data32; - - return (UINT64) Data64; -} - -STATIC -EFI_STATUS -ExecuteSignedDataManip ( - IN VM_CONTEXT *VmPtr - ) -{ - // - // Just call the data manipulation function with a flag indicating this - // is a signed operation. - // - return ExecuteDataManip (VmPtr, TRUE); -} - -STATIC -EFI_STATUS -ExecuteUnsignedDataManip ( - IN VM_CONTEXT *VmPtr - ) -{ - // - // Just call the data manipulation function with a flag indicating this - // is not a signed operation. - // - return ExecuteDataManip (VmPtr, FALSE); -} - -STATIC -EFI_STATUS -ExecuteDataManip ( - IN VM_CONTEXT *VmPtr, - IN BOOLEAN IsSignedOp - ) -/*++ - -Routine Description: - Execute all the EBC data manipulation instructions. - Since the EBC data manipulation instructions all have the same basic form, - they can share the code that does the fetch of operands and the write-back - of the result. This function performs the fetch of the operands (even if - both are not needed to be fetched, like NOT instruction), dispatches to the - appropriate subfunction, then writes back the returned result. - -Arguments: - VmPtr - pointer to VM context - -Returns: - Standard EBC status - -Format: - INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16} - ---*/ -{ - UINT8 Opcode; - INT16 Index16; - UINT8 Operands; - UINT8 Size; - UINT64 Op1; - UINT64 Op2; - - // - // Get opcode and operands - // - Opcode = GETOPCODE (VmPtr); - Operands = GETOPERANDS (VmPtr); - - // - // Determine if we have immediate data by the opcode - // - if (Opcode & DATAMANIP_M_IMMDATA) { - // - // Index16 if Ry is indirect, or Immed16 if Ry direct. - // - if (OPERAND2_INDIRECT (Operands)) { - Index16 = VmReadIndex16 (VmPtr, 2); - } else { - Index16 = VmReadImmed16 (VmPtr, 2); - } - - Size = 4; - } else { - Index16 = 0; - Size = 2; - } - // - // Now get operand2 (source). It's of format {@}R2 {Index16|Immed16} - // - Op2 = (UINT64) VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16; - if (OPERAND2_INDIRECT (Operands)) { - // - // Indirect form: @R2 Index16. Fetch as 32- or 64-bit data - // - if (Opcode & DATAMANIP_M_64) { - Op2 = VmReadMem64 (VmPtr, (UINTN) Op2); - } else { - // - // Read as signed value where appropriate. - // - if (IsSignedOp) { - Op2 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op2)); - } else { - Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2); - } - } - } else { - if ((Opcode & DATAMANIP_M_64) == 0) { - if (IsSignedOp) { - Op2 = (UINT64) (INT64) ((INT32) Op2); - } else { - Op2 = (UINT64) ((UINT32) Op2); - } - } - } - // - // Get operand1 (destination and sometimes also an actual operand) - // of form {@}R1 - // - Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; - if (OPERAND1_INDIRECT (Operands)) { - if (Opcode & DATAMANIP_M_64) { - Op1 = VmReadMem64 (VmPtr, (UINTN) Op1); - } else { - if (IsSignedOp) { - Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1)); - } else { - Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1); - } - } - } else { - if ((Opcode & DATAMANIP_M_64) == 0) { - if (IsSignedOp) { - Op1 = (UINT64) (INT64) ((INT32) Op1); - } else { - Op1 = (UINT64) ((UINT32) Op1); - } - } - } - // - // Dispatch to the computation function - // - if (((Opcode & OPCODE_M_OPCODE) - OPCODE_NOT) >= - (sizeof (mDataManipDispatchTable) / sizeof (mDataManipDispatchTable[0])) - ) { - EbcDebugSignalException ( - EXCEPT_EBC_INVALID_OPCODE, - EXCEPTION_FLAG_ERROR, - VmPtr - ); - // - // Advance and return - // - VmPtr->Ip += Size; - return EFI_UNSUPPORTED; - } else { - Op2 = mDataManipDispatchTable[(Opcode & OPCODE_M_OPCODE) - OPCODE_NOT](VmPtr, Op1, Op2); - } - // - // Write back the result. - // - if (OPERAND1_INDIRECT (Operands)) { - Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)]; - if (Opcode & DATAMANIP_M_64) { - VmWriteMem64 (VmPtr, (UINTN) Op1, Op2); - } else { - VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2); - } - } else { - // - // Storage back to a register. Write back, clearing upper bits (as per - // the specification) if 32-bit operation. - // - VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2; - if ((Opcode & DATAMANIP_M_64) == 0) { - VmPtr->R[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF; - } - } - // - // Advance the instruction pointer - // - VmPtr->Ip += Size; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteLOADSP ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC LOADSP instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - LOADSP SP1, R2 - ---*/ -{ - UINT8 Operands; - - // - // Get the operands - // - Operands = GETOPERANDS (VmPtr); - - // - // Do the operation - // - switch (OPERAND1_REGNUM (Operands)) { - // - // Set flags - // - case 0: - // - // Spec states that this instruction will not modify reserved bits in - // the flags register. - // - VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->R[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID); - break; - - default: - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_WARNING, - VmPtr - ); - VmPtr->Ip += 2; - return EFI_UNSUPPORTED; - } - - VmPtr->Ip += 2; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -ExecuteSTORESP ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - Execute the EBC STORESP instruction - -Arguments: - VmPtr - pointer to a VM context - -Returns: - Standard EFI_STATUS - -Instruction syntax: - STORESP Rx, FLAGS|IP - ---*/ -{ - UINT8 Operands; - - // - // Get the operands - // - Operands = GETOPERANDS (VmPtr); - - // - // Do the operation - // - switch (OPERAND2_REGNUM (Operands)) { - // - // Get flags - // - case 0: - // - // Retrieve the value in the flags register, then clear reserved bits - // - VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID); - break; - - // - // Get IP -- address of following instruction - // - case 1: - VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2; - break; - - default: - EbcDebugSignalException ( - EXCEPT_EBC_INSTRUCTION_ENCODING, - EXCEPTION_FLAG_WARNING, - VmPtr - ); - VmPtr->Ip += 2; - return EFI_UNSUPPORTED; - break; - } - - VmPtr->Ip += 2; - return EFI_SUCCESS; -} - -STATIC -INT16 -VmReadIndex16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ) -/*++ - -Routine Description: - Decode a 16-bit index to determine the offset. Given an index value: - - b15 - sign bit - b14:12 - number of bits in this index assigned to natural units (=a) - ba:11 - constant units = C - b0:a - natural units = N - - Given this info, the offset can be computed by: - offset = sign_bit * (C + N * sizeof(UINTN)) - - Max offset is achieved with index = 0x7FFF giving an offset of - 0x27B (32-bit machine) or 0x477 (64-bit machine). - Min offset is achieved with index = - -Arguments: - VmPtr - pointer to VM context - CodeOffset - offset from IP of the location of the 16-bit index to decode - -Returns: - The decoded offset. - ---*/ -{ - UINT16 Index; - INT16 Offset; - INT16 C; - INT16 N; - INT16 NBits; - INT16 Mask; - - // - // First read the index from the code stream - // - Index = VmReadCode16 (VmPtr, CodeOffset); - - // - // Get the mask for N. First get the number of bits from the index. - // - NBits = (INT16) ((Index & 0x7000) >> 12); - - // - // Scale it for 16-bit indexes - // - NBits *= 2; - - // - // Now using the number of bits, create a mask. - // - Mask = (INT16) ((INT16)~0 << NBits); - - // - // Now using the mask, extract N from the lower bits of the index. - // - N = (INT16) (Index &~Mask); - - // - // Now compute C - // - C = (INT16) (((Index &~0xF000) & Mask) >> NBits); - - Offset = (INT16) (N * sizeof (UINTN) + C); - - // - // Now set the sign - // - if (Index & 0x8000) { - // - // Do it the hard way to work around a bogus compiler warning - // - // Offset = -1 * Offset; - // - Offset = (INT16) ((INT32) Offset * -1); - } - - return Offset; -} - -STATIC -INT32 -VmReadIndex32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ) -/*++ - -Routine Description: - Decode a 32-bit index to determine the offset. - -Arguments: - VmPtr - pointer to VM context - CodeOffset - offset from IP of the location of the 32-bit index to decode - -Returns: - Converted index per EBC VM specification - ---*/ -{ - UINT32 Index; - INT32 Offset; - INT32 C; - INT32 N; - INT32 NBits; - INT32 Mask; - - Index = VmReadImmed32 (VmPtr, CodeOffset); - - // - // Get the mask for N. First get the number of bits from the index. - // - NBits = (Index & 0x70000000) >> 28; - - // - // Scale it for 32-bit indexes - // - NBits *= 4; - - // - // Now using the number of bits, create a mask. - // - Mask = (INT32)~0 << NBits; - - // - // Now using the mask, extract N from the lower bits of the index. - // - N = Index &~Mask; - - // - // Now compute C - // - C = ((Index &~0xF0000000) & Mask) >> NBits; - - Offset = N * sizeof (UINTN) + C; - - // - // Now set the sign - // - if (Index & 0x80000000) { - Offset = Offset * -1; - } - - return Offset; -} - -STATIC -INT64 -VmReadIndex64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 CodeOffset - ) -/*++ - -Routine Description: - Decode a 64-bit index to determine the offset. - -Arguments: - VmPtr - pointer to VM context - CodeOffset - offset from IP of the location of the 64-bit index to decode - -Returns: - Converted index per EBC VM specification - ---*/ -{ - UINT64 Index; - INT64 Offset; - INT64 C; - INT64 N; - INT64 NBits; - INT64 Mask; - - Index = VmReadCode64 (VmPtr, CodeOffset); - - // - // Get the mask for N. First get the number of bits from the index. - // - NBits = RShiftU64 ((Index & 0x7000000000000000ULL), 60); - - // - // Scale it for 64-bit indexes (multiply by 8 by shifting left 3) - // - NBits = LShiftU64 ((UINT64)NBits, 3); - - // - // Now using the number of bits, create a mask. - // - Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits)); - - // - // Now using the mask, extract N from the lower bits of the index. - // - N = Index &~Mask; - - // - // Now compute C - // - C = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits); - - Offset = MultU64x64 (N, sizeof (UINTN)) + C; - - // - // Now set the sign - // - if (Index & 0x8000000000000000ULL) { - Offset = MultS64x64 (Offset, -1); - } - - return Offset; -} - -STATIC -EFI_STATUS -VmWriteMem8 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINT8 Data - ) -/*++ - -Routine Description: - The following VmWriteMem? routines are 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. - -Arguments: - VmPtr - pointer to a VM context - Addr - adddress to write to - Data - value to write to Addr - -Returns: - Standard EFI_STATUS - ---*/ -{ - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - *(UINT8 *) Addr = Data; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -VmWriteMem16 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINT16 Data - ) -{ - EFI_STATUS Status; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - - // - // Do a simple write if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT16))) { - *(UINT16 *) Addr = Data; - } else { - // - // Write as two bytes - // - MemoryFence (); - if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8) Data)) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8) (Data >> 8))) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -VmWriteMem32 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINT32 Data - ) -{ - EFI_STATUS Status; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - - // - // Do a simple write if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT32))) { - *(UINT32 *) Addr = Data; - } else { - // - // Write as two words - // - MemoryFence (); - if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16) Data)) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16) (Data >> 16))) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - } - - return EFI_SUCCESS; -} - -EFI_STATUS -VmWriteMem64 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINT64 Data - ) -{ - EFI_STATUS Status; - UINT32 Data32; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - - // - // Do a simple write if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT64))) { - *(UINT64 *) Addr = Data; - } else { - // - // Write as two 32-bit words - // - MemoryFence (); - if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32) Data)) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - Data32 = (UINT32) (((UINT32 *) &Data)[1]); - if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), Data32)) != EFI_SUCCESS) { - return Status; - } - - MemoryFence (); - } - - return EFI_SUCCESS; -} - -EFI_STATUS -VmWriteMemN ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINTN Data - ) -{ - EFI_STATUS Status; - UINTN Index; - - Status = EFI_SUCCESS; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - - // - // Do a simple write if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINTN))) { - *(UINTN *) Addr = Data; - } else { - for (Index = 0; Index < sizeof (UINTN) / sizeof (UINT32); Index++) { - MemoryFence (); - Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32) Data); - MemoryFence (); - Data = (UINTN)RShiftU64 ((UINT64)Data, 32); - } - } - - return Status; -} - -STATIC -INT8 -VmReadImmed8 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -/*++ - -Routine Description: - - The following VmReadImmed routines are called by the EBC execute - functions to read EBC immediate values from the code stream. - Since we can't assume alignment, each tries to read in the biggest - chunks size available, but will revert to smaller reads if necessary. - -Arguments: - VmPtr - pointer to a VM context - Offset - offset from IP of the code bytes to read. - -Returns: - Signed data of the requested size from the specified address. - ---*/ -{ - // - // Simply return the data in flat memory space - // - return * (INT8 *) (VmPtr->Ip + Offset); -} - -STATIC -INT16 -VmReadImmed16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -{ - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (INT16))) { - return * (INT16 *) (VmPtr->Ip + Offset); - } else { - // - // All code word reads should be aligned - // - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_WARNING, - VmPtr - ); - } - // - // Return unaligned data - // - return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8)); -} - -STATIC -INT32 -VmReadImmed32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -{ - UINT32 Data; - - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) { - return * (INT32 *) (VmPtr->Ip + Offset); - } - // - // Return unaligned data - // - Data = (UINT32) VmReadCode16 (VmPtr, Offset); - Data |= (UINT32) (VmReadCode16 (VmPtr, Offset + 2) << 16); - return Data; -} - -STATIC -INT64 -VmReadImmed64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -{ - UINT64 Data64; - UINT32 Data32; - UINT8 *Ptr; - - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) { - return * (UINT64 *) (VmPtr->Ip + Offset); - } - // - // Return unaligned data. - // - Ptr = (UINT8 *) &Data64; - Data32 = VmReadCode32 (VmPtr, Offset); - *(UINT32 *) Ptr = Data32; - Ptr += sizeof (Data32); - Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32)); - *(UINT32 *) Ptr = Data32; - return Data64; -} - -STATIC -UINT16 -VmReadCode16 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -/*++ - -Routine Description: - The following VmReadCode() routines provide the ability to read raw - unsigned data from the code stream. - -Arguments: - VmPtr - pointer to VM context - Offset - offset from current IP to the raw data to read. - -Returns: - The raw unsigned 16-bit value from the code stream. - ---*/ -{ - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT16))) { - return * (UINT16 *) (VmPtr->Ip + Offset); - } else { - // - // All code word reads should be aligned - // - EbcDebugSignalException ( - EXCEPT_EBC_ALIGNMENT_CHECK, - EXCEPTION_FLAG_WARNING, - VmPtr - ); - } - // - // Return unaligned data - // - return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8)); -} - -STATIC -UINT32 -VmReadCode32 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -{ - UINT32 Data; - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) { - return * (UINT32 *) (VmPtr->Ip + Offset); - } - // - // Return unaligned data - // - Data = (UINT32) VmReadCode16 (VmPtr, Offset); - Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16); - return Data; -} - -STATIC -UINT64 -VmReadCode64 ( - IN VM_CONTEXT *VmPtr, - IN UINT32 Offset - ) -{ - UINT64 Data64; - UINT32 Data32; - UINT8 *Ptr; - - // - // Read direct if aligned - // - if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) { - return * (UINT64 *) (VmPtr->Ip + Offset); - } - // - // Return unaligned data. - // - Ptr = (UINT8 *) &Data64; - Data32 = VmReadCode32 (VmPtr, Offset); - *(UINT32 *) Ptr = Data32; - Ptr += sizeof (Data32); - Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32)); - *(UINT32 *) Ptr = Data32; - return Data64; -} - -STATIC -UINT8 -VmReadMem8 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -{ - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - // - // Simply return the data in flat memory space - // - return * (UINT8 *) Addr; -} - -STATIC -UINT16 -VmReadMem16 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -{ - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - // - // Read direct if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT16))) { - return * (UINT16 *) Addr; - } - // - // Return unaligned data - // - return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8)); -} - -STATIC -UINT32 -VmReadMem32 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -{ - UINT32 Data; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - // - // Read direct if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT32))) { - return * (UINT32 *) Addr; - } - // - // Return unaligned data - // - Data = (UINT32) VmReadMem16 (VmPtr, Addr); - Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16); - return Data; -} - -STATIC -UINT64 -VmReadMem64 ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -{ - UINT64 Data; - UINT32 Data32; - - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - - // - // Read direct if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINT64))) { - return * (UINT64 *) Addr; - } - // - // Return unaligned data. Assume little endian. - // - Data = (UINT64) VmReadMem32 (VmPtr, Addr); - Data32 = VmReadMem32 (VmPtr, Addr + sizeof (UINT32)); - *(UINT32 *) ((UINT32 *) &Data + 1) = Data32; - return Data; -} - -STATIC -UINTN -ConvertStackAddr ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -/*++ - -Routine Description: - - Given an address that EBC is going to read from or write to, return - an appropriate address that accounts for a gap in the stack. - - The stack for this application looks like this (high addr on top) - [EBC entry point arguments] - [VM stack] - [EBC stack] - - The EBC assumes that its arguments are at the top of its stack, which - is where the VM stack is really. Therefore if the EBC does memory - accesses into the VM stack area, then we need to convert the address - to point to the EBC entry point arguments area. Do this here. - -Arguments: - - VmPtr - pointer to VM context - Addr - address of interest - -Returns: - - The unchanged address if it's not in the VM stack region. Otherwise, - adjust for the stack gap and return the modified address. - ---*/ -{ - ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom))); - return Addr; -} - -STATIC -UINTN -VmReadMemN ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr - ) -/*++ - -Routine Description: - Read a natural value from memory. May or may not be aligned. - -Arguments: - VmPtr - current VM context - Addr - the address to read from - -Returns: - The natural value at address Addr. - ---*/ -{ - UINTN Data; - volatile UINT32 Size; - UINT8 *FromPtr; - UINT8 *ToPtr; - // - // Convert the address if it's in the stack gap - // - Addr = ConvertStackAddr (VmPtr, Addr); - // - // Read direct if aligned - // - if (IS_ALIGNED (Addr, sizeof (UINTN))) { - return * (UINTN *) Addr; - } - // - // Return unaligned data - // - Data = 0; - FromPtr = (UINT8 *) Addr; - ToPtr = (UINT8 *) &Data; - - for (Size = 0; Size < sizeof (Data); Size++) { - *ToPtr = *FromPtr; - ToPtr++; - FromPtr++; - } - - return Data; -} - -UINT64 -GetVmVersion ( - VOID - ) -{ - return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF))); -} diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h b/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h deleted file mode 100644 index b1926ee975..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/EbcExecute.h +++ /dev/null @@ -1,323 +0,0 @@ -/*++ - -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: - - EbcExecute.h - -Abstract: - - 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. - ---*/ - -#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->R[OPERAND1_REGNUM (op)] -#define OPERAND2_REGDATA(pvm, op) pvm->R[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 - -EFI_STATUS -EbcExecute ( - IN VM_CONTEXT *VmPtr - ) -; - - - -UINT64 -GetVmVersion ( - VOID - ) -; - -EFI_STATUS -VmWriteMemN ( - IN VM_CONTEXT *VmPtr, - IN UINTN Addr, - IN UINTN Data - ) -; - -EFI_STATUS -VmWriteMem64 ( - IN VM_CONTEXT *VmPtr, - UINTN Addr, - IN UINT64 Data - ) -; - -// -// Define a protocol for an EBC VM test interface. -// -#define EFI_EBC_VM_TEST_PROTOCOL_GUID \ - { \ - 0xAAEACCFDL, 0xF27B, 0x4C17, { 0xB6, 0x10, 0x75, 0xCA, 0x1F, 0x2D, 0xFB, 0x52 } \ - } - -// -// Define for forward reference. -// -typedef struct _EFI_EBC_VM_TEST_PROTOCOL EFI_EBC_VM_TEST_PROTOCOL; - -typedef -EFI_STATUS -(*EBC_VM_TEST_EXECUTE) ( - IN EFI_EBC_VM_TEST_PROTOCOL * This, - IN VM_CONTEXT * VmPtr, - IN OUT UINTN *InstructionCount - ); - -typedef -EFI_STATUS -(*EBC_VM_TEST_ASM) ( - IN EFI_EBC_VM_TEST_PROTOCOL * This, - IN CHAR16 *AsmText, - IN OUT INT8 *Buffer, - IN OUT UINTN *BufferLen - ); - -typedef -EFI_STATUS -(*EBC_VM_TEST_DASM) ( - IN EFI_EBC_VM_TEST_PROTOCOL * This, - IN OUT CHAR16 *AsmText, - IN OUT INT8 *Buffer, - IN OUT UINTN *Len - ); - -// -// Prototype for the actual EBC test protocol interface -// -struct _EFI_EBC_VM_TEST_PROTOCOL { - EBC_VM_TEST_EXECUTE Execute; - EBC_VM_TEST_ASM Assemble; - EBC_VM_TEST_DASM Disassemble; -}; - -EFI_STATUS -EbcExecuteInstructions ( - IN EFI_EBC_VM_TEST_PROTOCOL *This, - IN VM_CONTEXT *VmPtr, - IN OUT UINTN *InstructionCount - ) -; - -#endif // ifndef _EBC_EXECUTE_H_ diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c deleted file mode 100644 index 2b647d9bae..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.c +++ /dev/null @@ -1,1172 +0,0 @@ -/*++ - -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: - - EbcInt.c - -Abstract: - - Top level module for the EBC virtual machine implementation. - Provides auxilliary support routines for the VM. That is, routines - that are not particularly related to VM execution of EBC instructions. - ---*/ - -#include "EbcInt.h" -#include "EbcExecute.h" - -// -// We'll keep track of all thunks we create in a linked list. Each -// thunk is tied to an image handle, so we have a linked list of -// image handles, with each having a linked list of thunks allocated -// to that image handle. -// -typedef struct _EBC_THUNK_LIST { - VOID *ThunkBuffer; - struct _EBC_THUNK_LIST *Next; -} EBC_THUNK_LIST; - -typedef struct _EBC_IMAGE_LIST { - struct _EBC_IMAGE_LIST *Next; - EFI_HANDLE ImageHandle; - EBC_THUNK_LIST *ThunkList; -} EBC_IMAGE_LIST; - -STATIC -EFI_STATUS -EFIAPI -EbcUnloadImage ( - IN EFI_EBC_PROTOCOL *This, - IN EFI_HANDLE ImageHandle - ); - -STATIC -EFI_STATUS -EFIAPI -EbcCreateThunk ( - IN EFI_EBC_PROTOCOL *This, - IN EFI_HANDLE ImageHandle, - IN VOID *EbcEntryPoint, - OUT VOID **Thunk - ); - -STATIC -EFI_STATUS -EFIAPI -EbcGetVersion ( - IN EFI_EBC_PROTOCOL *This, - IN OUT UINT64 *Version - ); - -STATIC -EFI_STATUS -EFIAPI -InitializeEbcCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This - ); - -STATIC -VOID -EFIAPI -CommonEbcExceptionHandler ( - IN EFI_EXCEPTION_TYPE InterruptType, - IN EFI_SYSTEM_CONTEXT SystemContext - ); - -STATIC -VOID -EFIAPI -EbcPeriodicNotifyFunction ( - IN EFI_EVENT Event, - IN VOID *Context - ); - -STATIC -EFI_STATUS -EFIAPI -EbcDebugPeriodic ( - IN VM_CONTEXT *VmPtr - ); - -// -// These two functions and the GUID are used to produce an EBC test protocol. -// This functionality is definitely not required for execution. -// -STATIC -EFI_STATUS -InitEbcVmTestProtocol ( - IN EFI_HANDLE *Handle - ); - -STATIC -EFI_STATUS -EbcVmTestUnsupported ( - VOID - ); - -STATIC -EFI_STATUS -EFIAPI -EbcRegisterICacheFlush ( - IN EFI_EBC_PROTOCOL *This, - IN EBC_ICACHE_FLUSH Flush - ); - -STATIC -EFI_STATUS -EFIAPI -EbcDebugGetMaximumProcessorIndex ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - OUT UINTN *MaxProcessorIndex - ); - -STATIC -EFI_STATUS -EFIAPI -EbcDebugRegisterPeriodicCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN EFI_PERIODIC_CALLBACK PeriodicCallback - ); - -STATIC -EFI_STATUS -EFIAPI -EbcDebugRegisterExceptionCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN EFI_EXCEPTION_CALLBACK ExceptionCallback, - IN EFI_EXCEPTION_TYPE ExceptionType - ); - -STATIC -EFI_STATUS -EFIAPI -EbcDebugInvalidateInstructionCache ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN VOID *Start, - IN UINT64 Length - ); - -// -// We have one linked list of image handles for the whole world. Since -// there should only be one interpreter, make them global. They must -// also be global since the execution of an EBC image does not provide -// a This pointer. -// -static EBC_IMAGE_LIST *mEbcImageList = NULL; - -// -// Callback function to flush the icache after thunk creation -// -static EBC_ICACHE_FLUSH mEbcICacheFlush; - -// -// These get set via calls by the debug agent -// -static EFI_PERIODIC_CALLBACK mDebugPeriodicCallback = NULL; -static EFI_EXCEPTION_CALLBACK mDebugExceptionCallback[MAX_EBC_EXCEPTION + 1] = {NULL}; -static EFI_GUID mEfiEbcVmTestProtocolGuid = EFI_EBC_VM_TEST_PROTOCOL_GUID; - -static VOID* mStackBuffer[MAX_STACK_NUM]; -static EFI_HANDLE mStackBufferIndex[MAX_STACK_NUM]; -static UINTN mStackNum = 0; - -// -// Event for Periodic callback -// -static EFI_EVENT mEbcPeriodicEvent; -VM_CONTEXT *mVmPtr = NULL; - -EFI_STATUS -EFIAPI -InitializeEbcDriver ( - IN EFI_HANDLE ImageHandle, - IN EFI_SYSTEM_TABLE *SystemTable - ) -/*++ - -Routine Description: - - Initializes the VM EFI interface. Allocates memory for the VM interface - and registers the VM protocol. - -Arguments: - - ImageHandle - EFI image handle. - SystemTable - Pointer to the EFI system table. - -Returns: - Standard EFI status code. - ---*/ -{ - EFI_EBC_PROTOCOL *EbcProtocol; - EFI_EBC_PROTOCOL *OldEbcProtocol; - EFI_STATUS Status; - EFI_DEBUG_SUPPORT_PROTOCOL *EbcDebugProtocol; - EFI_HANDLE *HandleBuffer; - UINTN NumHandles; - UINTN Index; - BOOLEAN Installed; - - EbcProtocol = NULL; - EbcDebugProtocol = NULL; - - // - // Allocate memory for our protocol. Then fill in the blanks. - // - EbcProtocol = AllocatePool (sizeof (EFI_EBC_PROTOCOL)); - - if (EbcProtocol == NULL) { - return EFI_OUT_OF_RESOURCES; - } - - EbcProtocol->CreateThunk = EbcCreateThunk; - EbcProtocol->UnloadImage = EbcUnloadImage; - EbcProtocol->RegisterICacheFlush = EbcRegisterICacheFlush; - EbcProtocol->GetVersion = EbcGetVersion; - mEbcICacheFlush = NULL; - - // - // Find any already-installed EBC protocols and uninstall them - // - Installed = FALSE; - HandleBuffer = NULL; - Status = gBS->LocateHandleBuffer ( - ByProtocol, - &gEfiEbcProtocolGuid, - NULL, - &NumHandles, - &HandleBuffer - ); - if (Status == EFI_SUCCESS) { - // - // Loop through the handles - // - for (Index = 0; Index < NumHandles; Index++) { - Status = gBS->HandleProtocol ( - HandleBuffer[Index], - &gEfiEbcProtocolGuid, - (VOID **) &OldEbcProtocol - ); - if (Status == EFI_SUCCESS) { - if (gBS->ReinstallProtocolInterface ( - HandleBuffer[Index], - &gEfiEbcProtocolGuid, - OldEbcProtocol, - EbcProtocol - ) == EFI_SUCCESS) { - Installed = TRUE; - } - } - } - } - - if (HandleBuffer != NULL) { - FreePool (HandleBuffer); - HandleBuffer = NULL; - } - // - // Add the protocol so someone can locate us if we haven't already. - // - if (!Installed) { - Status = gBS->InstallProtocolInterface ( - &ImageHandle, - &gEfiEbcProtocolGuid, - EFI_NATIVE_INTERFACE, - EbcProtocol - ); - if (EFI_ERROR (Status)) { - FreePool (EbcProtocol); - return Status; - } - } - - Status = InitEBCStack(); - if (EFI_ERROR(Status)) { - goto ErrorExit; - } - - // - // Allocate memory for our debug protocol. Then fill in the blanks. - // - EbcDebugProtocol = AllocatePool (sizeof (EFI_DEBUG_SUPPORT_PROTOCOL)); - - if (EbcDebugProtocol == NULL) { - goto ErrorExit; - } - - EbcDebugProtocol->Isa = IsaEbc; - EbcDebugProtocol->GetMaximumProcessorIndex = EbcDebugGetMaximumProcessorIndex; - EbcDebugProtocol->RegisterPeriodicCallback = EbcDebugRegisterPeriodicCallback; - EbcDebugProtocol->RegisterExceptionCallback = EbcDebugRegisterExceptionCallback; - EbcDebugProtocol->InvalidateInstructionCache = EbcDebugInvalidateInstructionCache; - - // - // Add the protocol so the debug agent can find us - // - Status = gBS->InstallProtocolInterface ( - &ImageHandle, - &gEfiDebugSupportProtocolGuid, - EFI_NATIVE_INTERFACE, - EbcDebugProtocol - ); - // - // This is recoverable, so free the memory and continue. - // - if (EFI_ERROR (Status)) { - FreePool (EbcDebugProtocol); - goto ErrorExit; - } - // - // Install EbcDebugSupport Protocol Successfully - // Now we need to initialize the Ebc default Callback - // - Status = InitializeEbcCallback (EbcDebugProtocol); - - // - // Produce a VM test interface protocol. Not required for execution. - // - DEBUG_CODE_BEGIN (); - InitEbcVmTestProtocol (&ImageHandle); - DEBUG_CODE_END (); - - return EFI_SUCCESS; - -ErrorExit: - FreeEBCStack(); - HandleBuffer = NULL; - Status = gBS->LocateHandleBuffer ( - ByProtocol, - &gEfiEbcProtocolGuid, - NULL, - &NumHandles, - &HandleBuffer - ); - if (Status == EFI_SUCCESS) { - // - // Loop through the handles - // - for (Index = 0; Index < NumHandles; Index++) { - Status = gBS->HandleProtocol ( - HandleBuffer[Index], - &gEfiEbcProtocolGuid, - (VOID **) &OldEbcProtocol - ); - if (Status == EFI_SUCCESS) { - gBS->UninstallProtocolInterface ( - HandleBuffer[Index], - &gEfiEbcProtocolGuid, - OldEbcProtocol - ); - } - } - } - - if (HandleBuffer != NULL) { - FreePool (HandleBuffer); - HandleBuffer = NULL; - } - - FreePool (EbcProtocol); - - return Status; -} - -STATIC -EFI_STATUS -EFIAPI -EbcCreateThunk ( - IN EFI_EBC_PROTOCOL *This, - IN EFI_HANDLE ImageHandle, - IN VOID *EbcEntryPoint, - OUT VOID **Thunk - ) -/*++ - -Routine Description: - - This is the top-level routine plugged into the EBC protocol. Since thunks - are very processor-specific, from here we dispatch directly to the very - processor-specific routine EbcCreateThunks(). - -Arguments: - - This - protocol instance pointer - ImageHandle - handle to the image. The EBC interpreter may use this to keep - track of any resource allocations performed in loading and - executing the image. - EbcEntryPoint - the entry point for the image (as defined in the file header) - Thunk - pointer to thunk pointer where the address of the created - thunk is returned. - -Returns: - - EFI_STATUS - ---*/ -{ - EFI_STATUS Status; - - Status = EbcCreateThunks ( - ImageHandle, - EbcEntryPoint, - Thunk, - FLAG_THUNK_ENTRY_POINT - ); - return Status; -} - -STATIC -EFI_STATUS -EFIAPI -EbcDebugGetMaximumProcessorIndex ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - OUT UINTN *MaxProcessorIndex - ) -/*++ - -Routine Description: - - This EBC debugger protocol service is called by the debug agent - -Arguments: - - This - pointer to the caller's debug support protocol interface - MaxProcessorIndex - pointer to a caller allocated UINTN in which the maximum - processor index is returned. - -Returns: - - Standard EFI_STATUS - ---*/ -{ - *MaxProcessorIndex = 0; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcDebugRegisterPeriodicCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN EFI_PERIODIC_CALLBACK PeriodicCallback - ) -/*++ - -Routine Description: - - This protocol service is called by the debug agent to register a function - for us to call on a periodic basis. - - -Arguments: - - This - pointer to the caller's debug support protocol interface - PeriodicCallback - pointer to the function to call periodically - -Returns: - - Always EFI_SUCCESS - ---*/ -{ - if ((mDebugPeriodicCallback == NULL) && (PeriodicCallback == NULL)) { - return EFI_INVALID_PARAMETER; - } - if ((mDebugPeriodicCallback != NULL) && (PeriodicCallback != NULL)) { - return EFI_ALREADY_STARTED; - } - - mDebugPeriodicCallback = PeriodicCallback; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcDebugRegisterExceptionCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN EFI_EXCEPTION_CALLBACK ExceptionCallback, - IN EFI_EXCEPTION_TYPE ExceptionType - ) -/*++ - -Routine Description: - - This protocol service is called by the debug agent to register a function - for us to call when we detect an exception. - - -Arguments: - - This - pointer to the caller's debug support protocol interface - ExceptionCallback - pointer to the function to the exception - -Returns: - - Always EFI_SUCCESS - ---*/ -{ - if ((ExceptionType < 0) || (ExceptionType > MAX_EBC_EXCEPTION)) { - return EFI_INVALID_PARAMETER; - } - if ((mDebugExceptionCallback[ExceptionType] == NULL) && (ExceptionCallback == NULL)) { - return EFI_INVALID_PARAMETER; - } - if ((mDebugExceptionCallback[ExceptionType] != NULL) && (ExceptionCallback != NULL)) { - return EFI_ALREADY_STARTED; - } - mDebugExceptionCallback[ExceptionType] = ExceptionCallback; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcDebugInvalidateInstructionCache ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This, - IN UINTN ProcessorIndex, - IN VOID *Start, - IN UINT64 Length - ) -/*++ - -Routine Description: - - This EBC debugger protocol service is called by the debug agent. Required - for DebugSupport compliance but is only stubbed out for EBC. - -Arguments: - -Returns: - - EFI_SUCCESS - ---*/ -{ - return EFI_SUCCESS; -} - -EFI_STATUS -EbcDebugSignalException ( - IN EFI_EXCEPTION_TYPE ExceptionType, - IN EXCEPTION_FLAGS ExceptionFlags, - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - The VM interpreter calls this function when an exception is detected. - -Arguments: - - VmPtr - pointer to a VM context for passing info to the EFI debugger. - -Returns: - - EFI_SUCCESS if it returns at all - ---*/ -{ - EFI_SYSTEM_CONTEXT_EBC EbcContext; - EFI_SYSTEM_CONTEXT SystemContext; - - ASSERT ((ExceptionType >= 0) && (ExceptionType <= MAX_EBC_EXCEPTION)); - // - // Save the exception in the context passed in - // - VmPtr->ExceptionFlags |= ExceptionFlags; - VmPtr->LastException = ExceptionType; - // - // If it's a fatal exception, then flag it in the VM context in case an - // attached debugger tries to return from it. - // - if (ExceptionFlags & EXCEPTION_FLAG_FATAL) { - VmPtr->StopFlags |= STOPFLAG_APP_DONE; - } - - // - // If someone's registered for exception callbacks, then call them. - // - // EBC driver will register default exception callback to report the - // status code via the status code API - // - if (mDebugExceptionCallback[ExceptionType] != NULL) { - - // - // Initialize the context structure - // - EbcContext.R0 = VmPtr->R[0]; - EbcContext.R1 = VmPtr->R[1]; - EbcContext.R2 = VmPtr->R[2]; - EbcContext.R3 = VmPtr->R[3]; - EbcContext.R4 = VmPtr->R[4]; - EbcContext.R5 = VmPtr->R[5]; - EbcContext.R6 = VmPtr->R[6]; - EbcContext.R7 = VmPtr->R[7]; - EbcContext.Ip = (UINT64)(UINTN)VmPtr->Ip; - EbcContext.Flags = VmPtr->Flags; - EbcContext.ControlFlags = 0; - SystemContext.SystemContextEbc = &EbcContext; - - mDebugExceptionCallback[ExceptionType] (ExceptionType, SystemContext); - // - // Restore the context structure and continue to execute - // - VmPtr->R[0] = EbcContext.R0; - VmPtr->R[1] = EbcContext.R1; - VmPtr->R[2] = EbcContext.R2; - VmPtr->R[3] = EbcContext.R3; - VmPtr->R[4] = EbcContext.R4; - VmPtr->R[5] = EbcContext.R5; - VmPtr->R[6] = EbcContext.R6; - VmPtr->R[7] = EbcContext.R7; - VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip; - VmPtr->Flags = EbcContext.Flags; - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -InitializeEbcCallback ( - IN EFI_DEBUG_SUPPORT_PROTOCOL *This - ) -/*++ - -Routine Description: - - To install default Callback function for the VM interpreter. - -Arguments: - - This - pointer to the instance of DebugSupport protocol - -Returns: - - None - ---*/ -{ - INTN Index; - EFI_STATUS Status; - - // - // For ExceptionCallback - // - for (Index = 0; Index <= MAX_EBC_EXCEPTION; Index++) { - EbcDebugRegisterExceptionCallback ( - This, - 0, - CommonEbcExceptionHandler, - Index - ); - } - - // - // For PeriodicCallback - // - Status = gBS->CreateEvent ( - EVT_TIMER | EVT_NOTIFY_SIGNAL, - TPL_NOTIFY, - EbcPeriodicNotifyFunction, - &mVmPtr, - &mEbcPeriodicEvent - ); - if (EFI_ERROR(Status)) { - return Status; - } - - Status = gBS->SetTimer ( - mEbcPeriodicEvent, - TimerPeriodic, - EBC_VM_PERIODIC_CALLBACK_RATE - ); - if (EFI_ERROR(Status)) { - return Status; - } - - return EFI_SUCCESS; -} - -STATIC -VOID -CommonEbcExceptionHandler ( - IN EFI_EXCEPTION_TYPE InterruptType, - IN EFI_SYSTEM_CONTEXT SystemContext - ) -/*++ - -Routine Description: - - The default Exception Callback for the VM interpreter. - In this function, we report status code, and print debug information - about EBC_CONTEXT, then dead loop. - -Arguments: - - InterruptType - Interrupt type. - SystemContext - EBC system context. - -Returns: - - None - ---*/ -{ - // - // We deadloop here to make it easy to debug this issue. - // - ASSERT (FALSE); - - return ; -} - -STATIC -VOID -EFIAPI -EbcPeriodicNotifyFunction ( - IN EFI_EVENT Event, - IN VOID *Context - ) -/*++ - -Routine Description: - - The periodic callback function for EBC VM interpreter, which is used - to support the EFI debug support protocol. - -Arguments: - - Event - The Periodic Callback Event. - Context - It should be the address of VM_CONTEXT pointer. - -Returns: - - None. - ---*/ -{ - VM_CONTEXT *VmPtr; - - VmPtr = *(VM_CONTEXT **)Context; - - if (VmPtr != NULL) { - EbcDebugPeriodic (VmPtr); - } - - return ; -} - -STATIC -EFI_STATUS -EbcDebugPeriodic ( - IN VM_CONTEXT *VmPtr - ) -/*++ - -Routine Description: - - The VM interpreter calls this function on a periodic basis to support - the EFI debug support protocol. - -Arguments: - - VmPtr - pointer to a VM context for passing info to the debugger. - -Returns: - - Standard EFI status. - ---*/ -{ - EFI_SYSTEM_CONTEXT_EBC EbcContext; - EFI_SYSTEM_CONTEXT SystemContext; - - // - // If someone's registered for periodic callbacks, then call them. - // - if (mDebugPeriodicCallback != NULL) { - - // - // Initialize the context structure - // - EbcContext.R0 = VmPtr->R[0]; - EbcContext.R1 = VmPtr->R[1]; - EbcContext.R2 = VmPtr->R[2]; - EbcContext.R3 = VmPtr->R[3]; - EbcContext.R4 = VmPtr->R[4]; - EbcContext.R5 = VmPtr->R[5]; - EbcContext.R6 = VmPtr->R[6]; - EbcContext.R7 = VmPtr->R[7]; - EbcContext.Ip = (UINT64)(UINTN)VmPtr->Ip; - EbcContext.Flags = VmPtr->Flags; - EbcContext.ControlFlags = 0; - SystemContext.SystemContextEbc = &EbcContext; - - mDebugPeriodicCallback (SystemContext); - - // - // Restore the context structure and continue to execute - // - VmPtr->R[0] = EbcContext.R0; - VmPtr->R[1] = EbcContext.R1; - VmPtr->R[2] = EbcContext.R2; - VmPtr->R[3] = EbcContext.R3; - VmPtr->R[4] = EbcContext.R4; - VmPtr->R[5] = EbcContext.R5; - VmPtr->R[6] = EbcContext.R6; - VmPtr->R[7] = EbcContext.R7; - VmPtr->Ip = (VMIP)(UINTN)EbcContext.Ip; - VmPtr->Flags = EbcContext.Flags; - } - - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcUnloadImage ( - IN EFI_EBC_PROTOCOL *This, - IN EFI_HANDLE ImageHandle - ) -/*++ - -Routine Description: - - This routine is called by the core when an image is being unloaded from - memory. Basically we now have the opportunity to do any necessary cleanup. - Typically this will include freeing any memory allocated for thunk-creation. - -Arguments: - - This - protocol instance pointer - ImageHandle - handle to the image being unloaded. - -Returns: - - EFI_INVALID_PARAMETER - the ImageHandle passed in was not found in - the internal list of EBC image handles. - EFI_STATUS - completed successfully - ---*/ -{ - EBC_THUNK_LIST *ThunkList; - EBC_THUNK_LIST *NextThunkList; - EBC_IMAGE_LIST *ImageList; - EBC_IMAGE_LIST *PrevImageList; - // - // First go through our list of known image handles and see if we've already - // created an image list element for this image handle. - // - ReturnEBCStackByHandle(ImageHandle); - PrevImageList = NULL; - for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) { - if (ImageList->ImageHandle == ImageHandle) { - break; - } - // - // Save the previous so we can connect the lists when we remove this one - // - PrevImageList = ImageList; - } - - if (ImageList == NULL) { - return EFI_INVALID_PARAMETER; - } - // - // Free up all the thunk buffers and thunks list elements for this image - // handle. - // - ThunkList = ImageList->ThunkList; - while (ThunkList != NULL) { - NextThunkList = ThunkList->Next; - FreePool (ThunkList->ThunkBuffer); - FreePool (ThunkList); - ThunkList = NextThunkList; - } - // - // Now remove this image list element from the chain - // - if (PrevImageList == NULL) { - // - // Remove from head - // - mEbcImageList = ImageList->Next; - } else { - PrevImageList->Next = ImageList->Next; - } - // - // Now free up the image list element - // - FreePool (ImageList); - return EFI_SUCCESS; -} - -EFI_STATUS -EbcAddImageThunk ( - IN EFI_HANDLE ImageHandle, - IN VOID *ThunkBuffer, - IN UINT32 ThunkSize - ) -/*++ - -Routine Description: - - 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. - -Arguments: - - ImageHandle - the image handle to which the thunk is tied - ThunkBuffer - the buffer we've created/allocated - ThunkSize - the size of the thunk memory allocated - -Returns: - - EFI_OUT_OF_RESOURCES - memory allocation failed - EFI_SUCCESS - successful completion - ---*/ -{ - EBC_THUNK_LIST *ThunkList; - EBC_IMAGE_LIST *ImageList; - EFI_STATUS Status; - - // - // It so far so good, then flush the instruction cache - // - if (mEbcICacheFlush != NULL) { - Status = mEbcICacheFlush ((EFI_PHYSICAL_ADDRESS) (UINTN) ThunkBuffer, ThunkSize); - if (EFI_ERROR (Status)) { - return Status; - } - } - // - // Go through our list of known image handles and see if we've already - // created a image list element for this image handle. - // - for (ImageList = mEbcImageList; ImageList != NULL; ImageList = ImageList->Next) { - if (ImageList->ImageHandle == ImageHandle) { - break; - } - } - - if (ImageList == NULL) { - // - // Allocate a new one - // - ImageList = AllocatePool (sizeof (EBC_IMAGE_LIST)); - - if (ImageList == NULL) { - return EFI_OUT_OF_RESOURCES; - } - - ImageList->ThunkList = NULL; - ImageList->ImageHandle = ImageHandle; - ImageList->Next = mEbcImageList; - mEbcImageList = ImageList; - } - // - // Ok, now create a new thunk element to add to the list - // - ThunkList = AllocatePool (sizeof (EBC_THUNK_LIST)); - - if (ThunkList == NULL) { - return EFI_OUT_OF_RESOURCES; - } - // - // Add it to the head of the list - // - ThunkList->Next = ImageList->ThunkList; - ThunkList->ThunkBuffer = ThunkBuffer; - ImageList->ThunkList = ThunkList; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcRegisterICacheFlush ( - IN EFI_EBC_PROTOCOL *This, - IN EBC_ICACHE_FLUSH Flush - ) -{ - mEbcICacheFlush = Flush; - return EFI_SUCCESS; -} - -STATIC -EFI_STATUS -EFIAPI -EbcGetVersion ( - IN EFI_EBC_PROTOCOL *This, - IN OUT UINT64 *Version - ) -{ - if (Version == NULL) { - return EFI_INVALID_PARAMETER; - } - - *Version = GetVmVersion (); - return EFI_SUCCESS; -} - -EFI_STATUS -GetEBCStack( - EFI_HANDLE Handle, - VOID **StackBuffer, - UINTN *BufferIndex - ) -{ - UINTN Index; - EFI_TPL OldTpl; - OldTpl = gBS->RaiseTPL(TPL_HIGH_LEVEL); - for (Index = 0; Index < mStackNum; Index ++) { - if (mStackBufferIndex[Index] == NULL) { - mStackBufferIndex[Index] = Handle; - break; - } - } - gBS->RestoreTPL(OldTpl); - if (Index == mStackNum) { - return EFI_OUT_OF_RESOURCES; - } - *BufferIndex = Index; - *StackBuffer = mStackBuffer[Index]; - return EFI_SUCCESS; -} - -EFI_STATUS -ReturnEBCStack( - UINTN Index - ) -{ - mStackBufferIndex[Index] =NULL; - return EFI_SUCCESS; -} - -EFI_STATUS -ReturnEBCStackByHandle( - EFI_HANDLE Handle - ) -{ - UINTN Index; - for (Index = 0; Index < mStackNum; Index ++) { - if (mStackBufferIndex[Index] == Handle) { - break; - } - } - if (Index == mStackNum) { - return EFI_NOT_FOUND; - } - mStackBufferIndex[Index] = NULL; - return EFI_SUCCESS; -} - -EFI_STATUS -InitEBCStack ( - VOID - ) -{ - for (mStackNum = 0; mStackNum < MAX_STACK_NUM; mStackNum ++) { - mStackBuffer[mStackNum] = AllocatePool(STACK_POOL_SIZE); - mStackBufferIndex[mStackNum] = NULL; - if (mStackBuffer[mStackNum] == NULL) { - break; - } - } - if (mStackNum == 0) { - return EFI_OUT_OF_RESOURCES; - } - return EFI_SUCCESS; -} - -EFI_STATUS -FreeEBCStack( - VOID - ) -{ - UINTN Index; - for (Index = 0; Index < mStackNum; Index ++) { - FreePool(mStackBuffer[Index]); - } - return EFI_SUCCESS; -} -STATIC -EFI_STATUS -InitEbcVmTestProtocol ( - IN EFI_HANDLE *IHandle - ) -/*++ - -Routine Description: - - Produce an EBC VM test protocol that can be used for regression tests. - -Arguments: - - IHandle - handle on which to install the protocol. - -Returns: - - EFI_OUT_OF_RESOURCES - memory allocation failed - EFI_SUCCESS - successful completion - ---*/ -{ - EFI_HANDLE Handle; - EFI_STATUS Status; - EFI_EBC_VM_TEST_PROTOCOL *EbcVmTestProtocol; - - // - // Allocate memory for the protocol, then fill in the fields - // - EbcVmTestProtocol = AllocatePool (sizeof (EFI_EBC_VM_TEST_PROTOCOL)); - if (EbcVmTestProtocol == NULL) { - return EFI_OUT_OF_RESOURCES; - } - EbcVmTestProtocol->Execute = (EBC_VM_TEST_EXECUTE) EbcExecuteInstructions; - - DEBUG_CODE_BEGIN (); - EbcVmTestProtocol->Assemble = (EBC_VM_TEST_ASM) EbcVmTestUnsupported; - EbcVmTestProtocol->Disassemble = (EBC_VM_TEST_DASM) EbcVmTestUnsupported; - DEBUG_CODE_END (); - - // - // Publish the protocol - // - Handle = NULL; - Status = gBS->InstallProtocolInterface (&Handle, &mEfiEbcVmTestProtocolGuid, EFI_NATIVE_INTERFACE, EbcVmTestProtocol); - if (EFI_ERROR (Status)) { - FreePool (EbcVmTestProtocol); - } - return Status; -} -STATIC -EFI_STATUS -EbcVmTestUnsupported () -{ - return EFI_UNSUPPORTED; -} - diff --git a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h b/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h deleted file mode 100644 index d1631f8e9b..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/EbcInt.h +++ /dev/null @@ -1,283 +0,0 @@ -/*++ - -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: - - EbcInt.h - -Abstract: - - Main routines for the EBC interpreter. Includes the initialization and - main interpreter routines. - ---*/ - -#ifndef _EBC_INT_H_ -#define _EBC_INT_H_ - -// -// The package level header files this module uses -// -#include -// -// The protocols, PPI and GUID defintions for this module -// -#include -#include -// -// The Library classes this module consumes -// -#include -#include -#include -#include -#include -#include - -typedef INT64 VM_REGISTER; -typedef UINT8 *VMIP; // instruction pointer for the VM -typedef UINT32 EXCEPTION_FLAGS; - -typedef struct { - VM_REGISTER R[8]; // General purpose registers. - UINT64 Flags; // Flags register: - // 0 Set to 1 if the result of the last compare was true - // 1 Set to 1 if stepping - // 2..63 Reserved. - VMIP Ip; // Instruction pointer. - UINTN LastException; // - EXCEPTION_FLAGS ExceptionFlags; // to keep track of exceptions - UINT32 StopFlags; - UINT32 CompilerVersion; // via break(6) - UINTN HighStackBottom; // bottom of the upper stack - UINTN LowStackTop; // top of the lower stack - UINT64 StackRetAddr; // location of final return address on stack - UINTN *StackMagicPtr; // pointer to magic value on stack to detect corruption - EFI_HANDLE ImageHandle; // for this EBC driver - EFI_SYSTEM_TABLE *SystemTable; // for debugging only - UINTN LastAddrConverted; // for debug - UINTN LastAddrConvertedValue; // for debug - VOID *FramePtr; - VOID *EntryPoint; // entry point of EBC image - UINTN ImageBase; - VOID *StackPool; - VOID *StackTop; -} VM_CONTEXT; - -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 - -EFI_STATUS -EbcCreateThunks ( - IN EFI_HANDLE ImageHandle, - IN VOID *EbcEntryPoint, - OUT VOID **Thunk, - IN UINT32 Flags - ) -; - -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. -// -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 - -EFI_STATUS -EbcDebugSignalPeriodic ( - IN VM_CONTEXT *VmPtr - ) -; - -// -// External low level functions that are native-processor dependent -// -UINTN -EbcLLGetEbcEntryPoint ( - VOID - ) -; - -UINTN -EbcLLGetStackPointer ( - VOID - ) -; - -VOID -EbcLLCALLEXNative ( - IN UINTN CallAddr, - IN UINTN EbcSp, - IN VOID *FramePtr - ) -; - -VOID -EbcLLCALLEX ( - IN VM_CONTEXT *VmPtr, - IN UINTN CallAddr, - IN UINTN EbcSp, - IN VOID *FramePtr, - IN UINT8 Size - ) -; - -INT64 -EbcLLGetReturnValue ( - VOID - ) -; - -EFI_STATUS -GetEBCStack( - EFI_HANDLE Handle, - VOID **StackBuffer, - UINTN *BufferIndex - ); - -EFI_STATUS -ReturnEBCStack( - UINTN Index - ); - -EFI_STATUS -InitEBCStack ( - VOID - ); - -EFI_STATUS -FreeEBCStack( - VOID - ); - -EFI_STATUS -ReturnEBCStackByHandle( - EFI_HANDLE Handle - ); -// -// Defines for a simple EBC debugger interface -// -typedef struct _EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL; - -#define EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL_GUID \ - { \ - 0x2a72d11e, 0x7376, 0x40f6, { 0x9c, 0x68, 0x23, 0xfa, 0x2f, 0xe3, 0x63, 0xf1 } \ - } - -typedef -EFI_STATUS -(*EBC_DEBUGGER_SIGNAL_EXCEPTION) ( - IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, - IN VM_CONTEXT * VmPtr, - IN EFI_EXCEPTION_TYPE ExceptionType - ); - -typedef -VOID -(*EBC_DEBUGGER_DEBUG) ( - IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, - IN VM_CONTEXT * VmPtr - ); - -typedef -UINT32 -(*EBC_DEBUGGER_DASM) ( - IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, - IN VM_CONTEXT * VmPtr, - IN UINT16 *DasmString OPTIONAL, - IN UINT32 DasmStringSize - ); - -// -// This interface allows you to configure the EBC debug support -// driver. For example, turn on or off saving and printing of -// delta VM even if called. Or to even disable the entire interface, -// in which case all functions become no-ops. -// -typedef -EFI_STATUS -(*EBC_DEBUGGER_CONFIGURE) ( - IN EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL * This, - IN UINT32 ConfigId, - IN UINTN ConfigValue - ); - -// -// Prototype for the actual EBC debug support protocol interface -// -struct _EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL { - EBC_DEBUGGER_DEBUG Debugger; - EBC_DEBUGGER_SIGNAL_EXCEPTION SignalException; - EBC_DEBUGGER_DASM Dasm; - EBC_DEBUGGER_CONFIGURE Configure; -}; - -typedef struct { - EFI_EBC_PROTOCOL *This; - VOID *EntryPoint; - EFI_HANDLE ImageHandle; - VM_CONTEXT VmContext; -} EFI_EBC_THUNK_DATA; - -#define EBC_PROTOCOL_PRIVATE_DATA_SIGNATURE EFI_SIGNATURE_32 ('e', 'b', 'c', 'p') - -struct _EBC_PROTOCOL_PRIVATE_DATA { - UINT32 Signature; - EFI_EBC_PROTOCOL EbcProtocol; - UINTN StackBase; - UINTN StackTop; - UINTN StackSize; -} ; - -#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_ diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S deleted file mode 100644 index 5e9828dc11..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.S +++ /dev/null @@ -1,54 +0,0 @@ -#**************************************************************************** -#* -#* 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. -#* -#**************************************************************************** -.globl ASM_PFX(CopyMem) - -.globl 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 - -.globl ASM_PFX(EbcLLGetEbcEntryPoint) -ASM_PFX(EbcLLGetEbcEntryPoint): - ret - -.globl ASM_PFX(EbcLLGetStackPointer) -ASM_PFX(EbcLLGetStackPointer): - mov %esp,%eax - add $0x4,%eax - ret - -.globl ASM_PFX(EbcLLGetReturnValue) -ASM_PFX(EbcLLGetReturnValue): - ret diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm deleted file mode 100644 index 4249241e7d..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcLowLevel.asm +++ /dev/null @@ -1,163 +0,0 @@ - page ,132 - title VM ASSEMBLY LANGUAGE ROUTINES -;**************************************************************************** -;* -;* Copyright (c) 2006 - 2007, 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. -;* -;**************************************************************************** -;**************************************************************************** -; REV 1.0 -;**************************************************************************** -; -; Rev Date Description -; --- -------- ------------------------------------------------------------ -; 1.0 03/14/01 Initial creation of file. -; -;**************************************************************************** - -;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -; This code provides low level routines that support the Virtual Machine -; for option ROMs. -;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - -;--------------------------------------------------------------------------- -; Equate files needed. -;--------------------------------------------------------------------------- - -.XLIST - -.LIST - -;--------------------------------------------------------------------------- -; Assembler options -;--------------------------------------------------------------------------- - -.686p -.model flat -.code -;--------------------------------------------------------------------------- -;;GenericPostSegment SEGMENT USE16 -;--------------------------------------------------------------------------- -CopyMem PROTO C Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD - -;**************************************************************************** -; 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. -;**************************************************************************** -; VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) -_EbcLLCALLEXNative PROC NEAR 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 - - -; UINTN EbcLLGetEbcEntryPoint(VOID); -; Routine Description: -; 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. -; -; Arguments: -; None. -; -; Returns: -; The contents of the register in which the entry point is passed. -; -_EbcLLGetEbcEntryPoint PROC NEAR PUBLIC - ret -_EbcLLGetEbcEntryPoint ENDP - -;/*++ -; -;Routine Description: -; -; Return the caller's value of the stack pointer. -; -;Arguments: -; -; None. -; -;Returns: -; -; The current value of the stack pointer for the caller. We -; adjust it by 4 here because when they called us, the return address -; is put on the stack, thereby lowering it by 4 bytes. -; -;--*/ - -; UINTN EbcLLGetStackPointer() -_EbcLLGetStackPointer PROC NEAR PUBLIC - mov eax, esp ; get current stack pointer - add eax, 4 ; stack adjusted by this much when we were called - ret -_EbcLLGetStackPointer ENDP - -; UINT64 EbcLLGetReturnValue(VOID); -; Routine Description: -; When EBC calls native, on return the VM has to stuff the return -; value into a VM register. It's assumed here that the value is still -; in the register, so simply return and the caller should get the -; return result properly. -; -; Arguments: -; None. -; -; Returns: -; The unmodified value returned by the native code. -; -_EbcLLGetReturnValue PROC NEAR PUBLIC - ret -_EbcLLGetReturnValue ENDP - -END diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c deleted file mode 100644 index a534e00780..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ia32/EbcSupport.c +++ /dev/null @@ -1,545 +0,0 @@ -/*++ - -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" - -// -// 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 EBC_THUNK_SIZE 32 - -#define STACK_REMAIN_SIZE (1024 * 4) -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; - - IsThunk = 1; - TargetEbcAddr = 0; - - // - // Processor specific code to check whether the callee is a thunk to EBC. - // - if (*((UINT8 *)FuncAddr) != 0xB8) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 1) != 0xBC) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 2) != 0x2E) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 3) != 0x11) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 4) != 0xCA) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 5) != 0xB8) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 10) != 0xB9) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 15) != 0xFF) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 16) != 0xE1) { - IsThunk = 0; - goto Action; - } - - TargetEbcAddr = ((UINTN)(*((UINT8 *)FuncAddr + 9)) << 24) + ((UINTN)(*((UINT8 *)FuncAddr + 8)) << 16) + - ((UINTN)(*((UINT8 *)FuncAddr + 7)) << 8) + ((UINTN)(*((UINT8 *)FuncAddr + 6))); - -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) (UINTN) (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; - } -} - -STATIC -UINT64 -EbcInterpret ( - IN OUT UINTN Arg1, - IN OUT UINTN Arg2, - IN OUT UINTN Arg3, - IN OUT UINTN Arg4, - IN OUT UINTN Arg5, - IN OUT UINTN Arg6, - IN OUT UINTN Arg7, - IN OUT UINTN Arg8, - IN OUT UINTN Arg9, - IN OUT UINTN Arg10, - IN OUT UINTN Arg11, - IN OUT UINTN Arg12, - IN OUT UINTN Arg13, - IN OUT UINTN Arg14, - IN OUT UINTN Arg15, - IN OUT UINTN Arg16 - ) -/*++ - -Routine Description: - - 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: - - None. Since we're called from a fixed up thunk (which we want to keep - small), our only so-called argument is the EBC entry point passed in - to us in a processor register. - -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. - // - Addr = EbcLLGetEbcEntryPoint (); - - // - // 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.R[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); - VmContext.HighStackBottom = (UINTN)VmContext.R[0]; - VmContext.R[0] &= ~(sizeof (UINTN) - 1); - VmContext.R[0] -= sizeof (UINTN); - - // - // Put a magic value in the stack gap, then adjust down again - // - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; - VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; - VmContext.LowStackTop = (UINTN) VmContext.R[0]; - - // - // For IA32, this is where we say our return address is - // - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg16; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg15; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg14; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg13; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg12; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg11; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg10; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg9; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg8; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg7; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg6; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg5; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg4; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg3; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg2; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) Arg1; - VmContext.R[0] -= 16; - VmContext.StackRetAddr = (UINT64) VmContext.R[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.R[7]; -} - -STATIC -UINT64 -ExecuteEbcImageEntryPoint ( - IN EFI_HANDLE ImageHandle, - IN EFI_SYSTEM_TABLE *SystemTable - ) -/*++ - -Routine Description: - - 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 (); - - // - // Print(L"*** Thunked into EBC entry point - ImageHandle = 0x%X\n", (UINTN)ImageHandle); - // Print(L"EBC entry point is 0x%X\n", (UINT32)(UINTN)Addr); - // - // 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.R[0] = (UINT64)(UINTN) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); - VmContext.HighStackBottom = (UINTN)VmContext.R[0]; - VmContext.R[0] -= sizeof (UINTN); - - // - // Put a magic value in the stack gap, then adjust down again - // - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; - VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; - - // - // Align the stack on a natural boundary - // VmContext.R[0] &= ~(sizeof(UINTN) - 1); - // - VmContext.LowStackTop = (UINTN) VmContext.R[0]; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) SystemTable; - VmContext.R[0] -= sizeof (UINTN); - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) ImageHandle; - - VmContext.R[0] -= 16; - VmContext.StackRetAddr = (UINT64) VmContext.R[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 - // - return (UINT64) VmContext.R[7]; -} - -EFI_STATUS -EbcCreateThunks ( - IN EFI_HANDLE ImageHandle, - IN VOID *EbcEntryPoint, - OUT VOID **Thunk, - IN UINT32 Flags - ) -/*++ - -Routine Description: - - Create an IA32 thunk for the given EBC entry point. - -Arguments: - - ImageHandle - Handle of image for which this thunk is being created - EbcEntryPoint - Address of the EBC code that the thunk is to call - Thunk - Returned thunk we create here - -Returns: - - Standard EFI status. - ---*/ -{ - UINT8 *Ptr; - UINT8 *ThunkBase; - UINT32 I; - UINT32 Addr; - INT32 Size; - INT32 ThunkSize; - - // - // Check alignment of pointer to EBC code - // - if ((UINT32) (UINTN) EbcEntryPoint & 0x01) { - return EFI_INVALID_PARAMETER; - } - - Size = EBC_THUNK_SIZE; - ThunkSize = Size; - - Ptr = AllocatePool (Size); - - 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; - - // - // Add a magic code here to help the VM recognize the thunk.. - // mov eax, 0xca112ebc => B8 BC 2E 11 CA - // - *Ptr = 0xB8; - Ptr++; - Size--; - Addr = (UINT32) 0xCA112EBC; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) (UINTN) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - - // - // Add code bytes to load up a processor register with the EBC entry point. - // mov eax, 0xaa55aa55 => B8 55 AA 55 AA - // The first 8 bytes of the thunk entry is the address of the EBC - // entry point. - // - *Ptr = 0xB8; - Ptr++; - Size--; - Addr = (UINT32) EbcEntryPoint; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) (UINTN) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - // - // Stick in a load of ecx with the address of appropriate VM function. - // mov ecx 12345678h => 0xB9 0x78 0x56 0x34 0x12 - // - if (Flags & FLAG_THUNK_ENTRY_POINT) { - Addr = (UINT32) (UINTN) ExecuteEbcImageEntryPoint; - } else { - Addr = (UINT32) (UINTN) EbcInterpret; - } - - // - // MOV ecx - // - *Ptr = 0xB9; - Ptr++; - Size--; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - // - // Stick in jump opcode bytes for jmp ecx => 0xFF 0xE1 - // - *Ptr = 0xFF; - Ptr++; - Size--; - *Ptr = 0xE1; - Size--; - - // - // Double check that our defined size is ok (application error) - // - if (Size < 0) { - ASSERT (FALSE); - return EFI_BUFFER_TOO_SMALL; - } - // - // 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; -} diff --git a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s deleted file mode 100644 index e329b68e66..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcLowLevel.s +++ /dev/null @@ -1,197 +0,0 @@ -//++ -// 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/Ebc/Dxe/Ipf/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c deleted file mode 100644 index 3647a12fae..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.c +++ /dev/null @@ -1,869 +0,0 @@ -/*++ - -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/Ebc/Dxe/Ipf/EbcSupport.h b/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h deleted file mode 100644 index f6c929ba3e..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/Ipf/EbcSupport.h +++ /dev/null @@ -1,56 +0,0 @@ -/*++ - -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 diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S deleted file mode 100644 index 538462575b..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.S +++ /dev/null @@ -1,144 +0,0 @@ -#**************************************************************************** -#* -#* 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. -#* -#**************************************************************************** -#**************************************************************************** -# REV 1.0 -#**************************************************************************** -# -# Rev Date Description -# --- -------- ------------------------------------------------------------ -# 1.0 05/09/12 Initial creation of file. -# -#**************************************************************************** - -#* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -# This code provides low level routines that support the Virtual Machine -# for option ROMs. -#* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - -#--------------------------------------------------------------------------- -# Equate files needed. -#--------------------------------------------------------------------------- - -#--------------------------------------------------------------------------- -##GenericPostSegment SEGMENT USE16 -#--------------------------------------------------------------------------- - -#**************************************************************************** -# 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. -#**************************************************************************** -.global _CopyMem; - -# VOID EbcLLCALLEXNative(UINTN FuncAddr, UINTN NewStackPointer, VOID *FramePtr) -.global _EbcLLCALLEXNative; -_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 %r8, %rdx - sub %rsp, %r8 - mov %rsp, %rcx - sub %rsp, 0x20 - call _CopyMem - add %rsp, 0x20 - - # Considering the worst case, load 4 potiential arguments - # into registers. - mov (%rsp), %rcx - mov 8(%rsp), %rdx - mov 10(%rsp), %r8 - mov 18(%rsp), %r9 - - # Now call the external routine - call *%rbx - - # Function epilog - mov %rbp, %rsp - pop %rbx - pop %rbp - ret - - -# UINTN EbcLLGetEbcEntryPoint(VOID); -# Routine Description: -# 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. -# -# Arguments: -# None. -# -# Returns: -# The contents of the register in which the entry point is passed. -# -.global _EbcLLGetEbcEntryPoint; -_EbcLLGetEbcEntryPoint: - ret - -#/*++ -# -#Routine Description: -# -# Return the caller's value of the stack pointer. -# -#Arguments: -# -# None. -# -#Returns: -# -# The current value of the stack pointer for the caller. We -# adjust it by 4 here because when they called us, the return address -# is put on the stack, thereby lowering it by 4 bytes. -# -#--*/ - -# UINTN EbcLLGetStackPointer() -.global _EbcLLGetStackPointer; -_EbcLLGetStackPointer: - mov %rsp, %rax - # Stack adjusted by this much when we were called, - # For this function, it's 4. - add $4, %rax - ret - -.global _EbcLLGetReturnValue; -_EbcLLGetReturnValue: -# UINT64 EbcLLGetReturnValue(VOID); -# Routine Description: -# When EBC calls native, on return the VM has to stuff the return -# value into a VM register. It's assumed here that the value is still -# in the register, so simply return and the caller should get the -# return result properly. -# -# Arguments: -# None. -# -# Returns: -# The unmodified value returned by the native code. -# - ret diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm deleted file mode 100644 index 7b59e93aa1..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcLowLevel.asm +++ /dev/null @@ -1,154 +0,0 @@ - page ,132 - title VM ASSEMBLY LANGUAGE ROUTINES -;**************************************************************************** -;* -;* 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. -;* -;**************************************************************************** -;**************************************************************************** -; REV 1.0 -;**************************************************************************** -; -; Rev Date Description -; --- -------- ------------------------------------------------------------ -; 1.0 05/09/12 Initial creation of file. -; -;**************************************************************************** - -;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -; This code provides low level routines that support the Virtual Machine -; for option ROMs. -;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - -;--------------------------------------------------------------------------- -; Equate files needed. -;--------------------------------------------------------------------------- - -text SEGMENT - -;--------------------------------------------------------------------------- -;;GenericPostSegment SEGMENT USE16 -;--------------------------------------------------------------------------- - -;**************************************************************************** -; 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) - -CopyMem PROTO Destination:PTR DWORD, Source:PTR DWORD, Count:DWORD - - -EbcLLCALLEXNative PROC NEAR 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 - sub rsp, r8 - 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 - - -; UINTN EbcLLGetEbcEntryPoint(VOID); -; Routine Description: -; 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. -; -; Arguments: -; None. -; -; Returns: -; The contents of the register in which the entry point is passed. -; -EbcLLGetEbcEntryPoint PROC NEAR PUBLIC - ret -EbcLLGetEbcEntryPoint ENDP - -;/*++ -; -;Routine Description: -; -; Return the caller's value of the stack pointer. -; -;Arguments: -; -; None. -; -;Returns: -; -; The current value of the stack pointer for the caller. We -; adjust it by 4 here because when they called us, the return address -; is put on the stack, thereby lowering it by 4 bytes. -; -;--*/ - -; UINTN EbcLLGetStackPointer() -EbcLLGetStackPointer PROC NEAR PUBLIC - mov rax, rsp ; get current stack pointer - ; Stack adjusted by this much when we were called, - ; For this function, it's 4. - add rax, 4 - ret -EbcLLGetStackPointer ENDP - -; UINT64 EbcLLGetReturnValue(VOID); -; Routine Description: -; When EBC calls native, on return the VM has to stuff the return -; value into a VM register. It's assumed here that the value is still -; in the register, so simply return and the caller should get the -; return result properly. -; -; Arguments: -; None. -; -; Returns: -; The unmodified value returned by the native code. -; -EbcLLGetReturnValue PROC NEAR PUBLIC - ret -EbcLLGetReturnValue ENDP - -text ENDS -END - diff --git a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c b/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c deleted file mode 100644 index bec82d67c5..0000000000 --- a/MdeModulePkg/Universal/Ebc/Dxe/x64/EbcSupport.c +++ /dev/null @@ -1,619 +0,0 @@ -/*++ - -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 x64 processor. - ---*/ - -#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 EBC_THUNK_SIZE 64 - -#define STACK_REMAIN_SIZE (1024 * 4) - -STATIC -VOID -PushU64 ( - VM_CONTEXT *VmPtr, - UINT64 Arg - ) -/*++ - -Routine Description: - - Push a 64 bit unsigned value to the VM stack. - -Arguments: - - VmPtr - The pointer to current VM context. - Arg - The value to be pushed - -Returns: - - VOID - ---*/ -{ - // - // 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; - return; -} - -STATIC -UINT64 -EbcInterpret ( - UINTN Arg1, - UINTN Arg2, - UINTN Arg3, - UINTN Arg4, - UINTN Arg5, - UINTN Arg6, - UINTN Arg7, - UINTN Arg8, - UINTN Arg9, - UINTN Arg10, - UINTN Arg11, - UINTN Arg12, - UINTN Arg13, - UINTN Arg14, - UINTN Arg15, - UINTN Arg16 - ) -/*++ - -Routine Description: - - 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: - - 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. - -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. - // Don't call any function before getting the EBC entry - // point because this will collab the return register. - // - Addr = EbcLLGetEbcEntryPoint (); - - // - // 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. - // - Addr = EbcLLGetStackPointer (); - - // - // 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.R[0] = (UINT64) ((UINT8*)VmContext.StackPool + STACK_POOL_SIZE); - VmContext.HighStackBottom = (UINTN) VmContext.R[0]; - VmContext.R[0] -= sizeof (UINTN); - - // - // Align the stack on a natural boundary. - // - VmContext.R[0] &= ~(sizeof (UINTN) - 1); - - // - // Put a magic value in the stack gap, then adjust down again. - // - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; - VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; - - // - // The stack upper to LowStackTop is belong to the VM. - // - VmContext.LowStackTop = (UINTN) VmContext.R[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.R[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.R[7]; -} - -STATIC -UINT64 -ExecuteEbcImageEntryPoint ( - IN EFI_HANDLE ImageHandle, - IN EFI_SYSTEM_TABLE *SystemTable - ) -/*++ - -Routine Description: - - 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; - - // - // Initialize the stack pointer for the EBC. Get the current system stack - // pointer and adjust it down by the max needed for the interpreter. - // - 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); - - - // - // Put a magic value in the stack gap, then adjust down again - // - *(UINTN *) (UINTN) (VmContext.R[0]) = (UINTN) VM_STACK_KEY_VALUE; - VmContext.StackMagicPtr = (UINTN *) (UINTN) VmContext.R[0]; - - // - // Align the stack on a natural boundary - VmContext.R[0] &= ~(sizeof(UINTN) - 1); - // - 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); - - // - // 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.R[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.R[7]; -} - -EFI_STATUS -EbcCreateThunks ( - IN EFI_HANDLE ImageHandle, - IN VOID *EbcEntryPoint, - OUT VOID **Thunk, - IN UINT32 Flags - ) -/*++ - -Routine Description: - - Create an IA32 thunk for the given EBC entry point. - -Arguments: - - ImageHandle - Handle of image for which this thunk is being created - EbcEntryPoint - Address of the EBC code that the thunk is to call - Thunk - Returned thunk we create here - -Returns: - - Standard EFI status. - ---*/ -{ - UINT8 *Ptr; - UINT8 *ThunkBase; - UINT32 I; - UINT64 Addr; - INT32 Size; - INT32 ThunkSize; - - // - // Check alignment of pointer to EBC code - // - if ((UINT32) (UINTN) EbcEntryPoint & 0x01) { - return EFI_INVALID_PARAMETER; - } - - Size = EBC_THUNK_SIZE; - ThunkSize = Size; - - Ptr = AllocatePool (Size); - - 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; - - // - // Add a magic code here to help the VM recognize the thunk.. - // mov rax, ca112ebccall2ebch => 48 B8 BC 2E 11 CA BC 2E 11 CA - // - *Ptr = 0x48; - Ptr++; - Size--; - *Ptr = 0xB8; - Ptr++; - Size--; - Addr = (UINT64) 0xCA112EBCCA112EBCULL; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) (UINTN) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - - // - // Add code bytes to load up a processor register with the EBC entry point. - // mov rax, 123456789abcdef0h => 48 B8 F0 DE BC 9A 78 56 34 12 - // The first 8 bytes of the thunk entry is the address of the EBC - // entry point. - // - *Ptr = 0x48; - Ptr++; - Size--; - *Ptr = 0xB8; - Ptr++; - Size--; - Addr = (UINT64) EbcEntryPoint; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) (UINTN) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - - // - // Stick in a load of ecx with the address of appropriate VM function. - // Using r11 because it's a volatile register and won't be used in this - // point. - // mov r11 123456789abcdef0h => 49 BB F0 DE BC 9A 78 56 34 12 - // - if (Flags & FLAG_THUNK_ENTRY_POINT) { - Addr = (UINTN) ExecuteEbcImageEntryPoint; - } else { - Addr = (UINTN) EbcInterpret; - } - - // - // mov r11 Addr => 0x49 0xBB - // - *Ptr = 0x49; - Ptr++; - Size--; - *Ptr = 0xBB; - Ptr++; - Size--; - for (I = 0; I < sizeof (Addr); I++) { - *Ptr = (UINT8) Addr; - Addr >>= 8; - Ptr++; - Size--; - } - // - // Stick in jump opcode bytes for jmp r11 => 0x41 0xFF 0xE3 - // - *Ptr = 0x41; - Ptr++; - Size--; - *Ptr = 0xFF; - Ptr++; - Size--; - *Ptr = 0xE3; - Size--; - - // - // Double check that our defined size is ok (application error) - // - if (Size < 0) { - ASSERT (FALSE); - return EFI_BUFFER_TOO_SMALL; - } - // - // 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; -} - -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; - - IsThunk = 1; - TargetEbcAddr = 0; - - // - // Processor specific code to check whether the callee is a thunk to EBC. - // - if (*((UINT8 *)FuncAddr) != 0x48) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 1) != 0xB8) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 2) != 0xBC) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 3) != 0x2E) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 4) != 0x11) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 5) != 0xCA) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 6) != 0xBC) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 7) != 0x2E) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 8) != 0x11) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 9) != 0xCA) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 10) != 0x48) { - IsThunk = 0; - goto Action; - } - if (*((UINT8 *)FuncAddr + 11) != 0xB8) { - IsThunk = 0; - goto Action; - } - - CopyMem (&TargetEbcAddr, (UINT8 *)FuncAddr + 12, 8); - -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; - } -} -