--- /dev/null
+/*++\r
+\r
+Copyright (c) 2006, Intel Corporation \r
+All rights reserved. This program and the accompanying materials \r
+are licensed and made available under the terms and conditions of the BSD License \r
+which accompanies this distribution. The full text of the license may be found at \r
+http://opensource.org/licenses/bsd-license.php \r
+ \r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
+\r
+Module Name:\r
+\r
+ EbcExecute.c\r
+\r
+Abstract:\r
+\r
+ Contains code that implements the virtual machine.\r
+\r
+--*/\r
+\r
+#include "EbcInt.h"\r
+#include "EbcExecute.h"\r
+\r
+\r
+//\r
+// Define some useful data size constants to allow switch statements based on\r
+// size of operands or data.\r
+//\r
+#define DATA_SIZE_INVALID 0\r
+#define DATA_SIZE_8 1\r
+#define DATA_SIZE_16 2\r
+#define DATA_SIZE_32 4\r
+#define DATA_SIZE_64 8\r
+#define DATA_SIZE_N 48 // 4 or 8\r
+//\r
+// Structure we'll use to dispatch opcodes to execute functions.\r
+//\r
+typedef struct {\r
+ EFI_STATUS (*ExecuteFunction) (IN VM_CONTEXT * VmPtr);\r
+}\r
+VM_TABLE_ENTRY;\r
+\r
+typedef\r
+UINT64\r
+(*DATA_MANIP_EXEC_FUNCTION) (\r
+ IN VM_CONTEXT * VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+INT16\r
+VmReadIndex16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ );\r
+\r
+STATIC\r
+INT32\r
+VmReadIndex32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ );\r
+\r
+STATIC\r
+INT64\r
+VmReadIndex64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ );\r
+\r
+STATIC\r
+UINT8\r
+VmReadMem8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+UINT16\r
+VmReadMem16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+UINT32\r
+VmReadMem32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+VmReadMem64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+UINTN\r
+VmReadMemN (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ UINTN Addr,\r
+ IN UINT8 Data\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ UINTN Addr,\r
+ IN UINT16 Data\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ UINTN Addr,\r
+ IN UINT32 Data\r
+ );\r
+\r
+STATIC\r
+UINT16\r
+VmReadCode16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+UINT32\r
+VmReadCode32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+VmReadCode64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+INT8\r
+VmReadImmed8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+INT16\r
+VmReadImmed16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+INT32\r
+VmReadImmed32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+INT64\r
+VmReadImmed64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ );\r
+\r
+STATIC\r
+UINTN\r
+ConvertStackAddr (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteDataManip (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN BOOLEAN IsSignedOperation\r
+ );\r
+\r
+//\r
+// Functions that execute VM opcodes\r
+//\r
+STATIC\r
+EFI_STATUS\r
+ExecuteBREAK (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteJMP (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteJMP8 (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCALL (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteRET (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCMP (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCMPI (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVxx (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVI (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVIn (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVREL (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePUSHn (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePUSH (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePOPn (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePOP (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteSignedDataManip (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteUnsignedDataManip (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteLOADSP (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteSTORESP (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVsnd (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVsnw (\r
+ IN VM_CONTEXT *VmPtr\r
+ );\r
+\r
+//\r
+// Data manipulation subfunctions\r
+//\r
+STATIC\r
+UINT64\r
+ExecuteNOT (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteNEG (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteADD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSUB (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMUL (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMULU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteDIV (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteDIVU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMOD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMODU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteAND (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteOR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteXOR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSHL (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSHR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteASHR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDB (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDW (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ );\r
+\r
+//\r
+// Once we retrieve the operands for the data manipulation instructions,\r
+// call these functions to perform the operation.\r
+//\r
+static CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {\r
+ ExecuteNOT,\r
+ ExecuteNEG,\r
+ ExecuteADD,\r
+ ExecuteSUB,\r
+ ExecuteMUL,\r
+ ExecuteMULU,\r
+ ExecuteDIV,\r
+ ExecuteDIVU,\r
+ ExecuteMOD,\r
+ ExecuteMODU,\r
+ ExecuteAND,\r
+ ExecuteOR,\r
+ ExecuteXOR,\r
+ ExecuteSHL,\r
+ ExecuteSHR,\r
+ ExecuteASHR,\r
+ ExecuteEXTNDB,\r
+ ExecuteEXTNDW,\r
+ ExecuteEXTNDD,\r
+};\r
+\r
+static CONST VM_TABLE_ENTRY mVmOpcodeTable[] = {\r
+ { ExecuteBREAK }, // opcode 0x00\r
+ { ExecuteJMP }, // opcode 0x01\r
+ { ExecuteJMP8 }, // opcode 0x02\r
+ { ExecuteCALL }, // opcode 0x03\r
+ { ExecuteRET }, // opcode 0x04\r
+ { ExecuteCMP }, // opcode 0x05 CMPeq\r
+ { ExecuteCMP }, // opcode 0x06 CMPlte\r
+ { ExecuteCMP }, // opcode 0x07 CMPgte\r
+ { ExecuteCMP }, // opcode 0x08 CMPulte\r
+ { ExecuteCMP }, // opcode 0x09 CMPugte\r
+ { ExecuteUnsignedDataManip }, // opcode 0x0A NOT\r
+ { ExecuteSignedDataManip }, // opcode 0x0B NEG\r
+ { ExecuteSignedDataManip }, // opcode 0x0C ADD\r
+ { ExecuteSignedDataManip }, // opcode 0x0D SUB\r
+ { ExecuteSignedDataManip }, // opcode 0x0E MUL\r
+ { ExecuteUnsignedDataManip }, // opcode 0x0F MULU\r
+ { ExecuteSignedDataManip }, // opcode 0x10 DIV\r
+ { ExecuteUnsignedDataManip }, // opcode 0x11 DIVU\r
+ { ExecuteSignedDataManip }, // opcode 0x12 MOD\r
+ { ExecuteUnsignedDataManip }, // opcode 0x13 MODU\r
+ { ExecuteUnsignedDataManip }, // opcode 0x14 AND\r
+ { ExecuteUnsignedDataManip }, // opcode 0x15 OR\r
+ { ExecuteUnsignedDataManip }, // opcode 0x16 XOR\r
+ { ExecuteUnsignedDataManip }, // opcode 0x17 SHL\r
+ { ExecuteUnsignedDataManip }, // opcode 0x18 SHR\r
+ { ExecuteSignedDataManip }, // opcode 0x19 ASHR\r
+ { ExecuteUnsignedDataManip }, // opcode 0x1A EXTNDB\r
+ { ExecuteUnsignedDataManip }, // opcode 0x1B EXTNDW\r
+ { ExecuteUnsignedDataManip }, // opcode 0x1C EXTNDD\r
+ { ExecuteMOVxx }, // opcode 0x1D MOVBW\r
+ { ExecuteMOVxx }, // opcode 0x1E MOVWW\r
+ { ExecuteMOVxx }, // opcode 0x1F MOVDW\r
+ { ExecuteMOVxx }, // opcode 0x20 MOVQW\r
+ { ExecuteMOVxx }, // opcode 0x21 MOVBD\r
+ { ExecuteMOVxx }, // opcode 0x22 MOVWD\r
+ { ExecuteMOVxx }, // opcode 0x23 MOVDD\r
+ { ExecuteMOVxx }, // opcode 0x24 MOVQD\r
+ { ExecuteMOVsnw }, // opcode 0x25 MOVsnw\r
+ { ExecuteMOVsnd }, // opcode 0x26 MOVsnd\r
+ { NULL }, // opcode 0x27\r
+ { ExecuteMOVxx }, // opcode 0x28 MOVqq\r
+ { ExecuteLOADSP }, // opcode 0x29 LOADSP SP1, R2\r
+ { ExecuteSTORESP }, // opcode 0x2A STORESP R1, SP2\r
+ { ExecutePUSH }, // opcode 0x2B PUSH {@}R1 [imm16]\r
+ { ExecutePOP }, // opcode 0x2C POP {@}R1 [imm16]\r
+ { ExecuteCMPI }, // opcode 0x2D CMPIEQ\r
+ { ExecuteCMPI }, // opcode 0x2E CMPILTE\r
+ { ExecuteCMPI }, // opcode 0x2F CMPIGTE\r
+ { ExecuteCMPI }, // opcode 0x30 CMPIULTE\r
+ { ExecuteCMPI }, // opcode 0x31 CMPIUGTE\r
+ { ExecuteMOVxx }, // opcode 0x32 MOVN\r
+ { ExecuteMOVxx }, // opcode 0x33 MOVND\r
+ { NULL }, // opcode 0x34\r
+ { ExecutePUSHn }, // opcode 0x35\r
+ { ExecutePOPn }, // opcode 0x36\r
+ { ExecuteMOVI }, // opcode 0x37 - mov immediate data\r
+ { ExecuteMOVIn }, // opcode 0x38 - mov immediate natural\r
+ { ExecuteMOVREL } // opcode 0x39 - move data relative to PC\r
+};\r
+\r
+//\r
+// Length of JMP instructions, depending on upper two bits of opcode.\r
+//\r
+static CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 };\r
+\r
+//\r
+// Simple Debugger Protocol GUID\r
+//\r
+EFI_GUID mEbcSimpleDebuggerProtocolGuid = EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL_GUID;\r
+\r
+EFI_STATUS\r
+EbcExecuteInstructions (\r
+ IN EFI_EBC_VM_TEST_PROTOCOL *This,\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN OUT UINTN *InstructionCount\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Given a pointer to a new VM context, execute one or more instructions. This\r
+ function is only used for test purposes via the EBC VM test protocol.\r
+\r
+Arguments:\r
+\r
+ This - pointer to protocol interface\r
+ VmPtr - pointer to a VM context\r
+ InstructionCount - how many instructions to execute. 0 if don't count.\r
+\r
+Returns:\r
+\r
+ EFI_UNSUPPORTED\r
+ EFI_SUCCESS\r
+\r
+--*/\r
+{\r
+ UINTN ExecFunc;\r
+ EFI_STATUS Status;\r
+ UINTN InstructionsLeft;\r
+ UINTN SavedInstructionCount;\r
+\r
+ Status = EFI_SUCCESS;\r
+\r
+ if (*InstructionCount == 0) {\r
+ InstructionsLeft = 1;\r
+ } else {\r
+ InstructionsLeft = *InstructionCount;\r
+ }\r
+\r
+ SavedInstructionCount = *InstructionCount;\r
+ *InstructionCount = 0;\r
+\r
+ //\r
+ // Index into the opcode table using the opcode byte for this instruction.\r
+ // This gives you the execute function, which we first test for null, then\r
+ // call it if it's not null.\r
+ //\r
+ while (InstructionsLeft != 0) {\r
+ ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction;\r
+ if (ExecFunc == (UINTN) NULL) {\r
+ EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ return EFI_UNSUPPORTED;\r
+ } else {\r
+ mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction (VmPtr);\r
+ *InstructionCount = *InstructionCount + 1;\r
+ }\r
+\r
+ //\r
+ // Decrement counter if applicable\r
+ //\r
+ if (SavedInstructionCount != 0) {\r
+ InstructionsLeft--;\r
+ }\r
+ }\r
+\r
+ return Status;\r
+}\r
+\r
+EFI_STATUS\r
+EbcExecute (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute an EBC image from an entry point or from a published protocol.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to prepared VM context.\r
+\r
+Returns:\r
+\r
+ Standard EBC status.\r
+\r
+--*/\r
+{\r
+ UINTN ExecFunc;\r
+ UINT8 StackCorrupted;\r
+ EFI_STATUS Status;\r
+ EFI_EBC_SIMPLE_DEBUGGER_PROTOCOL *EbcSimpleDebugger;\r
+\r
+ mVmPtr = VmPtr;\r
+ EbcSimpleDebugger = NULL;\r
+ Status = EFI_SUCCESS;\r
+ StackCorrupted = 0;\r
+\r
+ //\r
+ // Make sure the magic value has been put on the stack before we got here.\r
+ //\r
+ if (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE) {\r
+ StackCorrupted = 1;\r
+ }\r
+\r
+ VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->R[0] + 8);\r
+\r
+ //\r
+ // Try to get the debug support for EBC\r
+ //\r
+ DEBUG_CODE_BEGIN ();\r
+ Status = gBS->LocateProtocol (\r
+ &mEbcSimpleDebuggerProtocolGuid,\r
+ NULL,\r
+ (VOID **) &EbcSimpleDebugger\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ EbcSimpleDebugger = NULL;\r
+ }\r
+ DEBUG_CODE_END ();\r
+\r
+ //\r
+ // Save the start IP for debug. For example, if we take an exception we\r
+ // can print out the location of the exception relative to the entry point,\r
+ // which could then be used in a disassembly listing to find the problem.\r
+ //\r
+ VmPtr->EntryPoint = (VOID *) VmPtr->Ip;\r
+\r
+ //\r
+ // We'll wait for this flag to know when we're done. The RET\r
+ // instruction sets it if it runs out of stack.\r
+ //\r
+ VmPtr->StopFlags = 0;\r
+ while (!(VmPtr->StopFlags & STOPFLAG_APP_DONE)) {\r
+ //\r
+ // If we've found a simple debugger protocol, call it\r
+ //\r
+ DEBUG_CODE_BEGIN ();\r
+ if (EbcSimpleDebugger != NULL) {\r
+ EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr);\r
+ }\r
+ DEBUG_CODE_END ();\r
+\r
+ //\r
+ // Verify the opcode is in range. Otherwise generate an exception.\r
+ //\r
+ if ((*VmPtr->Ip & OPCODE_M_OPCODE) >= (sizeof (mVmOpcodeTable) / sizeof (mVmOpcodeTable[0]))) {\r
+ EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ Status = EFI_UNSUPPORTED;\r
+ goto Done;\r
+ }\r
+ //\r
+ // Use the opcode bits to index into the opcode dispatch table. If the\r
+ // function pointer is null then generate an exception.\r
+ //\r
+ ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;\r
+ if (ExecFunc == (UINTN) NULL) {\r
+ EbcDebugSignalException (EXCEPT_EBC_INVALID_OPCODE, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ Status = EFI_UNSUPPORTED;\r
+ goto Done;\r
+ }\r
+ //\r
+ // The EBC VM is a strongly ordered processor, so perform a fence operation before\r
+ // and after each instruction is executed.\r
+ //\r
+ MemoryFence ();\r
+\r
+ mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr);\r
+\r
+ MemoryFence ();\r
+\r
+ //\r
+ // If the step flag is set, signal an exception and continue. We don't\r
+ // clear it here. Assuming the debugger is responsible for clearing it.\r
+ //\r
+ if (VMFLAG_ISSET (VmPtr, VMFLAGS_STEP)) {\r
+ EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr);\r
+ }\r
+ //\r
+ // Make sure stack has not been corrupted. Only report it once though.\r
+ //\r
+ if (!StackCorrupted && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) {\r
+ EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ StackCorrupted = 1;\r
+ }\r
+ if (!StackCorrupted && ((UINT64)VmPtr->R[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {\r
+ EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ StackCorrupted = 1;\r
+ }\r
+ }\r
+\r
+Done:\r
+ mVmPtr = NULL;\r
+\r
+ return Status;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVxx (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the MOVxx instructions.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context.\r
+\r
+Returns:\r
+\r
+ EFI_UNSUPPORTED\r
+ EFI_SUCCESS\r
+\r
+Instruction format:\r
+ \r
+ MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32}\r
+ MOVqq {@}R1 {Index64}, {@}R2 {Index64}\r
+\r
+ Copies contents of [R2] -> [R1], zero extending where required.\r
+\r
+ First character indicates the size of the move.\r
+ Second character indicates the size of the index(s).\r
+\r
+ Invalid to have R1 direct with index.\r
+ \r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 OpcMasked;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ UINT8 MoveSize;\r
+ INT16 Index16;\r
+ INT32 Index32;\r
+ INT64 Index64Op1;\r
+ INT64 Index64Op2;\r
+ UINT64 Data64;\r
+ UINT64 DataMask;\r
+ UINTN Source;\r
+\r
+ Opcode = GETOPCODE (VmPtr);\r
+ OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE);\r
+\r
+ //\r
+ // Get the operands byte so we can get R1 and R2\r
+ //\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Assume no indexes\r
+ //\r
+ Index64Op1 = 0;\r
+ Index64Op2 = 0;\r
+ Data64 = 0;\r
+\r
+ //\r
+ // Determine if we have an index/immediate data. Base instruction size\r
+ // is 2 (opcode + operands). Add to this size each index specified.\r
+ //\r
+ Size = 2;\r
+ if (Opcode & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) {\r
+ //\r
+ // Determine size of the index from the opcode. Then get it.\r
+ //\r
+ if ((OpcMasked <= OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVNW)) {\r
+ //\r
+ // MOVBW, MOVWW, MOVDW, MOVQW, and MOVNW have 16-bit immediate index.\r
+ // Get one or both index values.\r
+ //\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Index64Op1 = (INT64) Index16;\r
+ Size += sizeof (UINT16);\r
+ }\r
+\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ Index16 = VmReadIndex16 (VmPtr, Size);\r
+ Index64Op2 = (INT64) Index16;\r
+ Size += sizeof (UINT16);\r
+ }\r
+ } else if ((OpcMasked <= OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVND)) {\r
+ //\r
+ // MOVBD, MOVWD, MOVDD, MOVQD, and MOVND have 32-bit immediate index\r
+ //\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ Index32 = VmReadIndex32 (VmPtr, 2);\r
+ Index64Op1 = (INT64) Index32;\r
+ Size += sizeof (UINT32);\r
+ }\r
+\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ Index32 = VmReadIndex32 (VmPtr, Size);\r
+ Index64Op2 = (INT64) Index32;\r
+ Size += sizeof (UINT32);\r
+ }\r
+ } else if (OpcMasked == OPCODE_MOVQQ) {\r
+ //\r
+ // MOVqq -- only form with a 64-bit index\r
+ //\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ Index64Op1 = VmReadIndex64 (VmPtr, 2);\r
+ Size += sizeof (UINT64);\r
+ }\r
+\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ Index64Op2 = VmReadIndex64 (VmPtr, Size);\r
+ Size += sizeof (UINT64);\r
+ }\r
+ } else {\r
+ //\r
+ // Obsolete MOVBQ, MOVWQ, MOVDQ, and MOVNQ have 64-bit immediate index\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ }\r
+ //\r
+ // Determine the size of the move, and create a mask for it so we can\r
+ // clear unused bits.\r
+ //\r
+ if ((OpcMasked == OPCODE_MOVBW) || (OpcMasked == OPCODE_MOVBD)) {\r
+ MoveSize = DATA_SIZE_8;\r
+ DataMask = 0xFF;\r
+ } else if ((OpcMasked == OPCODE_MOVWW) || (OpcMasked == OPCODE_MOVWD)) {\r
+ MoveSize = DATA_SIZE_16;\r
+ DataMask = 0xFFFF;\r
+ } else if ((OpcMasked == OPCODE_MOVDW) || (OpcMasked == OPCODE_MOVDD)) {\r
+ MoveSize = DATA_SIZE_32;\r
+ DataMask = 0xFFFFFFFF;\r
+ } else if ((OpcMasked == OPCODE_MOVQW) || (OpcMasked == OPCODE_MOVQD) || (OpcMasked == OPCODE_MOVQQ)) {\r
+ MoveSize = DATA_SIZE_64;\r
+ DataMask = (UINT64)~0;\r
+ } else if ((OpcMasked == OPCODE_MOVNW) || (OpcMasked == OPCODE_MOVND)) {\r
+ MoveSize = DATA_SIZE_N;\r
+ DataMask = (UINT64)~0 >> (64 - 8 * sizeof (UINTN));\r
+ } else {\r
+ //\r
+ // We were dispatched to this function and we don't recognize the opcode\r
+ //\r
+ EbcDebugSignalException (EXCEPT_EBC_UNDEFINED, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Now get the source address\r
+ //\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ //\r
+ // Indirect form @R2. Compute address of operand2\r
+ //\r
+ Source = (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2);\r
+ //\r
+ // Now get the data from the source. Always 0-extend and let the compiler\r
+ // sign-extend where required.\r
+ //\r
+ switch (MoveSize) {\r
+ case DATA_SIZE_8:\r
+ Data64 = (UINT64) (UINT8) VmReadMem8 (VmPtr, Source);\r
+ break;\r
+\r
+ case DATA_SIZE_16:\r
+ Data64 = (UINT64) (UINT16) VmReadMem16 (VmPtr, Source);\r
+ break;\r
+\r
+ case DATA_SIZE_32:\r
+ Data64 = (UINT64) (UINT32) VmReadMem32 (VmPtr, Source);\r
+ break;\r
+\r
+ case DATA_SIZE_64:\r
+ Data64 = (UINT64) VmReadMem64 (VmPtr, Source);\r
+ break;\r
+\r
+ case DATA_SIZE_N:\r
+ Data64 = (UINT64) (UINTN) VmReadMemN (VmPtr, Source);\r
+ break;\r
+\r
+ default:\r
+ //\r
+ // not reached\r
+ //\r
+ break;\r
+ }\r
+ } else {\r
+ //\r
+ // Not indirect source: MOVxx {@}Rx, Ry [Index]\r
+ //\r
+ Data64 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index64Op2;\r
+ //\r
+ // Did Operand2 have an index? If so, treat as two signed values since\r
+ // indexes are signed values.\r
+ //\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ //\r
+ // NOTE: need to find a way to fix this, most likely by changing the VM\r
+ // implementation to remove the stack gap. To do that, we'd need to\r
+ // allocate stack space for the VM and actually set the system\r
+ // stack pointer to the allocated buffer when the VM starts.\r
+ //\r
+ // Special case -- if someone took the address of a function parameter\r
+ // then we need to make sure it's not in the stack gap. We can identify\r
+ // this situation if (Operand2 register == 0) && (Operand2 is direct)\r
+ // && (Index applies to Operand2) && (Index > 0) && (Operand1 register != 0)\r
+ // Situations that to be aware of:\r
+ // * stack adjustments at beginning and end of functions R0 = R0 += stacksize\r
+ //\r
+ if ((OPERAND2_REGNUM (Operands) == 0) &&\r
+ (!OPERAND2_INDIRECT (Operands)) &&\r
+ (Index64Op2 > 0) &&\r
+ (OPERAND1_REGNUM (Operands) == 0) &&\r
+ (OPERAND1_INDIRECT (Operands))\r
+ ) {\r
+ Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64);\r
+ }\r
+ }\r
+ }\r
+ //\r
+ // Now write it back\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ //\r
+ // Reuse the Source variable to now be dest.\r
+ //\r
+ Source = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index64Op1);\r
+ //\r
+ // Do the write based on the size\r
+ //\r
+ switch (MoveSize) {\r
+ case DATA_SIZE_8:\r
+ VmWriteMem8 (VmPtr, Source, (UINT8) Data64);\r
+ break;\r
+\r
+ case DATA_SIZE_16:\r
+ VmWriteMem16 (VmPtr, Source, (UINT16) Data64);\r
+ break;\r
+\r
+ case DATA_SIZE_32:\r
+ VmWriteMem32 (VmPtr, Source, (UINT32) Data64);\r
+ break;\r
+\r
+ case DATA_SIZE_64:\r
+ VmWriteMem64 (VmPtr, Source, Data64);\r
+ break;\r
+\r
+ case DATA_SIZE_N:\r
+ VmWriteMemN (VmPtr, Source, (UINTN) Data64);\r
+ break;\r
+\r
+ default:\r
+ //\r
+ // not reached\r
+ //\r
+ break;\r
+ }\r
+ } else {\r
+ //\r
+ // Operand1 direct.\r
+ // Make sure we didn't have an index on operand1.\r
+ //\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Direct storage in register. Clear unused bits and store back to\r
+ // register.\r
+ //\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteBREAK (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC BREAK instruction\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to current VM context\r
+\r
+Returns:\r
+\r
+ EFI_UNSUPPORTED\r
+ EFI_SUCCESS\r
+\r
+--*/\r
+{\r
+ UINT8 Operands;\r
+ VOID *EbcEntryPoint;\r
+ VOID *Thunk;\r
+ UINT64 U64EbcEntryPoint;\r
+ INT32 Offset;\r
+\r
+ Operands = GETOPERANDS (VmPtr);\r
+ switch (Operands) {\r
+ //\r
+ // Runaway program break. Generate an exception and terminate\r
+ //\r
+ case 0:\r
+ EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ break;\r
+\r
+ //\r
+ // Get VM version -- return VM revision number in R7\r
+ //\r
+ case 1:\r
+ //\r
+ // Bits:\r
+ // 63-17 = 0\r
+ // 16-8 = Major version\r
+ // 7-0 = Minor version\r
+ //\r
+ VmPtr->R[7] = GetVmVersion ();\r
+ break;\r
+\r
+ //\r
+ // Debugger breakpoint\r
+ //\r
+ case 3:\r
+ VmPtr->StopFlags |= STOPFLAG_BREAKPOINT;\r
+ //\r
+ // See if someone has registered a handler\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_BREAKPOINT,\r
+ EXCEPTION_FLAG_NONE,\r
+ VmPtr\r
+ );\r
+ break;\r
+\r
+ //\r
+ // System call, which there are none, so NOP it.\r
+ //\r
+ case 4:\r
+ break;\r
+\r
+ //\r
+ // Create a thunk for EBC code. R7 points to a 32-bit (in a 64-bit slot)\r
+ // "offset from self" pointer to the EBC entry point.\r
+ // After we're done, *(UINT64 *)R7 will be the address of the new thunk.\r
+ //\r
+ case 5:\r
+ Offset = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[7]);\r
+ U64EbcEntryPoint = (UINT64) (VmPtr->R[7] + Offset + 4);\r
+ EbcEntryPoint = (VOID *) (UINTN) U64EbcEntryPoint;\r
+\r
+ //\r
+ // Now create a new thunk\r
+ //\r
+ EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);\r
+\r
+ //\r
+ // Finally replace the EBC entry point memory with the thunk address\r
+ //\r
+ VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[7], (UINT64) (UINTN) Thunk);\r
+ break;\r
+\r
+ //\r
+ // Compiler setting version per value in R7\r
+ //\r
+ case 6:\r
+ VmPtr->CompilerVersion = (UINT32) VmPtr->R[7];\r
+ //\r
+ // Check compiler version against VM version?\r
+ //\r
+ break;\r
+\r
+ //\r
+ // Unhandled break code. Signal exception.\r
+ //\r
+ default:\r
+ EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ break;\r
+ }\r
+ //\r
+ // Advance IP\r
+ //\r
+ VmPtr->Ip += 2;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteJMP (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the JMP instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ JMP64{cs|cc} Immed64\r
+ JMP32{cs|cc} {@}R1 {Immed32|Index32}\r
+\r
+Encoding:\r
+ b0.7 - immediate data present\r
+ b0.6 - 1 = 64 bit immediate data\r
+ 0 = 32 bit immediate data\r
+ b1.7 - 1 = conditional\r
+ b1.6 1 = CS (condition set)\r
+ 0 = CC (condition clear)\r
+ b1.4 1 = relative address\r
+ 0 = absolute address\r
+ b1.3 1 = operand1 indirect\r
+ b1.2-0 operand 1\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 CompareSet;\r
+ UINT8 ConditionFlag;\r
+ UINT8 Size;\r
+ UINT8 Operand;\r
+ UINT64 Data64;\r
+ INT32 Index32;\r
+ UINTN Addr;\r
+\r
+ Operand = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+\r
+ //\r
+ // Get instruction length from the opcode. The upper two bits are used here\r
+ // to index into the length array.\r
+ //\r
+ Size = mJMPLen[(Opcode >> 6) & 0x03];\r
+\r
+ //\r
+ // Decode instruction conditions\r
+ // If we haven't met the condition, then simply advance the IP and return.\r
+ //\r
+ CompareSet = (UINT8) ((Operand & JMP_M_CS) ? 1 : 0);\r
+ ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
+ if (Operand & CONDITION_M_CONDITIONAL) {\r
+ if (CompareSet != ConditionFlag) {\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+ }\r
+ }\r
+ //\r
+ // Check for 64-bit form and do it right away since it's the most\r
+ // straight-forward form.\r
+ //\r
+ if (Opcode & OPCODE_M_IMMDATA64) {\r
+ //\r
+ // Double check for immediate-data, which is required. If not there,\r
+ // then signal an exception\r
+ //\r
+ if (!(Opcode & OPCODE_M_IMMDATA)) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_ERROR,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // 64-bit immediate data is full address. Read the immediate data,\r
+ // check for alignment, and jump absolute.\r
+ //\r
+ Data64 = VmReadImmed64 (VmPtr, 2);\r
+ if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ //\r
+ // Take jump -- relative or absolute\r
+ //\r
+ if (Operand & JMP_M_RELATIVE) {\r
+ VmPtr->Ip += (UINTN) Data64 + Size;\r
+ } else {\r
+ VmPtr->Ip = (VMIP) (UINTN) Data64;\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+ }\r
+ //\r
+ // 32-bit forms:\r
+ // Get the index if there is one. May be either an index, or an immediate\r
+ // offset depending on indirect operand.\r
+ // JMP32 @R1 Index32 -- immediate data is an index\r
+ // JMP32 R1 Immed32 -- immedate data is an offset\r
+ //\r
+ if (Opcode & OPCODE_M_IMMDATA) {\r
+ if (OPERAND1_INDIRECT (Operand)) {\r
+ Index32 = VmReadIndex32 (VmPtr, 2);\r
+ } else {\r
+ Index32 = VmReadImmed32 (VmPtr, 2);\r
+ }\r
+ } else {\r
+ Index32 = 0;\r
+ }\r
+ //\r
+ // Get the register data. If R == 0, then special case where it's ignored.\r
+ //\r
+ if (OPERAND1_REGNUM (Operand) == 0) {\r
+ Data64 = 0;\r
+ } else {\r
+ Data64 = OPERAND1_REGDATA (VmPtr, Operand);\r
+ }\r
+ //\r
+ // Decode the forms\r
+ //\r
+ if (OPERAND1_INDIRECT (Operand)) {\r
+ //\r
+ // Form: JMP32 @Rx {Index32}\r
+ //\r
+ Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32);\r
+ if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ if (Operand & JMP_M_RELATIVE) {\r
+ VmPtr->Ip += (UINTN) Addr + Size;\r
+ } else {\r
+ VmPtr->Ip = (VMIP) Addr;\r
+ }\r
+ } else {\r
+ //\r
+ // Form: JMP32 Rx {Immed32}\r
+ //\r
+ Addr = (UINTN) (Data64 + Index32);\r
+ if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ if (Operand & JMP_M_RELATIVE) {\r
+ VmPtr->Ip += (UINTN) Addr + Size;\r
+ } else {\r
+ VmPtr->Ip = (VMIP) Addr;\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteJMP8 (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC JMP8 instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ JMP8{cs|cc} Offset/2\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 ConditionFlag;\r
+ UINT8 CompareSet;\r
+ INT8 Offset;\r
+\r
+ //\r
+ // Decode instruction.\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ CompareSet = (UINT8) ((Opcode & JMP_M_CS) ? 1 : 0);\r
+ ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
+\r
+ //\r
+ // If we haven't met the condition, then simply advance the IP and return\r
+ //\r
+ if (Opcode & CONDITION_M_CONDITIONAL) {\r
+ if (CompareSet != ConditionFlag) {\r
+ VmPtr->Ip += 2;\r
+ return EFI_SUCCESS;\r
+ }\r
+ }\r
+ //\r
+ // Get the offset from the instruction stream. It's relative to the\r
+ // following instruction, and divided by 2.\r
+ //\r
+ Offset = VmReadImmed8 (VmPtr, 1);\r
+ //\r
+ // Want to check for offset == -2 and then raise an exception?\r
+ //\r
+ VmPtr->Ip += (Offset * 2) + 2;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVI (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MOVI \r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+\r
+ MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
+\r
+ First variable character specifies the move size\r
+ Second variable character specifies size of the immediate data\r
+\r
+ Sign-extend the immediate data to the size of the operation, and zero-extend\r
+ if storing to a register.\r
+\r
+ Operand1 direct with index/immed is invalid.\r
+ \r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT16 Index16;\r
+ INT64 ImmData64;\r
+ UINT64 Op1;\r
+ UINT64 Mask64;\r
+\r
+ //\r
+ // Get the opcode and operands byte so we can get R1 and R2\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Get the index (16-bit) if present\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Size = 4;\r
+ } else {\r
+ Index16 = 0;\r
+ Size = 2;\r
+ }\r
+ //\r
+ // Extract the immediate data. Sign-extend always.\r
+ //\r
+ if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {\r
+ ImmData64 = (INT64) (INT16) VmReadImmed16 (VmPtr, Size);\r
+ Size += 2;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {\r
+ ImmData64 = (INT64) (INT32) VmReadImmed32 (VmPtr, Size);\r
+ Size += 4;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {\r
+ ImmData64 = (INT64) VmReadImmed64 (VmPtr, Size);\r
+ Size += 8;\r
+ } else {\r
+ //\r
+ // Invalid encoding\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Now write back the result\r
+ //\r
+ if (!OPERAND1_INDIRECT (Operands)) {\r
+ //\r
+ // Operand1 direct. Make sure it didn't have an index.\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Writing directly to a register. Clear unused bits.\r
+ //\r
+ if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {\r
+ Mask64 = 0x000000FF;\r
+ } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {\r
+ Mask64 = 0x0000FFFF;\r
+ } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {\r
+ Mask64 = 0x00000000FFFFFFFF;\r
+ } else {\r
+ Mask64 = (UINT64)~0;\r
+ }\r
+\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64;\r
+ } else {\r
+ //\r
+ // Get the address then write back based on size of the move\r
+ //\r
+ Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {\r
+ VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64);\r
+ } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {\r
+ VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64);\r
+ } else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {\r
+ VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64);\r
+ } else {\r
+ VmWriteMem64 (VmPtr, (UINTN) Op1, ImmData64);\r
+ }\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVIn (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MOV immediate natural. This instruction moves an immediate\r
+ index value into a register or memory location.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+\r
+ MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT16 Index16;\r
+ INT16 ImmedIndex16;\r
+ INT32 ImmedIndex32;\r
+ INT64 ImmedIndex64;\r
+ UINT64 Op1;\r
+\r
+ //\r
+ // Get the opcode and operands byte so we can get R1 and R2\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Get the operand1 index (16-bit) if present\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Size = 4;\r
+ } else {\r
+ Index16 = 0;\r
+ Size = 2;\r
+ }\r
+ //\r
+ // Extract the immediate data and convert to a 64-bit index.\r
+ //\r
+ if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {\r
+ ImmedIndex16 = VmReadIndex16 (VmPtr, Size);\r
+ ImmedIndex64 = (INT64) ImmedIndex16;\r
+ Size += 2;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {\r
+ ImmedIndex32 = VmReadIndex32 (VmPtr, Size);\r
+ ImmedIndex64 = (INT64) ImmedIndex32;\r
+ Size += 4;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {\r
+ ImmedIndex64 = VmReadIndex64 (VmPtr, Size);\r
+ Size += 8;\r
+ } else {\r
+ //\r
+ // Invalid encoding\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Now write back the result\r
+ //\r
+ if (!OPERAND1_INDIRECT (Operands)) {\r
+ //\r
+ // Check for MOVIn R1 Index16, Immed (not indirect, with index), which\r
+ // is illegal\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmedIndex64;\r
+ } else {\r
+ //\r
+ // Get the address\r
+ //\r
+ Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ VmWriteMemN (VmPtr, (UINTN) Op1, (INTN) ImmedIndex64);\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVREL (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MOVREL instruction.\r
+ Dest <- Ip + ImmData\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+\r
+ MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT16 Index16;\r
+ INT64 ImmData64;\r
+ UINT64 Op1;\r
+ UINT64 Op2;\r
+\r
+ //\r
+ // Get the opcode and operands byte so we can get R1 and R2\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Get the Operand 1 index (16-bit) if present\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Size = 4;\r
+ } else {\r
+ Index16 = 0;\r
+ Size = 2;\r
+ }\r
+ //\r
+ // Get the immediate data.\r
+ //\r
+ if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH16) {\r
+ ImmData64 = (INT64) VmReadImmed16 (VmPtr, Size);\r
+ Size += 2;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH32) {\r
+ ImmData64 = (INT64) VmReadImmed32 (VmPtr, Size);\r
+ Size += 4;\r
+ } else if ((Opcode & MOVI_M_DATAWIDTH) == MOVI_DATAWIDTH64) {\r
+ ImmData64 = VmReadImmed64 (VmPtr, Size);\r
+ Size += 8;\r
+ } else {\r
+ //\r
+ // Invalid encoding\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ //\r
+ // Compute the value and write back the result\r
+ //\r
+ Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size);\r
+ if (!OPERAND1_INDIRECT (Operands)) {\r
+ //\r
+ // Check for illegal combination of operand1 direct with immediate data\r
+ //\r
+ if (Operands & MOVI_M_IMMDATA) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2;\r
+ } else {\r
+ //\r
+ // Get the address = [Rx] + Index16\r
+ // Write back the result. Always a natural size write, since\r
+ // we're talking addresses here.\r
+ //\r
+ Op1 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2);\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVsnw (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MOVsnw instruction. This instruction loads a signed \r
+ natural value from memory or register to another memory or register. On\r
+ 32-bit machines, the value gets sign-extended to 64 bits if the destination\r
+ is a register.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+\r
+ MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16}\r
+\r
+ 0:7 1=>operand1 index present\r
+ 0:6 1=>operand2 index present\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT16 Op1Index;\r
+ INT16 Op2Index;\r
+ UINT64 Op2;\r
+\r
+ //\r
+ // Get the opcode and operand bytes\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ Op1Index = Op2Index = 0;\r
+\r
+ //\r
+ // Get the indexes if present.\r
+ //\r
+ Size = 2;\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Op1Index = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ //\r
+ // Illegal form operand1 direct with index: MOVsnw R1 Index16, {@}R2\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ Size += sizeof (UINT16);\r
+ }\r
+\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Op2Index = VmReadIndex16 (VmPtr, Size);\r
+ } else {\r
+ Op2Index = VmReadImmed16 (VmPtr, Size);\r
+ }\r
+\r
+ Size += sizeof (UINT16);\r
+ }\r
+ //\r
+ // Get the data from the source.\r
+ //\r
+ Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index));\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2);\r
+ }\r
+ //\r
+ // Now write back the result.\r
+ //\r
+ if (!OPERAND1_INDIRECT (Operands)) {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2;\r
+ } else {\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteMOVsnd (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MOVsnw instruction. This instruction loads a signed \r
+ natural value from memory or register to another memory or register. On\r
+ 32-bit machines, the value gets sign-extended to 64 bits if the destination\r
+ is a register.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+\r
+ MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32}\r
+\r
+ 0:7 1=>operand1 index present\r
+ 0:6 1=>operand2 index present\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT32 Op1Index;\r
+ INT32 Op2Index;\r
+ UINT64 Op2;\r
+\r
+ //\r
+ // Get the opcode and operand bytes\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ Op1Index = Op2Index = 0;\r
+\r
+ //\r
+ // Get the indexes if present.\r
+ //\r
+ Size = 2;\r
+ if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Op1Index = VmReadIndex32 (VmPtr, 2);\r
+ } else {\r
+ //\r
+ // Illegal form operand1 direct with index: MOVsnd R1 Index16,..\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ Size += sizeof (UINT32);\r
+ }\r
+\r
+ if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Op2Index = VmReadIndex32 (VmPtr, Size);\r
+ } else {\r
+ Op2Index = VmReadImmed32 (VmPtr, Size);\r
+ }\r
+\r
+ Size += sizeof (UINT32);\r
+ }\r
+ //\r
+ // Get the data from the source.\r
+ //\r
+ Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index));\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2);\r
+ }\r
+ //\r
+ // Now write back the result.\r
+ //\r
+ if (!OPERAND1_INDIRECT (Operands)) {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2;\r
+ } else {\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePUSHn (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC PUSHn instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ PUSHn {@}R1 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ INT16 Index16;\r
+ UINTN DataN;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Get index if present\r
+ //\r
+ if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ VmPtr->Ip += 4;\r
+ } else {\r
+ Index16 = 0;\r
+ VmPtr->Ip += 2;\r
+ }\r
+ //\r
+ // Get the data to push\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ } else {\r
+ DataN = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16);\r
+ }\r
+ //\r
+ // Adjust the stack down.\r
+ //\r
+ VmPtr->R[0] -= sizeof (UINTN);\r
+ VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], DataN);\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePUSH (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC PUSH instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ PUSH[32|64] {@}R1 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT32 Data32;\r
+ UINT64 Data64;\r
+ INT16 Index16;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+ //\r
+ // Get immediate index if present, then advance the IP.\r
+ //\r
+ if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ VmPtr->Ip += 4;\r
+ } else {\r
+ Index16 = 0;\r
+ VmPtr->Ip += 2;\r
+ }\r
+ //\r
+ // Get the data to push\r
+ //\r
+ if (Opcode & PUSHPOP_M_64) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ } else {\r
+ Data64 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ }\r
+ //\r
+ // Adjust the stack down, then write back the data\r
+ //\r
+ VmPtr->R[0] -= sizeof (UINT64);\r
+ VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], Data64);\r
+ } else {\r
+ //\r
+ // 32-bit data\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ } else {\r
+ Data32 = (UINT32) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ }\r
+ //\r
+ // Adjust the stack down and write the data\r
+ //\r
+ VmPtr->R[0] -= sizeof (UINT32);\r
+ VmWriteMem32 (VmPtr, (UINTN) VmPtr->R[0], Data32);\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePOPn (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC POPn instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ POPn {@}R1 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ INT16 Index16;\r
+ UINTN DataN;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+ //\r
+ // Get immediate data if present, and advance the IP\r
+ //\r
+ if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ VmPtr->Ip += 4;\r
+ } else {\r
+ Index16 = 0;\r
+ VmPtr->Ip += 2;\r
+ }\r
+ //\r
+ // Read the data off the stack, then adjust the stack pointer\r
+ //\r
+ DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]);\r
+ VmPtr->R[0] += sizeof (UINTN);\r
+ //\r
+ // Do the write-back\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), DataN);\r
+ } else {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) ((UINTN) DataN + Index16);\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecutePOP (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC POP instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ POP {@}R1 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ INT16 Index16;\r
+ INT32 Data32;\r
+ UINT64 Data64;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+ //\r
+ // Get immediate data if present, and advance the IP.\r
+ //\r
+ if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ VmPtr->Ip += 4;\r
+ } else {\r
+ Index16 = 0;\r
+ VmPtr->Ip += 2;\r
+ }\r
+ //\r
+ // Get the data off the stack, then write it to the appropriate location\r
+ //\r
+ if (Opcode & PUSHPOP_M_64) {\r
+ //\r
+ // Read the data off the stack, then adjust the stack pointer\r
+ //\r
+ Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]);\r
+ VmPtr->R[0] += sizeof (UINT64);\r
+ //\r
+ // Do the write-back\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ VmWriteMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data64);\r
+ } else {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 + Index16;\r
+ }\r
+ } else {\r
+ //\r
+ // 32-bit pop. Read it off the stack and adjust the stack pointer\r
+ //\r
+ Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->R[0]);\r
+ VmPtr->R[0] += sizeof (UINT32);\r
+ //\r
+ // Do the write-back\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ VmWriteMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16), Data32);\r
+ } else {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCALL (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Implements the EBC CALL instruction.\r
+\r
+ Instruction format: \r
+\r
+ CALL64 Immed64\r
+ CALL32 {@}R1 {Immed32|Index32}\r
+ CALLEX64 Immed64\r
+ CALLEX16 {@}R1 {Immed32}\r
+\r
+ If Rx == R0, then it's a PC relative call to PC = PC + imm32.\r
+ \r
+Arguments:\r
+ VmPtr - pointer to a VM context.\r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ INT32 Immed32;\r
+ UINT8 Size;\r
+ INT64 Immed64;\r
+ VOID *FramePtr;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+ //\r
+ // Assign these as well to avoid compiler warnings\r
+ //\r
+ Immed64 = 0;\r
+ Immed32 = 0;\r
+\r
+ FramePtr = VmPtr->FramePtr;\r
+ //\r
+ // Determine the instruction size, and get immediate data if present\r
+ //\r
+ if (Opcode & OPCODE_M_IMMDATA) {\r
+ if (Opcode & OPCODE_M_IMMDATA64) {\r
+ Immed64 = VmReadImmed64 (VmPtr, 2);\r
+ Size = 10;\r
+ } else {\r
+ //\r
+ // If register operand is indirect, then the immediate data is an index\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Immed32 = VmReadIndex32 (VmPtr, 2);\r
+ } else {\r
+ Immed32 = VmReadImmed32 (VmPtr, 2);\r
+ }\r
+\r
+ Size = 6;\r
+ }\r
+ } else {\r
+ Size = 2;\r
+ }\r
+ //\r
+ // If it's a call to EBC, adjust the stack pointer down 16 bytes and\r
+ // put our return address and frame pointer on the VM stack.\r
+ //\r
+ if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {\r
+ VmPtr->R[0] -= 8;\r
+ VmWriteMemN (VmPtr, (UINTN) VmPtr->R[0], (UINTN) FramePtr);\r
+ VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->R[0];\r
+ VmPtr->R[0] -= 8;\r
+ VmWriteMem64 (VmPtr, (UINTN) VmPtr->R[0], (UINT64) (UINTN) (VmPtr->Ip + Size));\r
+ }\r
+ //\r
+ // If 64-bit data, then absolute jump only\r
+ //\r
+ if (Opcode & OPCODE_M_IMMDATA64) {\r
+ //\r
+ // Native or EBC call?\r
+ //\r
+ if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {\r
+ VmPtr->Ip = (VMIP) (UINTN) Immed64;\r
+ } else {\r
+ //\r
+ // Call external function, get the return value, and advance the IP\r
+ //\r
+ EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size);\r
+ }\r
+ } else {\r
+ //\r
+ // Get the register data. If operand1 == 0, then ignore register and\r
+ // take immediate data as relative or absolute address.\r
+ // Compiler should take care of upper bits if 32-bit machine.\r
+ //\r
+ if (OPERAND1_REGNUM (Operands) != 0) {\r
+ Immed64 = (UINT64) (UINTN) VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ }\r
+ //\r
+ // Get final address\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32));\r
+ } else {\r
+ Immed64 += Immed32;\r
+ }\r
+ //\r
+ // Now determine if external call, and then if relative or absolute\r
+ //\r
+ if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {\r
+ //\r
+ // EBC call. Relative or absolute? If relative, then it's relative to the\r
+ // start of the next instruction.\r
+ //\r
+ if (Operands & OPERAND_M_RELATIVE_ADDR) {\r
+ VmPtr->Ip += Immed64 + Size;\r
+ } else {\r
+ VmPtr->Ip = (VMIP) (UINTN) Immed64;\r
+ }\r
+ } else {\r
+ //\r
+ // Native call. Relative or absolute?\r
+ //\r
+ if (Operands & OPERAND_M_RELATIVE_ADDR) {\r
+ EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->R[0], FramePtr, Size);\r
+ } else {\r
+ if (VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) {\r
+ CpuBreakpoint ();\r
+ }\r
+\r
+ EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size);\r
+ }\r
+ }\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteRET (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC RET instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ RET\r
+\r
+--*/\r
+{\r
+ //\r
+ // If we're at the top of the stack, then simply set the done\r
+ // flag and return\r
+ //\r
+ if (VmPtr->StackRetAddr == (UINT64) VmPtr->R[0]) {\r
+ VmPtr->StopFlags |= STOPFLAG_APP_DONE;\r
+ } else {\r
+ //\r
+ // Pull the return address off the VM app's stack and set the IP\r
+ // to it\r
+ //\r
+ if (!IS_ALIGNED ((UINTN) VmPtr->R[0], sizeof (UINT16))) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ }\r
+ //\r
+ // Restore the IP and frame pointer from the stack\r
+ //\r
+ VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->R[0]);\r
+ VmPtr->R[0] += 8;\r
+ VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->R[0]);\r
+ VmPtr->R[0] += 8;\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCMP (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC CMP instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ CMP[32|64][eq|lte|gte|ulte|ugte] R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT16 Index16;\r
+ UINT32 Flag;\r
+ INT64 Op2;\r
+ INT64 Op1;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+ //\r
+ // Get the register data we're going to compare to\r
+ //\r
+ Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ //\r
+ // Get immediate data\r
+ //\r
+ if (Opcode & OPCODE_M_IMMDATA) {\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ Size = 4;\r
+ } else {\r
+ Index16 = 0;\r
+ Size = 2;\r
+ }\r
+ //\r
+ // Now get Op2\r
+ //\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ if (Opcode & OPCODE_M_64BIT) {\r
+ Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16));\r
+ } else {\r
+ //\r
+ // 32-bit operations. 0-extend the values for all cases.\r
+ //\r
+ Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16)));\r
+ }\r
+ } else {\r
+ Op2 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16;\r
+ }\r
+ //\r
+ // Now do the compare\r
+ //\r
+ Flag = 0;\r
+ if (Opcode & OPCODE_M_64BIT) {\r
+ //\r
+ // 64-bit compares\r
+ //\r
+ switch (Opcode & OPCODE_M_OPCODE) {\r
+ case OPCODE_CMPEQ:\r
+ if (Op1 == Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPLTE:\r
+ if (Op1 <= Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPGTE:\r
+ if (Op1 >= Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPULTE:\r
+ if ((UINT64) Op1 <= (UINT64) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPUGTE:\r
+ if ((UINT64) Op1 >= (UINT64) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
+ }\r
+ } else {\r
+ //\r
+ // 32-bit compares\r
+ //\r
+ switch (Opcode & OPCODE_M_OPCODE) {\r
+ case OPCODE_CMPEQ:\r
+ if ((INT32) Op1 == (INT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPLTE:\r
+ if ((INT32) Op1 <= (INT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPGTE:\r
+ if ((INT32) Op1 >= (INT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPULTE:\r
+ if ((UINT32) Op1 <= (UINT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPUGTE:\r
+ if ((UINT32) Op1 >= (UINT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
+ }\r
+ }\r
+ //\r
+ // Now set the flag accordingly for the comparison\r
+ //\r
+ if (Flag) {\r
+ VMFLAG_SET (VmPtr, VMFLAGS_CC);\r
+ } else {\r
+ VMFLAG_CLEAR (VmPtr, VMFLAGS_CC);\r
+ }\r
+ //\r
+ // Advance the IP\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteCMPI (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC CMPI instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ CMPI[32|64]{w|d}[eq|lte|gte|ulte|ugte] {@}Rx {Index16}, Immed16|Immed32\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ INT64 Op1;\r
+ INT64 Op2;\r
+ INT16 Index16;\r
+ UINT32 Flag;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Get operand1 index if present\r
+ //\r
+ Size = 2;\r
+ if (Operands & OPERAND_M_CMPI_INDEX) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Size += 2;\r
+ } else {\r
+ Index16 = 0;\r
+ }\r
+ //\r
+ // Get operand1 data we're going to compare to\r
+ //\r
+ Op1 = (INT64) VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ //\r
+ // Indirect operand1. Fetch 32 or 64-bit value based on compare size.\r
+ //\r
+ if (Opcode & OPCODE_M_CMPI64) {\r
+ Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16);\r
+ } else {\r
+ Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16);\r
+ }\r
+ } else {\r
+ //\r
+ // Better not have been an index with direct. That is, CMPI R1 Index,...\r
+ // is illegal.\r
+ //\r
+ if (Operands & OPERAND_M_CMPI_INDEX) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_ERROR,\r
+ VmPtr\r
+ );\r
+ VmPtr->Ip += Size;\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+ }\r
+ //\r
+ // Get immediate data -- 16- or 32-bit sign extended\r
+ //\r
+ if (Opcode & OPCODE_M_CMPI32_DATA) {\r
+ Op2 = (INT64) VmReadImmed32 (VmPtr, Size);\r
+ Size += 4;\r
+ } else {\r
+ //\r
+ // 16-bit immediate data. Sign extend always.\r
+ //\r
+ Op2 = (INT64) ((INT16) VmReadImmed16 (VmPtr, Size));\r
+ Size += 2;\r
+ }\r
+ //\r
+ // Now do the compare\r
+ //\r
+ Flag = 0;\r
+ if (Opcode & OPCODE_M_CMPI64) {\r
+ //\r
+ // 64 bit comparison\r
+ //\r
+ switch (Opcode & OPCODE_M_OPCODE) {\r
+ case OPCODE_CMPIEQ:\r
+ if (Op1 == (INT64) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPILTE:\r
+ if (Op1 <= (INT64) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIGTE:\r
+ if (Op1 >= (INT64) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIULTE:\r
+ if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIUGTE:\r
+ if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
+ }\r
+ } else {\r
+ //\r
+ // 32-bit comparisons\r
+ //\r
+ switch (Opcode & OPCODE_M_OPCODE) {\r
+ case OPCODE_CMPIEQ:\r
+ if ((INT32) Op1 == Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPILTE:\r
+ if ((INT32) Op1 <= Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIGTE:\r
+ if ((INT32) Op1 >= Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIULTE:\r
+ if ((UINT32) Op1 <= (UINT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ case OPCODE_CMPIUGTE:\r
+ if ((UINT32) Op1 >= (UINT32) Op2) {\r
+ Flag = 1;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
+ }\r
+ }\r
+ //\r
+ // Now set the flag accordingly for the comparison\r
+ //\r
+ if (Flag) {\r
+ VMFLAG_SET (VmPtr, VMFLAGS_CC);\r
+ } else {\r
+ VMFLAG_CLEAR (VmPtr, VMFLAGS_CC);\r
+ }\r
+ //\r
+ // Advance the IP\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteNOT (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC NOT instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ ~Op2\r
+\r
+Instruction syntax:\r
+ NOT[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+ \r
+--*/\r
+{\r
+ return ~Op2;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteNEG (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC NEG instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op2 * -1\r
+\r
+Instruction syntax:\r
+ NEG[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ return ~Op2 + 1;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteADD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC ADD instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 + Op2\r
+\r
+Instruction syntax:\r
+ ADD[32|64] {@}R1, {@}R2 {Index16}\r
+\r
+--*/\r
+{\r
+ return Op1 + Op2;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSUB (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC SUB instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 - Op2\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ SUB[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2));\r
+ } else {\r
+ return (UINT64) ((INT64) ((INT32) Op1 - (INT32) Op2));\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMUL (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC MUL instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 * Op2\r
+\r
+Instruction syntax:\r
+ MUL[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return MultS64x64 ((INT64)Op1, (INT64)Op2);\r
+ } else {\r
+ return (UINT64) ((INT64) ((INT32) Op1 * (INT32) Op2));\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMULU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC MULU instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ (unsigned)Op1 * (unsigned)Op2 \r
+\r
+Instruction syntax:\r
+ MULU[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return MultU64x64 (Op1, Op2);\r
+ } else {\r
+ return (UINT64) ((UINT32) Op1 * (UINT32) Op2);\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteDIV (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC DIV instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1/Op2\r
+\r
+Instruction syntax:\r
+ DIV[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ INT64 Remainder;\r
+\r
+ //\r
+ // Check for divide-by-0\r
+ //\r
+ if (Op2 == 0) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_DIVIDE_ERROR,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+\r
+ return 0;\r
+ } else {\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder));\r
+ } else {\r
+ return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2));\r
+ }\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteDIVU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC DIVU instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ (unsigned)Op1 / (unsigned)Op2\r
+\r
+Instruction syntax:\r
+ DIVU[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ UINT64 Remainder;\r
+\r
+ //\r
+ // Check for divide-by-0\r
+ //\r
+ if (Op2 == 0) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_DIVIDE_ERROR,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return 0;\r
+ } else {\r
+ //\r
+ // Get the destination register\r
+ //\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return (UINT64) (DivU64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder));\r
+ } else {\r
+ return (UINT64) ((UINT32) Op1 / (UINT32) Op2);\r
+ }\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMOD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC MOD instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 MODULUS Op2\r
+\r
+Instruction syntax:\r
+ MOD[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ INT64 Remainder;\r
+\r
+ //\r
+ // Check for divide-by-0\r
+ //\r
+ if (Op2 == 0) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_DIVIDE_ERROR,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return 0;\r
+ } else {\r
+ DivS64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder);\r
+ return Remainder;\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteMODU (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC MODU instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 UNSIGNED_MODULUS Op2\r
+\r
+Instruction syntax:\r
+ MODU[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+ \r
+--*/\r
+{\r
+ UINT64 Remainder;\r
+\r
+ //\r
+ // Check for divide-by-0\r
+ //\r
+ if (Op2 == 0) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_DIVIDE_ERROR,\r
+ EXCEPTION_FLAG_FATAL,\r
+ VmPtr\r
+ );\r
+ return 0;\r
+ } else {\r
+ DivU64x64Remainder (Op1, Op2, &Remainder);\r
+ return Remainder;\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteAND (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC AND instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 AND Op2\r
+\r
+Instruction syntax:\r
+ AND[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ return Op1 & Op2;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteOR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC OR instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 OR Op2\r
+\r
+Instruction syntax:\r
+ OR[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ return Op1 | Op2;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteXOR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC XOR instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 XOR Op2\r
+\r
+Instruction syntax:\r
+ XOR[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ return Op1 ^ Op2;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSHL (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ Execute the EBC SHL shift left instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 << Op2\r
+\r
+Instruction syntax:\r
+ SHL[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return LShiftU64 (Op1, (UINTN)Op2);\r
+ } else {\r
+ return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2));\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteSHR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC SHR instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 >> Op2 (unsigned operands)\r
+\r
+Instruction syntax:\r
+ SHR[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return RShiftU64 (Op1, (UINTN)Op2);\r
+ } else {\r
+ return (UINT64) ((UINT32) Op1 >> (UINT32) Op2);\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteASHR (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC ASHR instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ Op1 >> Op2 (signed)\r
+\r
+Instruction syntax:\r
+ ASHR[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+--*/\r
+{\r
+ if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ return ARShiftU64 (Op1, (UINTN)Op2);\r
+ } else {\r
+ return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2));\r
+ }\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDB (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC EXTNDB instruction to sign-extend a byte value.\r
+ \r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ (INT64)(INT8)Op2\r
+\r
+Instruction syntax:\r
+ EXTNDB[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+ \r
+--*/\r
+{\r
+ INT8 Data8;\r
+ INT64 Data64;\r
+ //\r
+ // Convert to byte, then return as 64-bit signed value to let compiler\r
+ // sign-extend the value\r
+ //\r
+ Data8 = (INT8) Op2;\r
+ Data64 = (INT64) Data8;\r
+\r
+ return (UINT64) Data64;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDW (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC EXTNDW instruction to sign-extend a 16-bit value.\r
+ \r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ (INT64)(INT16)Op2\r
+\r
+Instruction syntax:\r
+ EXTNDW[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+ \r
+--*/\r
+{\r
+ INT16 Data16;\r
+ INT64 Data64;\r
+ //\r
+ // Convert to word, then return as 64-bit signed value to let compiler\r
+ // sign-extend the value\r
+ //\r
+ Data16 = (INT16) Op2;\r
+ Data64 = (INT64) Data16;\r
+\r
+ return (UINT64) Data64;\r
+}\r
+//\r
+// Execute the EBC EXTNDD instruction.\r
+//\r
+// Format: EXTNDD {@}Rx, {@}Ry [Index16|Immed16]\r
+// EXTNDD Dest, Source\r
+//\r
+// Operation: Dest <- SignExtended((DWORD)Source))\r
+//\r
+STATIC\r
+UINT64\r
+ExecuteEXTNDD (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC EXTNDD instruction to sign-extend a 32-bit value.\r
+ \r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Op1 - Operand 1 from the instruction \r
+ Op2 - Operand 2 from the instruction\r
+\r
+Returns:\r
+ (INT64)(INT32)Op2\r
+\r
+Instruction syntax:\r
+ EXTNDD[32|64] {@}R1, {@}R2 {Index16|Immed16}\r
+\r
+ \r
+--*/\r
+{\r
+ INT32 Data32;\r
+ INT64 Data64;\r
+ //\r
+ // Convert to 32-bit value, then return as 64-bit signed value to let compiler\r
+ // sign-extend the value\r
+ //\r
+ Data32 = (INT32) Op2;\r
+ Data64 = (INT64) Data32;\r
+\r
+ return (UINT64) Data64;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteSignedDataManip (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+{\r
+ //\r
+ // Just call the data manipulation function with a flag indicating this\r
+ // is a signed operation.\r
+ //\r
+ return ExecuteDataManip (VmPtr, TRUE);\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteUnsignedDataManip (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+{\r
+ //\r
+ // Just call the data manipulation function with a flag indicating this\r
+ // is not a signed operation.\r
+ //\r
+ return ExecuteDataManip (VmPtr, FALSE);\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteDataManip (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN BOOLEAN IsSignedOp\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute all the EBC data manipulation instructions. \r
+ Since the EBC data manipulation instructions all have the same basic form, \r
+ they can share the code that does the fetch of operands and the write-back\r
+ of the result. This function performs the fetch of the operands (even if\r
+ both are not needed to be fetched, like NOT instruction), dispatches to the\r
+ appropriate subfunction, then writes back the returned result.\r
+\r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+\r
+Returns:\r
+ Standard EBC status\r
+\r
+Format: \r
+ INSTRUCITON[32|64] {@}R1, {@}R2 {Immed16|Index16}\r
+\r
+--*/\r
+{\r
+ UINT8 Opcode;\r
+ INT16 Index16;\r
+ UINT8 Operands;\r
+ UINT8 Size;\r
+ UINT64 Op1;\r
+ UINT64 Op2;\r
+\r
+ //\r
+ // Get opcode and operands\r
+ //\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Determine if we have immediate data by the opcode\r
+ //\r
+ if (Opcode & DATAMANIP_M_IMMDATA) {\r
+ //\r
+ // Index16 if Ry is indirect, or Immed16 if Ry direct.\r
+ //\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ } else {\r
+ Index16 = VmReadImmed16 (VmPtr, 2);\r
+ }\r
+\r
+ Size = 4;\r
+ } else {\r
+ Index16 = 0;\r
+ Size = 2;\r
+ }\r
+ //\r
+ // Now get operand2 (source). It's of format {@}R2 {Index16|Immed16}\r
+ //\r
+ Op2 = (UINT64) VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16;\r
+ if (OPERAND2_INDIRECT (Operands)) {\r
+ //\r
+ // Indirect form: @R2 Index16. Fetch as 32- or 64-bit data\r
+ //\r
+ if (Opcode & DATAMANIP_M_64) {\r
+ Op2 = VmReadMem64 (VmPtr, (UINTN) Op2);\r
+ } else {\r
+ //\r
+ // Read as signed value where appropriate.\r
+ //\r
+ if (IsSignedOp) {\r
+ Op2 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op2));\r
+ } else {\r
+ Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2);\r
+ }\r
+ }\r
+ } else {\r
+ if ((Opcode & DATAMANIP_M_64) == 0) {\r
+ if (IsSignedOp) {\r
+ Op2 = (UINT64) (INT64) ((INT32) Op2);\r
+ } else {\r
+ Op2 = (UINT64) ((UINT32) Op2);\r
+ }\r
+ }\r
+ }\r
+ //\r
+ // Get operand1 (destination and sometimes also an actual operand)\r
+ // of form {@}R1\r
+ //\r
+ Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ if (Opcode & DATAMANIP_M_64) {\r
+ Op1 = VmReadMem64 (VmPtr, (UINTN) Op1);\r
+ } else {\r
+ if (IsSignedOp) {\r
+ Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1));\r
+ } else {\r
+ Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1);\r
+ }\r
+ }\r
+ } else {\r
+ if ((Opcode & DATAMANIP_M_64) == 0) {\r
+ if (IsSignedOp) {\r
+ Op1 = (UINT64) (INT64) ((INT32) Op1);\r
+ } else {\r
+ Op1 = (UINT64) ((UINT32) Op1);\r
+ }\r
+ }\r
+ }\r
+ //\r
+ // Dispatch to the computation function\r
+ //\r
+ if (((Opcode & OPCODE_M_OPCODE) - OPCODE_NOT) >=\r
+ (sizeof (mDataManipDispatchTable) / sizeof (mDataManipDispatchTable[0]))\r
+ ) {\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INVALID_OPCODE,\r
+ EXCEPTION_FLAG_ERROR,\r
+ VmPtr\r
+ );\r
+ //\r
+ // Advance and return\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_UNSUPPORTED;\r
+ } else {\r
+ Op2 = mDataManipDispatchTable[(Opcode & OPCODE_M_OPCODE) - OPCODE_NOT](VmPtr, Op1, Op2);\r
+ }\r
+ //\r
+ // Write back the result.\r
+ //\r
+ if (OPERAND1_INDIRECT (Operands)) {\r
+ Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ if (Opcode & DATAMANIP_M_64) {\r
+ VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);\r
+ } else {\r
+ VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);\r
+ }\r
+ } else {\r
+ //\r
+ // Storage back to a register. Write back, clearing upper bits (as per\r
+ // the specification) if 32-bit operation.\r
+ //\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = Op2;\r
+ if ((Opcode & DATAMANIP_M_64) == 0) {\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF;\r
+ }\r
+ }\r
+ //\r
+ // Advance the instruction pointer\r
+ //\r
+ VmPtr->Ip += Size;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteLOADSP (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC LOADSP instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ LOADSP SP1, R2\r
+\r
+--*/\r
+{\r
+ UINT8 Operands;\r
+\r
+ //\r
+ // Get the operands\r
+ //\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Do the operation\r
+ //\r
+ switch (OPERAND1_REGNUM (Operands)) {\r
+ //\r
+ // Set flags\r
+ //\r
+ case 0:\r
+ //\r
+ // Spec states that this instruction will not modify reserved bits in\r
+ // the flags register.\r
+ //\r
+ VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->R[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);\r
+ break;\r
+\r
+ default:\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_WARNING,\r
+ VmPtr\r
+ );\r
+ VmPtr->Ip += 2;\r
+ return EFI_UNSUPPORTED;\r
+ }\r
+\r
+ VmPtr->Ip += 2;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+ExecuteSTORESP (\r
+ IN VM_CONTEXT *VmPtr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Execute the EBC STORESP instruction\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+\r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+Instruction syntax:\r
+ STORESP Rx, FLAGS|IP\r
+\r
+--*/\r
+{\r
+ UINT8 Operands;\r
+\r
+ //\r
+ // Get the operands\r
+ //\r
+ Operands = GETOPERANDS (VmPtr);\r
+\r
+ //\r
+ // Do the operation\r
+ //\r
+ switch (OPERAND2_REGNUM (Operands)) {\r
+ //\r
+ // Get flags\r
+ //\r
+ case 0:\r
+ //\r
+ // Retrieve the value in the flags register, then clear reserved bits\r
+ //\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID);\r
+ break;\r
+\r
+ //\r
+ // Get IP -- address of following instruction\r
+ //\r
+ case 1:\r
+ VmPtr->R[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;\r
+ break;\r
+\r
+ default:\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_INSTRUCTION_ENCODING,\r
+ EXCEPTION_FLAG_WARNING,\r
+ VmPtr\r
+ );\r
+ VmPtr->Ip += 2;\r
+ return EFI_UNSUPPORTED;\r
+ break;\r
+ }\r
+\r
+ VmPtr->Ip += 2;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+INT16\r
+VmReadIndex16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Decode a 16-bit index to determine the offset. Given an index value:\r
+\r
+ b15 - sign bit\r
+ b14:12 - number of bits in this index assigned to natural units (=a)\r
+ ba:11 - constant units = C\r
+ b0:a - natural units = N\r
+ \r
+ Given this info, the offset can be computed by:\r
+ offset = sign_bit * (C + N * sizeof(UINTN))\r
+\r
+ Max offset is achieved with index = 0x7FFF giving an offset of\r
+ 0x27B (32-bit machine) or 0x477 (64-bit machine).\r
+ Min offset is achieved with index = \r
+ \r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+ CodeOffset - offset from IP of the location of the 16-bit index to decode\r
+\r
+Returns:\r
+ The decoded offset.\r
+ \r
+--*/\r
+{\r
+ UINT16 Index;\r
+ INT16 Offset;\r
+ INT16 C;\r
+ INT16 N;\r
+ INT16 NBits;\r
+ INT16 Mask;\r
+\r
+ //\r
+ // First read the index from the code stream\r
+ //\r
+ Index = VmReadCode16 (VmPtr, CodeOffset);\r
+\r
+ //\r
+ // Get the mask for N. First get the number of bits from the index.\r
+ //\r
+ NBits = (INT16) ((Index & 0x7000) >> 12);\r
+\r
+ //\r
+ // Scale it for 16-bit indexes\r
+ //\r
+ NBits *= 2;\r
+\r
+ //\r
+ // Now using the number of bits, create a mask.\r
+ //\r
+ Mask = (INT16) ((INT16)~0 << NBits);\r
+\r
+ //\r
+ // Now using the mask, extract N from the lower bits of the index.\r
+ //\r
+ N = (INT16) (Index &~Mask);\r
+\r
+ //\r
+ // Now compute C\r
+ //\r
+ C = (INT16) (((Index &~0xF000) & Mask) >> NBits);\r
+\r
+ Offset = (INT16) (N * sizeof (UINTN) + C);\r
+\r
+ //\r
+ // Now set the sign\r
+ //\r
+ if (Index & 0x8000) {\r
+ //\r
+ // Do it the hard way to work around a bogus compiler warning\r
+ //\r
+ // Offset = -1 * Offset;\r
+ //\r
+ Offset = (INT16) ((INT32) Offset * -1);\r
+ }\r
+\r
+ return Offset;\r
+}\r
+\r
+STATIC\r
+INT32\r
+VmReadIndex32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Decode a 32-bit index to determine the offset.\r
+\r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+ CodeOffset - offset from IP of the location of the 32-bit index to decode\r
+\r
+Returns:\r
+ Converted index per EBC VM specification\r
+\r
+--*/\r
+{\r
+ UINT32 Index;\r
+ INT32 Offset;\r
+ INT32 C;\r
+ INT32 N;\r
+ INT32 NBits;\r
+ INT32 Mask;\r
+\r
+ Index = VmReadImmed32 (VmPtr, CodeOffset);\r
+\r
+ //\r
+ // Get the mask for N. First get the number of bits from the index.\r
+ //\r
+ NBits = (Index & 0x70000000) >> 28;\r
+\r
+ //\r
+ // Scale it for 32-bit indexes\r
+ //\r
+ NBits *= 4;\r
+\r
+ //\r
+ // Now using the number of bits, create a mask.\r
+ //\r
+ Mask = (INT32)~0 << NBits;\r
+\r
+ //\r
+ // Now using the mask, extract N from the lower bits of the index.\r
+ //\r
+ N = Index &~Mask;\r
+\r
+ //\r
+ // Now compute C\r
+ //\r
+ C = ((Index &~0xF0000000) & Mask) >> NBits;\r
+\r
+ Offset = N * sizeof (UINTN) + C;\r
+\r
+ //\r
+ // Now set the sign\r
+ //\r
+ if (Index & 0x80000000) {\r
+ Offset = Offset * -1;\r
+ }\r
+\r
+ return Offset;\r
+}\r
+\r
+STATIC\r
+INT64\r
+VmReadIndex64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Decode a 64-bit index to determine the offset.\r
+\r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+ CodeOffset - offset from IP of the location of the 64-bit index to decode\r
+\r
+Returns:\r
+ Converted index per EBC VM specification\r
+\r
+--*/\r
+{\r
+ UINT64 Index;\r
+ INT64 Offset;\r
+ INT64 C;\r
+ INT64 N;\r
+ INT64 NBits;\r
+ INT64 Mask;\r
+\r
+ Index = VmReadCode64 (VmPtr, CodeOffset);\r
+\r
+ //\r
+ // Get the mask for N. First get the number of bits from the index.\r
+ //\r
+ NBits = RShiftU64 ((Index & 0x7000000000000000ULL), 60);\r
+\r
+ //\r
+ // Scale it for 64-bit indexes (multiply by 8 by shifting left 3)\r
+ //\r
+ NBits = LShiftU64 ((UINT64)NBits, 3);\r
+\r
+ //\r
+ // Now using the number of bits, create a mask.\r
+ //\r
+ Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits));\r
+\r
+ //\r
+ // Now using the mask, extract N from the lower bits of the index.\r
+ //\r
+ N = Index &~Mask;\r
+\r
+ //\r
+ // Now compute C\r
+ //\r
+ C = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits);\r
+\r
+ Offset = MultU64x64 (N, sizeof (UINTN)) + C;\r
+\r
+ //\r
+ // Now set the sign\r
+ //\r
+ if (Index & 0x8000000000000000ULL) {\r
+ Offset = MultS64x64 (Offset, -1);\r
+ }\r
+\r
+ return Offset;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT8 Data\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ The following VmWriteMem? routines are called by the EBC data\r
+ movement instructions that write to memory. Since these writes\r
+ may be to the stack, which looks like (high address on top) this,\r
+\r
+ [EBC entry point arguments]\r
+ [VM stack]\r
+ [EBC stack]\r
+\r
+ we need to detect all attempts to write to the EBC entry point argument\r
+ stack area and adjust the address (which will initially point into the \r
+ VM stack) to point into the EBC entry point arguments.\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Addr - adddress to write to\r
+ Data - value to write to Addr\r
+ \r
+Returns:\r
+ Standard EFI_STATUS\r
+\r
+--*/\r
+{\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ *(UINT8 *) Addr = Data;\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT16 Data\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+\r
+ //\r
+ // Do a simple write if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT16))) {\r
+ *(UINT16 *) Addr = Data;\r
+ } else {\r
+ //\r
+ // Write as two bytes\r
+ //\r
+ MemoryFence ();\r
+ if ((Status = VmWriteMem8 (VmPtr, Addr, (UINT8) Data)) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8) (Data >> 8))) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+STATIC\r
+EFI_STATUS\r
+VmWriteMem32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT32 Data\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+\r
+ //\r
+ // Do a simple write if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT32))) {\r
+ *(UINT32 *) Addr = Data;\r
+ } else {\r
+ //\r
+ // Write as two words\r
+ //\r
+ MemoryFence ();\r
+ if ((Status = VmWriteMem16 (VmPtr, Addr, (UINT16) Data)) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16) (Data >> 16))) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+EFI_STATUS\r
+VmWriteMem64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT64 Data\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINT32 Data32;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+\r
+ //\r
+ // Do a simple write if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT64))) {\r
+ *(UINT64 *) Addr = Data;\r
+ } else {\r
+ //\r
+ // Write as two 32-bit words\r
+ //\r
+ MemoryFence ();\r
+ if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32) Data)) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ Data32 = (UINT32) (((UINT32 *) &Data)[1]);\r
+ if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), Data32)) != EFI_SUCCESS) {\r
+ return Status;\r
+ }\r
+\r
+ MemoryFence ();\r
+ }\r
+\r
+ return EFI_SUCCESS;\r
+}\r
+\r
+EFI_STATUS\r
+VmWriteMemN (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINTN Data\r
+ )\r
+{\r
+ EFI_STATUS Status;\r
+ UINTN Index;\r
+\r
+ Status = EFI_SUCCESS;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+\r
+ //\r
+ // Do a simple write if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINTN))) {\r
+ *(UINTN *) Addr = Data;\r
+ } else {\r
+ for (Index = 0; Index < sizeof (UINTN) / sizeof (UINT32); Index++) {\r
+ MemoryFence ();\r
+ Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32) Data);\r
+ MemoryFence ();\r
+ Data = (UINTN)RShiftU64 ((UINT64)Data, 32);\r
+ }\r
+ }\r
+\r
+ return Status;\r
+}\r
+\r
+STATIC\r
+INT8\r
+VmReadImmed8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ \r
+ The following VmReadImmed routines are called by the EBC execute\r
+ functions to read EBC immediate values from the code stream.\r
+ Since we can't assume alignment, each tries to read in the biggest \r
+ chunks size available, but will revert to smaller reads if necessary.\r
+\r
+Arguments:\r
+ VmPtr - pointer to a VM context \r
+ Offset - offset from IP of the code bytes to read.\r
+\r
+Returns:\r
+ Signed data of the requested size from the specified address.\r
+\r
+--*/\r
+{\r
+ //\r
+ // Simply return the data in flat memory space\r
+ //\r
+ return * (INT8 *) (VmPtr->Ip + Offset);\r
+}\r
+\r
+STATIC\r
+INT16\r
+VmReadImmed16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+{\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (INT16))) {\r
+ return * (INT16 *) (VmPtr->Ip + Offset);\r
+ } else {\r
+ //\r
+ // All code word reads should be aligned\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_WARNING,\r
+ VmPtr\r
+ );\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));\r
+}\r
+\r
+STATIC\r
+INT32\r
+VmReadImmed32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+{\r
+ UINT32 Data;\r
+\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {\r
+ return * (INT32 *) (VmPtr->Ip + Offset);\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
+ Data |= (UINT32) (VmReadCode16 (VmPtr, Offset + 2) << 16);\r
+ return Data;\r
+}\r
+\r
+STATIC\r
+INT64\r
+VmReadImmed64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+{\r
+ UINT64 Data64;\r
+ UINT32 Data32;\r
+ UINT8 *Ptr;\r
+\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {\r
+ return * (UINT64 *) (VmPtr->Ip + Offset);\r
+ }\r
+ //\r
+ // Return unaligned data.\r
+ //\r
+ Ptr = (UINT8 *) &Data64;\r
+ Data32 = VmReadCode32 (VmPtr, Offset);\r
+ *(UINT32 *) Ptr = Data32;\r
+ Ptr += sizeof (Data32);\r
+ Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));\r
+ *(UINT32 *) Ptr = Data32;\r
+ return Data64;\r
+}\r
+\r
+STATIC\r
+UINT16\r
+VmReadCode16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ The following VmReadCode() routines provide the ability to read raw \r
+ unsigned data from the code stream. \r
+ \r
+Arguments:\r
+ VmPtr - pointer to VM context\r
+ Offset - offset from current IP to the raw data to read.\r
+\r
+Returns:\r
+ The raw unsigned 16-bit value from the code stream.\r
+ \r
+--*/\r
+{\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT16))) {\r
+ return * (UINT16 *) (VmPtr->Ip + Offset);\r
+ } else {\r
+ //\r
+ // All code word reads should be aligned\r
+ //\r
+ EbcDebugSignalException (\r
+ EXCEPT_EBC_ALIGNMENT_CHECK,\r
+ EXCEPTION_FLAG_WARNING,\r
+ VmPtr\r
+ );\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));\r
+}\r
+\r
+STATIC\r
+UINT32\r
+VmReadCode32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+{\r
+ UINT32 Data;\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT32))) {\r
+ return * (UINT32 *) (VmPtr->Ip + Offset);\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
+ Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16);\r
+ return Data;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+VmReadCode64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
+ )\r
+{\r
+ UINT64 Data64;\r
+ UINT32 Data32;\r
+ UINT8 *Ptr;\r
+\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {\r
+ return * (UINT64 *) (VmPtr->Ip + Offset);\r
+ }\r
+ //\r
+ // Return unaligned data.\r
+ //\r
+ Ptr = (UINT8 *) &Data64;\r
+ Data32 = VmReadCode32 (VmPtr, Offset);\r
+ *(UINT32 *) Ptr = Data32;\r
+ Ptr += sizeof (Data32);\r
+ Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));\r
+ *(UINT32 *) Ptr = Data32;\r
+ return Data64;\r
+}\r
+\r
+STATIC\r
+UINT8\r
+VmReadMem8 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+{\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ //\r
+ // Simply return the data in flat memory space\r
+ //\r
+ return * (UINT8 *) Addr;\r
+}\r
+\r
+STATIC\r
+UINT16\r
+VmReadMem16 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+{\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT16))) {\r
+ return * (UINT16 *) Addr;\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8));\r
+}\r
+\r
+STATIC\r
+UINT32\r
+VmReadMem32 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+{\r
+ UINT32 Data;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT32))) {\r
+ return * (UINT32 *) Addr;\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ Data = (UINT32) VmReadMem16 (VmPtr, Addr);\r
+ Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16);\r
+ return Data;\r
+}\r
+\r
+STATIC\r
+UINT64\r
+VmReadMem64 (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+{\r
+ UINT64 Data;\r
+ UINT32 Data32;\r
+\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINT64))) {\r
+ return * (UINT64 *) Addr;\r
+ }\r
+ //\r
+ // Return unaligned data. Assume little endian.\r
+ //\r
+ Data = (UINT64) VmReadMem32 (VmPtr, Addr);\r
+ Data32 = VmReadMem32 (VmPtr, Addr + sizeof (UINT32));\r
+ *(UINT32 *) ((UINT32 *) &Data + 1) = Data32;\r
+ return Data;\r
+}\r
+\r
+STATIC\r
+UINTN\r
+ConvertStackAddr (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+ Given an address that EBC is going to read from or write to, return\r
+ an appropriate address that accounts for a gap in the stack.\r
+ \r
+ The stack for this application looks like this (high addr on top)\r
+ [EBC entry point arguments]\r
+ [VM stack]\r
+ [EBC stack]\r
+\r
+ The EBC assumes that its arguments are at the top of its stack, which\r
+ is where the VM stack is really. Therefore if the EBC does memory\r
+ accesses into the VM stack area, then we need to convert the address\r
+ to point to the EBC entry point arguments area. Do this here.\r
+\r
+Arguments:\r
+\r
+ VmPtr - pointer to VM context\r
+ Addr - address of interest\r
+\r
+Returns:\r
+\r
+ The unchanged address if it's not in the VM stack region. Otherwise, \r
+ adjust for the stack gap and return the modified address.\r
+ \r
+--*/\r
+{ \r
+ ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));\r
+ return Addr;\r
+}\r
+\r
+STATIC\r
+UINTN\r
+VmReadMemN (\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
+ )\r
+/*++\r
+\r
+Routine Description:\r
+ Read a natural value from memory. May or may not be aligned.\r
+ \r
+Arguments:\r
+ VmPtr - current VM context\r
+ Addr - the address to read from\r
+\r
+Returns:\r
+ The natural value at address Addr.\r
+ \r
+--*/\r
+{\r
+ UINTN Data;\r
+ volatile UINT32 Size;\r
+ UINT8 *FromPtr;\r
+ UINT8 *ToPtr;\r
+ //\r
+ // Convert the address if it's in the stack gap\r
+ //\r
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ //\r
+ // Read direct if aligned\r
+ //\r
+ if (IS_ALIGNED (Addr, sizeof (UINTN))) {\r
+ return * (UINTN *) Addr;\r
+ }\r
+ //\r
+ // Return unaligned data\r
+ //\r
+ Data = 0;\r
+ FromPtr = (UINT8 *) Addr;\r
+ ToPtr = (UINT8 *) &Data;\r
+\r
+ for (Size = 0; Size < sizeof (Data); Size++) {\r
+ *ToPtr = *FromPtr;\r
+ ToPtr++;\r
+ FromPtr++;\r
+ }\r
+\r
+ return Data;\r
+}\r
+\r
+UINT64\r
+GetVmVersion (\r
+ VOID\r
+ )\r
+{\r
+ return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));\r
+}\r
projects / mirror_edk2.git / blobdiff