#include "EbcExecute.h"\r
#include "EbcDebuggerHook.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
+#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
+ EFI_STATUS (*ExecuteFunction)(\r
+ 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
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
INT16\r
VmReadIndex16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
);\r
\r
/**\r
**/\r
INT32\r
VmReadIndex32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
);\r
\r
/**\r
**/\r
INT64\r
VmReadIndex64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
);\r
\r
/**\r
**/\r
UINT8\r
VmReadMem8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
UINT16\r
VmReadMem16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
UINT32\r
VmReadMem32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
UINT64\r
VmReadMem64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
UINTN\r
VmReadMemN (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
VmWriteMem8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT8 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT8 Data\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
VmWriteMem16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT16 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT16 Data\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
VmWriteMem32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT32 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT32 Data\r
);\r
\r
/**\r
**/\r
UINT16\r
VmReadCode16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
UINT32\r
VmReadCode32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
UINT64\r
VmReadCode64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
INT8\r
VmReadImmed8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
INT16\r
VmReadImmed16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
INT32\r
VmReadImmed32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
INT64\r
VmReadImmed64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
);\r
\r
/**\r
**/\r
UINTN\r
ConvertStackAddr (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteDataManip (\r
- IN VM_CONTEXT *VmPtr,\r
- IN BOOLEAN IsSignedOp\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN BOOLEAN IsSignedOp\r
);\r
\r
//\r
// Functions that execute VM opcodes\r
//\r
+\r
/**\r
Execute the EBC BREAK instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteBREAK (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteJMP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteJMP8 (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteCALL (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteRET (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteCMP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteCMPI (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVxx (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVI (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVIn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVREL (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecutePUSHn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecutePUSH (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecutePOPn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecutePOP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteSignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteUnsignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteLOADSP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteSTORESP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVsnd (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
**/\r
EFI_STATUS\r
ExecuteMOVsnw (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
//\r
// Data manipulation subfunctions\r
//\r
+\r
/**\r
Execute the EBC NOT instruction.s\r
\r
**/\r
UINT64\r
ExecuteNOT (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteNEG (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteADD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteSUB (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteMUL (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteMULU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteDIV (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteDIVU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteMOD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteMODU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteAND (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteOR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteXOR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteSHL (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteSHR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteASHR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteEXTNDB (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteEXTNDW (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
**/\r
UINT64\r
ExecuteEXTNDD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\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
-CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {\r
+CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {\r
ExecuteNOT,\r
ExecuteNEG,\r
ExecuteADD,\r
ExecuteEXTNDD,\r
};\r
\r
-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
+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
+ { 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
+ { ExecuteSignedDataManip }, // opcode 0x10 DIV\r
{ ExecuteUnsignedDataManip }, // opcode 0x11 DIVU\r
- { ExecuteSignedDataManip }, // opcode 0x12 MOD\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
+ { 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
- { NULL }, // opcode 0x3a\r
- { NULL }, // opcode 0x3b\r
- { NULL }, // opcode 0x3c\r
- { NULL }, // opcode 0x3d\r
- { NULL }, // opcode 0x3e\r
- { NULL } // opcode 0x3f\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
+ { NULL }, // opcode 0x3a\r
+ { NULL }, // opcode 0x3b\r
+ { NULL }, // opcode 0x3c\r
+ { NULL }, // opcode 0x3d\r
+ { NULL }, // opcode 0x3e\r
+ { NULL } // opcode 0x3f\r
};\r
\r
//\r
// Length of JMP instructions, depending on upper two bits of opcode.\r
//\r
-CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 };\r
+CONST UINT8 mJMPLen[] = { 2, 2, 6, 10 };\r
\r
/**\r
Given a pointer to a new VM context, execute one or more instructions. This\r
EFI_STATUS\r
EFIAPI\r
EbcExecuteInstructions (\r
- IN EFI_EBC_VM_TEST_PROTOCOL *This,\r
- IN VM_CONTEXT *VmPtr,\r
- IN OUT UINTN *InstructionCount\r
+ IN EFI_EBC_VM_TEST_PROTOCOL *This,\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN OUT UINTN *InstructionCount\r
)\r
{\r
UINTN ExecFunc;\r
// call it if it's not null.\r
//\r
while (InstructionsLeft != 0) {\r
- ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction;\r
- if (ExecFunc == (UINTN) NULL) {\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
return EFI_UNSUPPORTED;\r
} else {\r
return Status;\r
}\r
\r
-\r
/**\r
Execute an EBC image from an entry point or from a published protocol.\r
\r
**/\r
EFI_STATUS\r
EbcExecute (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINTN ExecFunc;\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
+ if (*VmPtr->StackMagicPtr != (UINTN)VM_STACK_KEY_VALUE) {\r
StackCorrupted = 1;\r
}\r
\r
- VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->Gpr[0] + 8);\r
+ VmPtr->FramePtr = (VOID *)((UINT8 *)(UINTN)VmPtr->Gpr[0] + 8);\r
\r
//\r
// Try to get the debug support for EBC\r
//\r
DEBUG_CODE_BEGIN ();\r
- Status = gBS->LocateProtocol (\r
- &gEfiEbcSimpleDebuggerProtocolGuid,\r
- NULL,\r
- (VOID **) &EbcSimpleDebugger\r
- );\r
- if (EFI_ERROR (Status)) {\r
- EbcSimpleDebugger = NULL;\r
- }\r
+ Status = gBS->LocateProtocol (\r
+ &gEfiEbcSimpleDebuggerProtocolGuid,\r
+ NULL,\r
+ (VOID **)&EbcSimpleDebugger\r
+ );\r
+ if (EFI_ERROR (Status)) {\r
+ EbcSimpleDebugger = NULL;\r
+ }\r
+\r
DEBUG_CODE_END ();\r
\r
//\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
+ VmPtr->EntryPoint = (VOID *)VmPtr->Ip;\r
\r
//\r
// We'll wait for this flag to know when we're done. The RET\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
+ if (EbcSimpleDebugger != NULL) {\r
+ EbcSimpleDebugger->Debugger (EbcSimpleDebugger, VmPtr);\r
+ }\r
+\r
DEBUG_CODE_END ();\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
+ 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
if (VMFLAG_ISSET (VmPtr, VMFLAGS_STEP)) {\r
EbcDebugSignalException (EXCEPT_EBC_STEP, EXCEPTION_FLAG_NONE, VmPtr);\r
}\r
+\r
//\r
// Make sure stack has not been corrupted. Only report it once though.\r
//\r
- if ((StackCorrupted == 0) && (*VmPtr->StackMagicPtr != (UINTN) VM_STACK_KEY_VALUE)) {\r
+ if ((StackCorrupted == 0) && (*VmPtr->StackMagicPtr != (UINTN)VM_STACK_KEY_VALUE)) {\r
EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);\r
StackCorrupted = 1;\r
}\r
- if ((StackCorrupted == 0) && ((UINT64)VmPtr->Gpr[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {\r
+\r
+ if ((StackCorrupted == 0) && ((UINT64)VmPtr->Gpr[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
+ mVmPtr = NULL;\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Execute the MOVxx instructions.\r
\r
**/\r
EFI_STATUS\r
ExecuteMOVxx (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
UINTN Source;\r
\r
Opcode = GETOPCODE (VmPtr);\r
- OpcMasked = (UINT8) (Opcode & OPCODE_M_OPCODE);\r
+ OpcMasked = (UINT8)(Opcode & OPCODE_M_OPCODE);\r
\r
//\r
// Get the operands byte so we can get R1 and R2\r
//\r
// Assume no indexes\r
//\r
- Index64Op1 = 0;\r
- Index64Op2 = 0;\r
- Data64 = 0;\r
+ Index64Op1 = 0;\r
+ Index64Op2 = 0;\r
+ Data64 = 0;\r
\r
//\r
// Determine if we have an index/immediate data. Base instruction size\r
// Get one or both index values.\r
//\r
if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
- Index16 = VmReadIndex16 (VmPtr, 2);\r
- Index64Op1 = (INT64) Index16;\r
- Size += sizeof (UINT16);\r
+ Index16 = VmReadIndex16 (VmPtr, 2);\r
+ Index64Op1 = (INT64)Index16;\r
+ Size += sizeof (UINT16);\r
}\r
\r
if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
- Index16 = VmReadIndex16 (VmPtr, Size);\r
- Index64Op2 = (INT64) Index16;\r
- Size += sizeof (UINT16);\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) != 0) {\r
- Index32 = VmReadIndex32 (VmPtr, 2);\r
- Index64Op1 = (INT64) Index32;\r
- Size += sizeof (UINT32);\r
+ Index32 = VmReadIndex32 (VmPtr, 2);\r
+ Index64Op1 = (INT64)Index32;\r
+ Size += sizeof (UINT32);\r
}\r
\r
if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
- Index32 = VmReadIndex32 (VmPtr, Size);\r
- Index64Op2 = (INT64) Index32;\r
- Size += sizeof (UINT32);\r
+ Index32 = VmReadIndex32 (VmPtr, Size);\r
+ Index64Op2 = (INT64)Index32;\r
+ Size += sizeof (UINT32);\r
}\r
} else if (OpcMasked == OPCODE_MOVQQ) {\r
//\r
//\r
if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
Index64Op1 = VmReadIndex64 (VmPtr, 2);\r
- Size += sizeof (UINT64);\r
+ Size += sizeof (UINT64);\r
}\r
\r
if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
Index64Op2 = VmReadIndex64 (VmPtr, Size);\r
- Size += sizeof (UINT64);\r
+ Size += sizeof (UINT64);\r
}\r
} else {\r
//\r
return EFI_UNSUPPORTED;\r
}\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
+ 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
+ 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
+ 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
+ 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
+ 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
EbcDebugSignalException (EXCEPT_EBC_UNDEFINED, EXCEPTION_FLAG_FATAL, VmPtr);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Now get the source address\r
//\r
//\r
// Indirect form @R2. Compute address of operand2\r
//\r
- Source = (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);\r
+ Source = (UINTN)(VmPtr->Gpr[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
+ 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 = (UINT64) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index64Op2);\r
+ Data64 = (UINT64)(VmPtr->Gpr[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
(Index64Op2 > 0) &&\r
(OPERAND1_REGNUM (Operands) == 0) &&\r
(OPERAND1_INDIRECT (Operands))\r
- ) {\r
- Data64 = (UINT64) ConvertStackAddr (VmPtr, (UINTN) (INT64) Data64);\r
+ )\r
+ {\r
+ Data64 = (UINT64)ConvertStackAddr (VmPtr, (UINTN)(INT64)Data64);\r
}\r
}\r
}\r
+\r
//\r
// Now write it back\r
//\r
//\r
// Reuse the Source variable to now be dest.\r
//\r
- Source = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index64Op1);\r
+ Source = (UINTN)(VmPtr->Gpr[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
+ 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
);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Direct storage in register. Clear unused bits and store back to\r
// register.\r
//\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC BREAK instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteBREAK (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
EFI_STATUS Status;\r
UINT64 U64EbcEntryPoint;\r
INT32 Offset;\r
\r
- Thunk = NULL;\r
+ Thunk = NULL;\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
+ // Runaway program break. Generate an exception and terminate\r
//\r
- VmPtr->Gpr[7] = GetVmVersion ();\r
- break;\r
+ case 0:\r
+ EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);\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
+ // Get VM version -- return VM revision number in R7\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
+ case 1:\r
+ //\r
+ // Bits:\r
+ // 63-17 = 0\r
+ // 16-8 = Major version\r
+ // 7-0 = Minor version\r
+ //\r
+ VmPtr->Gpr[7] = GetVmVersion ();\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->Gpr[7]);\r
- U64EbcEntryPoint = (UINT64) (VmPtr->Gpr[7] + Offset + 4);\r
- EbcEntryPoint = (VOID *) (UINTN) U64EbcEntryPoint;\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
- // Now create a new thunk\r
+ // System call, which there are none, so NOP it.\r
//\r
- Status = EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);\r
- if (EFI_ERROR (Status)) {\r
- return Status;\r
- }\r
+ case 4:\r
+ break;\r
\r
//\r
- // Finally replace the EBC entry point memory with the thunk address\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
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[7], (UINT64) (UINTN) Thunk);\r
- break;\r
+ case 5:\r
+ Offset = (INT32)VmReadMem32 (VmPtr, (UINTN)VmPtr->Gpr[7]);\r
+ U64EbcEntryPoint = (UINT64)(VmPtr->Gpr[7] + Offset + 4);\r
+ EbcEntryPoint = (VOID *)(UINTN)U64EbcEntryPoint;\r
+\r
+ //\r
+ // Now create a new thunk\r
+ //\r
+ Status = EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);\r
+ if (EFI_ERROR (Status)) {\r
+ return Status;\r
+ }\r
+\r
+ //\r
+ // Finally replace the EBC entry point memory with the thunk address\r
+ //\r
+ VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[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->Gpr[7];\r
//\r
- // Check compiler version against VM version?\r
+ // Compiler setting version per value in R7\r
//\r
- break;\r
+ case 6:\r
+ VmPtr->CompilerVersion = (UINT32)VmPtr->Gpr[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
+ // Unhandled break code. Signal exception.\r
+ //\r
+ default:\r
+ EbcDebugSignalException (EXCEPT_EBC_BAD_BREAK, EXCEPTION_FLAG_FATAL, VmPtr);\r
+ break;\r
}\r
+\r
//\r
// Advance IP\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the JMP instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteJMP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\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) != 0) ? 1 : 0);\r
- ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
+ CompareSet = (UINT8)(((Operand & JMP_M_CS) != 0) ? 1 : 0);\r
+ ConditionFlag = (UINT8)VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
if ((Operand & CONDITION_M_CONDITIONAL) != 0) {\r
if (CompareSet != ConditionFlag) {\r
EbcDebuggerHookJMPStart (VmPtr);\r
return EFI_SUCCESS;\r
}\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
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// 64-bit immediate data is full address. Read the immediate data,\r
// check for alignment, and jump absolute.\r
//\r
- Data64 = (UINT64) VmReadImmed64 (VmPtr, 2);\r
- if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) {\r
+ Data64 = (UINT64)VmReadImmed64 (VmPtr, 2);\r
+ if (!IS_ALIGNED ((UINTN)Data64, sizeof (UINT16))) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_ALIGNMENT_CHECK,\r
EXCEPTION_FLAG_FATAL,\r
//\r
EbcDebuggerHookJMPStart (VmPtr);\r
if ((Operand & JMP_M_RELATIVE) != 0) {\r
- VmPtr->Ip += (UINTN) Data64 + Size;\r
+ VmPtr->Ip += (UINTN)Data64 + Size;\r
} else {\r
- VmPtr->Ip = (VMIP) (UINTN) Data64;\r
+ VmPtr->Ip = (VMIP)(UINTN)Data64;\r
}\r
+\r
EbcDebuggerHookJMPEnd (VmPtr);\r
\r
return EFI_SUCCESS;\r
}\r
+\r
//\r
// 32-bit forms:\r
// Get the index if there is one. May be either an index, or an immediate\r
} else {\r
Index32 = 0;\r
}\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 = (UINT64) OPERAND1_REGDATA (VmPtr, Operand);\r
+ Data64 = (UINT64)OPERAND1_REGDATA (VmPtr, Operand);\r
}\r
+\r
//\r
// Decode the forms\r
//\r
//\r
// Form: JMP32 @Rx {Index32}\r
//\r
- Addr = VmReadMemN (VmPtr, (UINTN) Data64 + Index32);\r
- if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {\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
\r
EbcDebuggerHookJMPStart (VmPtr);\r
if ((Operand & JMP_M_RELATIVE) != 0) {\r
- VmPtr->Ip += (UINTN) Addr + Size;\r
+ VmPtr->Ip += (UINTN)Addr + Size;\r
} else {\r
- VmPtr->Ip = (VMIP) Addr;\r
+ VmPtr->Ip = (VMIP)Addr;\r
}\r
- EbcDebuggerHookJMPEnd (VmPtr);\r
\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
} else {\r
//\r
// Form: JMP32 Rx {Immed32}\r
//\r
- Addr = (UINTN) (Data64 + Index32);\r
- if (!IS_ALIGNED ((UINTN) Addr, sizeof (UINT16))) {\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
\r
EbcDebuggerHookJMPStart (VmPtr);\r
if ((Operand & JMP_M_RELATIVE) != 0) {\r
- VmPtr->Ip += (UINTN) Addr + Size;\r
+ VmPtr->Ip += (UINTN)Addr + Size;\r
} else {\r
- VmPtr->Ip = (VMIP) Addr;\r
+ VmPtr->Ip = (VMIP)Addr;\r
}\r
- EbcDebuggerHookJMPEnd (VmPtr);\r
\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC JMP8 instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteJMP8 (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Opcode;\r
- UINT8 ConditionFlag;\r
- UINT8 CompareSet;\r
- INT8 Offset;\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) != 0) ? 1 : 0);\r
- ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
+ CompareSet = (UINT8)(((Opcode & JMP_M_CS) != 0) ? 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
return EFI_SUCCESS;\r
}\r
}\r
+\r
//\r
// Get the offset from the instruction stream. It's relative to the\r
// following instruction, and divided by 2.\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC MOVI.\r
\r
**/\r
EFI_STATUS\r
ExecuteMOVI (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Get the index (16-bit) if present\r
Index16 = 0;\r
Size = 2;\r
}\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
+ 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
+ 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
+ ImmData64 = (INT64)VmReadImmed64 (VmPtr, Size);\r
+ Size += 8;\r
} else {\r
//\r
// Invalid encoding\r
);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Now write back the result\r
//\r
);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Writing directly to a register. Clear unused bits.\r
//\r
} else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {\r
Mask64 = 0x00000000FFFFFFFF;\r
} else {\r
- Mask64 = (UINT64)~0;\r
+ Mask64 = (UINT64) ~0;\r
}\r
\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64;\r
//\r
// Get the address then write back based on size of the move\r
//\r
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH8) {\r
- VmWriteMem8 (VmPtr, (UINTN) Op1, (UINT8) ImmData64);\r
+ VmWriteMem8 (VmPtr, (UINTN)Op1, (UINT8)ImmData64);\r
} else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH16) {\r
- VmWriteMem16 (VmPtr, (UINTN) Op1, (UINT16) ImmData64);\r
+ VmWriteMem16 (VmPtr, (UINTN)Op1, (UINT16)ImmData64);\r
} else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {\r
- VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64);\r
+ VmWriteMem32 (VmPtr, (UINTN)Op1, (UINT32)ImmData64);\r
} else {\r
- VmWriteMem64 (VmPtr, (UINTN) Op1, (UINT64) ImmData64);\r
+ VmWriteMem64 (VmPtr, (UINTN)Op1, (UINT64)ImmData64);\r
}\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC MOV immediate natural. This instruction moves an immediate\r
index value into a register or memory location.\r
**/\r
EFI_STATUS\r
ExecuteMOVIn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Get the operand1 index (16-bit) if present\r
Index16 = 0;\r
Size = 2;\r
}\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
+ 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
+ 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
+ Size += 8;\r
} else {\r
//\r
// Invalid encoding\r
);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Now write back the result\r
//\r
//\r
// Get the address\r
//\r
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
- VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN)(INTN) ImmedIndex64);\r
+ Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ VmWriteMemN (VmPtr, (UINTN)Op1, (UINTN)(INTN)ImmedIndex64);\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC MOVREL instruction.\r
Dest <- Ip + ImmData\r
**/\r
EFI_STATUS\r
ExecuteMOVREL (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Get the Operand 1 index (16-bit) if present\r
Index16 = 0;\r
Size = 2;\r
}\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
+ 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
+ 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
+ Size += 8;\r
} else {\r
//\r
// Invalid encoding\r
);\r
return EFI_UNSUPPORTED;\r
}\r
+\r
//\r
// Compute the value and write back the result\r
//\r
- Op2 = (UINT64) ((INT64) ((UINT64) (UINTN) VmPtr->Ip) + (INT64) ImmData64 + Size);\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
return EFI_UNSUPPORTED;\r
}\r
\r
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (VM_REGISTER) Op2;\r
+ VmPtr->Gpr[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->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
- VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2);\r
+ Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ VmWriteMemN (VmPtr, (UINTN)Op1, (UINTN)Op2);\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\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
**/\r
EFI_STATUS\r
ExecuteMOVsnw (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get the opcode and operand bytes\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
- Op1Index = Op2Index = 0;\r
+ Op1Index = Op2Index = 0;\r
\r
//\r
// Get the indexes if present.\r
//\r
Size = 2;\r
- if ((Opcode & OPCODE_M_IMMED_OP1) !=0) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Op1Index = VmReadIndex16 (VmPtr, 2);\r
} else {\r
\r
Size += sizeof (UINT16);\r
}\r
+\r
//\r
// Get the data from the source.\r
//\r
Op2 = (UINT64)(INT64)(INTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);\r
if (OPERAND2_INDIRECT (Operands)) {\r
- Op2 = (UINT64)(INT64)(INTN)VmReadMemN (VmPtr, (UINTN) Op2);\r
+ Op2 = (UINT64)(INT64)(INTN)VmReadMemN (VmPtr, (UINTN)Op2);\r
}\r
+\r
//\r
// Now write back the result.\r
//\r
if (!OPERAND1_INDIRECT (Operands)) {\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;\r
} else {\r
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN)Op2);\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\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
**/\r
EFI_STATUS\r
ExecuteMOVsnd (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get the opcode and operand bytes\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
- Op1Index = Op2Index = 0;\r
+ Op1Index = Op2Index = 0;\r
\r
//\r
// Get the indexes if present.\r
\r
Size += sizeof (UINT32);\r
}\r
+\r
//\r
// Get the data from the source.\r
//\r
Op2 = (UINT64)(INT64)(INTN)(INT64)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);\r
if (OPERAND2_INDIRECT (Operands)) {\r
- Op2 = (UINT64)(INT64)(INTN)(INT64)VmReadMemN (VmPtr, (UINTN) Op2);\r
+ Op2 = (UINT64)(INT64)(INTN)(INT64)VmReadMemN (VmPtr, (UINTN)Op2);\r
}\r
+\r
//\r
// Now write back the result.\r
//\r
if (!OPERAND1_INDIRECT (Operands)) {\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;\r
} else {\r
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN)Op2);\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC PUSHn instruction\r
\r
**/\r
EFI_STATUS\r
ExecutePUSHn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Opcode;\r
- UINT8 Operands;\r
- INT16 Index16;\r
- UINTN DataN;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Get index if present\r
\r
VmPtr->Ip += 4;\r
} else {\r
- Index16 = 0;\r
+ Index16 = 0;\r
VmPtr->Ip += 2;\r
}\r
+\r
//\r
// Get the data to push\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
+ DataN = VmReadMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- DataN = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16);\r
+ DataN = (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16);\r
}\r
+\r
//\r
// Adjust the stack down.\r
//\r
VmPtr->Gpr[0] -= sizeof (UINTN);\r
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], DataN);\r
+ VmWriteMemN (VmPtr, (UINTN)VmPtr->Gpr[0], DataN);\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC PUSH instruction.\r
\r
**/\r
EFI_STATUS\r
ExecutePUSH (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get opcode and operands\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
//\r
// Get immediate index if present, then advance the IP.\r
//\r
\r
VmPtr->Ip += 4;\r
} else {\r
- Index16 = 0;\r
+ Index16 = 0;\r
VmPtr->Ip += 2;\r
}\r
+\r
//\r
// Get the data to push\r
//\r
if ((Opcode & PUSHPOP_M_64) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
- Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
+ Data64 = VmReadMem64 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- Data64 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Data64 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
}\r
+\r
//\r
// Adjust the stack down, then write back the data\r
//\r
VmPtr->Gpr[0] -= sizeof (UINT64);\r
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], Data64);\r
+ VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[0], Data64);\r
} else {\r
//\r
// 32-bit data\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
+ Data32 = VmReadMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- Data32 = (UINT32) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Data32 = (UINT32)VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
}\r
+\r
//\r
// Adjust the stack down and write the data\r
//\r
VmPtr->Gpr[0] -= sizeof (UINT32);\r
- VmWriteMem32 (VmPtr, (UINTN) VmPtr->Gpr[0], Data32);\r
+ VmWriteMem32 (VmPtr, (UINTN)VmPtr->Gpr[0], Data32);\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC POPn instruction.\r
\r
**/\r
EFI_STATUS\r
ExecutePOPn (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Opcode;\r
- UINT8 Operands;\r
- INT16 Index16;\r
- UINTN DataN;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
//\r
// Get immediate data if present, and advance the IP\r
//\r
\r
VmPtr->Ip += 4;\r
} else {\r
- Index16 = 0;\r
+ Index16 = 0;\r
VmPtr->Ip += 2;\r
}\r
+\r
//\r
// Read the data off the stack, then adjust the stack pointer\r
//\r
- DataN = VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);\r
+ DataN = VmReadMemN (VmPtr, (UINTN)VmPtr->Gpr[0]);\r
VmPtr->Gpr[0] += sizeof (UINTN);\r
//\r
// Do the write-back\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);\r
+ VmWriteMemN (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);\r
} else {\r
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) (UINT64) (UINTN) (DataN + Index16);\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64)(UINT64)(UINTN)(DataN + Index16);\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC POP instruction.\r
\r
**/\r
EFI_STATUS\r
ExecutePOP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get opcode and operands\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
//\r
// Get immediate data if present, and advance the IP.\r
//\r
\r
VmPtr->Ip += 4;\r
} else {\r
- Index16 = 0;\r
+ Index16 = 0;\r
VmPtr->Ip += 2;\r
}\r
+\r
//\r
// Get the data off the stack, then write it to the appropriate location\r
//\r
//\r
// Read the data off the stack, then adjust the stack pointer\r
//\r
- Data64 = VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);\r
+ Data64 = VmReadMem64 (VmPtr, (UINTN)VmPtr->Gpr[0]);\r
VmPtr->Gpr[0] += sizeof (UINT64);\r
//\r
// Do the write-back\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- VmWriteMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);\r
+ VmWriteMem64 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);\r
} else {\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 + Index16;\r
}\r
//\r
// 32-bit pop. Read it off the stack and adjust the stack pointer\r
//\r
- Data32 = (INT32) VmReadMem32 (VmPtr, (UINTN) VmPtr->Gpr[0]);\r
+ Data32 = (INT32)VmReadMem32 (VmPtr, (UINTN)VmPtr->Gpr[0]);\r
VmPtr->Gpr[0] += sizeof (UINT32);\r
//\r
// Do the write-back\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- VmWriteMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);\r
+ VmWriteMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);\r
} else {\r
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64)Data32 + Index16;\r
}\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Implements the EBC CALL instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteCALL (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Opcode;\r
- UINT8 Operands;\r
- INT32 Immed32;\r
- UINT8 Size;\r
- INT64 Immed64;\r
- VOID *FramePtr;\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
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
if ((Operands & OPERAND_M_NATIVE_CALL) != 0) {\r
EbcDebuggerHookCALLEXStart (VmPtr);\r
//\r
// Assign these as well to avoid compiler warnings\r
//\r
- Immed64 = 0;\r
- Immed32 = 0;\r
+ Immed64 = 0;\r
+ Immed32 = 0;\r
\r
- FramePtr = VmPtr->FramePtr;\r
+ FramePtr = VmPtr->FramePtr;\r
//\r
// Determine the instruction size, and get immediate data if present\r
//\r
} else {\r
Size = 2;\r
}\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->Gpr[0] -= 8;\r
- VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], (UINTN) FramePtr);\r
- VmPtr->FramePtr = (VOID *) (UINTN) VmPtr->Gpr[0];\r
- VmPtr->Gpr[0] -= 8;\r
- VmWriteMem64 (VmPtr, (UINTN) VmPtr->Gpr[0], (UINT64) (UINTN) (VmPtr->Ip + Size));\r
+ VmWriteMemN (VmPtr, (UINTN)VmPtr->Gpr[0], (UINTN)FramePtr);\r
+ VmPtr->FramePtr = (VOID *)(UINTN)VmPtr->Gpr[0];\r
+ VmPtr->Gpr[0] -= 8;\r
+ VmWriteMem64 (VmPtr, (UINTN)VmPtr->Gpr[0], (UINT64)(UINTN)(VmPtr->Ip + Size));\r
}\r
+\r
//\r
// If 64-bit data, then absolute jump only\r
//\r
// Native or EBC call?\r
//\r
if ((Operands & OPERAND_M_NATIVE_CALL) == 0) {\r
- VmPtr->Ip = (VMIP) (UINTN) Immed64;\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->Gpr[0], FramePtr, Size);\r
+ EbcLLCALLEX (VmPtr, (UINTN)Immed64, (UINTN)VmPtr->Gpr[0], FramePtr, Size);\r
}\r
} else {\r
//\r
// Compiler should take care of upper bits if 32-bit machine.\r
//\r
if (OPERAND1_REGNUM (Operands) != 0) {\r
- Immed64 = (UINT64) (UINTN) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
+ Immed64 = (UINT64)(UINTN)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
}\r
+\r
//\r
// Get final address\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- Immed64 = (INT64) (UINT64) (UINTN) VmReadMemN (VmPtr, (UINTN) (Immed64 + Immed32));\r
+ Immed64 = (INT64)(UINT64)(UINTN)VmReadMemN (VmPtr, (UINTN)(Immed64 + Immed32));\r
} else {\r
Immed64 += Immed32;\r
}\r
+\r
//\r
// Now determine if external call, and then if relative or absolute\r
//\r
if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {\r
VmPtr->Ip += Immed64 + Size;\r
} else {\r
- VmPtr->Ip = (VMIP) (UINTN) Immed64;\r
+ VmPtr->Ip = (VMIP)(UINTN)Immed64;\r
}\r
} else {\r
//\r
// Native call. Relative or absolute?\r
//\r
if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {\r
- EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->Gpr[0], FramePtr, Size);\r
+ EbcLLCALLEX (VmPtr, (UINTN)(Immed64 + VmPtr->Ip + Size), (UINTN)VmPtr->Gpr[0], FramePtr, Size);\r
} else {\r
if ((VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) != 0) {\r
CpuBreakpoint ();\r
}\r
\r
- EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);\r
+ EbcLLCALLEX (VmPtr, (UINTN)Immed64, (UINTN)VmPtr->Gpr[0], FramePtr, Size);\r
}\r
}\r
}\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC RET instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteRET (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
-\r
EbcDebuggerHookRETStart (VmPtr);\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->Gpr[0]) {\r
+ if (VmPtr->StackRetAddr == (UINT64)VmPtr->Gpr[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->Gpr[0], sizeof (UINT16))) {\r
+ if (!IS_ALIGNED ((UINTN)VmPtr->Gpr[0], sizeof (UINT16))) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_ALIGNMENT_CHECK,\r
EXCEPTION_FLAG_FATAL,\r
VmPtr\r
);\r
}\r
+\r
//\r
// Restore the IP and frame pointer from the stack\r
//\r
- VmPtr->Ip = (VMIP) (UINTN) VmReadMem64 (VmPtr, (UINTN) VmPtr->Gpr[0]);\r
- VmPtr->Gpr[0] += 8;\r
- VmPtr->FramePtr = (VOID *) VmReadMemN (VmPtr, (UINTN) VmPtr->Gpr[0]);\r
- VmPtr->Gpr[0] += 8;\r
+ VmPtr->Ip = (VMIP)(UINTN)VmReadMem64 (VmPtr, (UINTN)VmPtr->Gpr[0]);\r
+ VmPtr->Gpr[0] += 8;\r
+ VmPtr->FramePtr = (VOID *)VmReadMemN (VmPtr, (UINTN)VmPtr->Gpr[0]);\r
+ VmPtr->Gpr[0] += 8;\r
}\r
\r
-\r
EbcDebuggerHookRETEnd (VmPtr);\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC CMP instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteCMP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get opcode and operands\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
//\r
// Get the register data we're going to compare to\r
//\r
Index16 = 0;\r
Size = 2;\r
}\r
+\r
//\r
// Now get Op2\r
//\r
if (OPERAND2_INDIRECT (Operands)) {\r
if ((Opcode & OPCODE_M_64BIT) != 0) {\r
- Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16));\r
+ Op2 = (INT64)VmReadMem64 (VmPtr, (UINTN)(VmPtr->Gpr[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->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));\r
+ Op2 = (INT64)(UINT64)((UINT32)VmReadMem32 (VmPtr, (UINTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));\r
}\r
} else {\r
Op2 = VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;\r
}\r
+\r
//\r
// Now do the compare\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
+ case OPCODE_CMPEQ:\r
+ if (Op1 == Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPLTE:\r
- if (Op1 <= Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPGTE:\r
- if (Op1 >= Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPLTE:\r
+ if (Op1 <= Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPULTE:\r
- if ((UINT64) Op1 <= (UINT64) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPUGTE:\r
- if ((UINT64) Op1 >= (UINT64) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPGTE:\r
+ if (Op1 >= Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- default:\r
- ASSERT (0);\r
+ break;\r
+\r
+ case OPCODE_CMPULTE:\r
+ if ((UINT64)Op1 <= (UINT64)Op2) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ case OPCODE_CMPUGTE:\r
+ if ((UINT64)Op1 >= (UINT64)Op2) {\r
+ Flag = 1;\r
+ }\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
+ case OPCODE_CMPEQ:\r
+ if ((INT32)Op1 == (INT32)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPLTE:\r
- if ((INT32) Op1 <= (INT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPGTE:\r
- if ((INT32) Op1 >= (INT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPLTE:\r
+ if ((INT32)Op1 <= (INT32)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPULTE:\r
- if ((UINT32) Op1 <= (UINT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPUGTE:\r
- if ((UINT32) Op1 >= (UINT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPGTE:\r
+ if ((INT32)Op1 >= (INT32)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- default:\r
- ASSERT (0);\r
+ break;\r
+\r
+ case OPCODE_CMPULTE:\r
+ if ((UINT32)Op1 <= (UINT32)Op2) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ case OPCODE_CMPUGTE:\r
+ if ((UINT32)Op1 >= (UINT32)Op2) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
}\r
}\r
+\r
//\r
// Now set the flag accordingly for the comparison\r
//\r
} else {\r
VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);\r
}\r
+\r
//\r
// Advance the IP\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC CMPI instruction\r
\r
**/\r
EFI_STATUS\r
ExecuteCMPI (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get opcode and operands\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Get operand1 index if present\r
Size = 2;\r
if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
- Size += 2;\r
+ Size += 2;\r
} else {\r
Index16 = 0;\r
}\r
+\r
//\r
// Get operand1 data we're going to compare to\r
//\r
- Op1 = (INT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
+ Op1 = (INT64)VmPtr->Gpr[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) != 0) {\r
- Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16);\r
+ Op1 = (INT64)VmReadMem64 (VmPtr, (UINTN)Op1 + Index16);\r
} else {\r
- Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16);\r
+ Op1 = (INT64)VmReadMem32 (VmPtr, (UINTN)Op1 + Index16);\r
}\r
} else {\r
//\r
return EFI_UNSUPPORTED;\r
}\r
}\r
+\r
//\r
// Get immediate data -- 16- or 32-bit sign extended\r
//\r
if ((Opcode & OPCODE_M_CMPI32_DATA) != 0) {\r
- Op2 = (INT64) VmReadImmed32 (VmPtr, Size);\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
+ Op2 = (INT64)((INT16)VmReadImmed16 (VmPtr, Size));\r
Size += 2;\r
}\r
+\r
//\r
// Now do the compare\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
+ case OPCODE_CMPIEQ:\r
+ if (Op1 == (INT64)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPILTE:\r
- if (Op1 <= (INT64) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPIGTE:\r
- if (Op1 >= (INT64) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPILTE:\r
+ if (Op1 <= (INT64)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPIULTE:\r
- if ((UINT64) Op1 <= (UINT64) ((UINT32) Op2)) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPIUGTE:\r
- if ((UINT64) Op1 >= (UINT64) ((UINT32) Op2)) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPIGTE:\r
+ if (Op1 >= (INT64)Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- default:\r
- ASSERT (0);\r
+ break;\r
+\r
+ case OPCODE_CMPIULTE:\r
+ if ((UINT64)Op1 <= (UINT64)((UINT32)Op2)) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ case OPCODE_CMPIUGTE:\r
+ if ((UINT64)Op1 >= (UINT64)((UINT32)Op2)) {\r
+ Flag = 1;\r
+ }\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
+ case OPCODE_CMPIEQ:\r
+ if ((INT32)Op1 == Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPILTE:\r
- if ((INT32) Op1 <= Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPIGTE:\r
- if ((INT32) Op1 >= Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPILTE:\r
+ if ((INT32)Op1 <= Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- case OPCODE_CMPIULTE:\r
- if ((UINT32) Op1 <= (UINT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ break;\r
\r
- case OPCODE_CMPIUGTE:\r
- if ((UINT32) Op1 >= (UINT32) Op2) {\r
- Flag = 1;\r
- }\r
- break;\r
+ case OPCODE_CMPIGTE:\r
+ if ((INT32)Op1 >= Op2) {\r
+ Flag = 1;\r
+ }\r
\r
- default:\r
- ASSERT (0);\r
+ break;\r
+\r
+ case OPCODE_CMPIULTE:\r
+ if ((UINT32)Op1 <= (UINT32)Op2) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ case OPCODE_CMPIUGTE:\r
+ if ((UINT32)Op1 >= (UINT32)Op2) {\r
+ Flag = 1;\r
+ }\r
+\r
+ break;\r
+\r
+ default:\r
+ ASSERT (0);\r
}\r
}\r
+\r
//\r
// Now set the flag accordingly for the comparison\r
//\r
} else {\r
VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);\r
}\r
+\r
//\r
// Advance the IP\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC NOT instruction.s\r
\r
**/\r
UINT64\r
ExecuteNOT (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return ~Op2;\r
}\r
\r
-\r
/**\r
Execute the EBC NEG instruction.\r
\r
**/\r
UINT64\r
ExecuteNEG (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return ~Op2 + 1;\r
}\r
\r
-\r
/**\r
Execute the EBC ADD instruction.\r
\r
**/\r
UINT64\r
ExecuteADD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return Op1 + Op2;\r
}\r
\r
-\r
/**\r
Execute the EBC SUB instruction.\r
\r
**/\r
UINT64\r
ExecuteSUB (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
- return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2));\r
+ return (UINT64)((INT64)((INT64)Op1 - (INT64)Op2));\r
} else {\r
- return (UINT64) ((INT64) ((INT32) ((INT32) Op1 - (INT32) Op2)));\r
+ return (UINT64)((INT64)((INT32)((INT32)Op1 - (INT32)Op2)));\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC MUL instruction.\r
\r
**/\r
UINT64\r
ExecuteMUL (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return MultS64x64 ((INT64)Op1, (INT64)Op2);\r
} else {\r
- return (UINT64) ((INT64) ((INT32) ((INT32) Op1 * (INT32) Op2)));\r
+ return (UINT64)((INT64)((INT32)((INT32)Op1 * (INT32)Op2)));\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC MULU instruction\r
\r
**/\r
UINT64\r
ExecuteMULU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return MultU64x64 (Op1, Op2);\r
} else {\r
- return (UINT64) ((UINT32) ((UINT32) Op1 * (UINT32) Op2));\r
+ return (UINT64)((UINT32)((UINT32)Op1 * (UINT32)Op2));\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC DIV instruction.\r
\r
**/\r
UINT64\r
ExecuteDIV (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
- INT64 Remainder;\r
+ INT64 Remainder;\r
\r
//\r
// Check for divide-by-0\r
return 0;\r
} else {\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
- return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder));\r
+ return (UINT64)(DivS64x64Remainder (Op1, Op2, &Remainder));\r
} else {\r
- return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2));\r
+ return (UINT64)((INT64)((INT32)Op1 / (INT32)Op2));\r
}\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC DIVU instruction\r
\r
**/\r
UINT64\r
ExecuteDIVU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
UINT64 Remainder;\r
// Get the destination register\r
//\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
- return (UINT64) (DivU64x64Remainder (Op1, Op2, &Remainder));\r
+ return (UINT64)(DivU64x64Remainder (Op1, Op2, &Remainder));\r
} else {\r
- return (UINT64) ((UINT32) Op1 / (UINT32) Op2);\r
+ return (UINT64)((UINT32)Op1 / (UINT32)Op2);\r
}\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC MOD instruction.\r
\r
**/\r
UINT64\r
ExecuteMOD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
- INT64 Remainder;\r
+ INT64 Remainder;\r
\r
//\r
// Check for divide-by-0\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC MODU instruction.\r
\r
**/\r
UINT64\r
ExecuteMODU (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
UINT64 Remainder;\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC AND instruction.\r
\r
**/\r
UINT64\r
ExecuteAND (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return Op1 & Op2;\r
}\r
\r
-\r
/**\r
Execute the EBC OR instruction.\r
\r
**/\r
UINT64\r
ExecuteOR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return Op1 | Op2;\r
}\r
\r
-\r
/**\r
Execute the EBC XOR instruction.\r
\r
**/\r
UINT64\r
ExecuteXOR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
return Op1 ^ Op2;\r
}\r
\r
-\r
/**\r
Execute the EBC SHL shift left instruction.\r
\r
**/\r
UINT64\r
ExecuteSHL (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return LShiftU64 (Op1, (UINTN)Op2);\r
} else {\r
- return (UINT64) ((UINT32) ((UINT32) Op1 << (UINT32) Op2));\r
+ return (UINT64)((UINT32)((UINT32)Op1 << (UINT32)Op2));\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC SHR instruction.\r
\r
**/\r
UINT64\r
ExecuteSHR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return RShiftU64 (Op1, (UINTN)Op2);\r
} else {\r
- return (UINT64) ((UINT32) Op1 >> (UINT32) Op2);\r
+ return (UINT64)((UINT32)Op1 >> (UINT32)Op2);\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC ASHR instruction.\r
\r
**/\r
UINT64\r
ExecuteASHR (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return ARShiftU64 (Op1, (UINTN)Op2);\r
} else {\r
- return (UINT64) ((INT64) ((INT32) Op1 >> (UINT32) Op2));\r
+ return (UINT64)((INT64)((INT32)Op1 >> (UINT32)Op2));\r
}\r
}\r
\r
-\r
/**\r
Execute the EBC EXTNDB instruction to sign-extend a byte value.\r
\r
**/\r
UINT64\r
ExecuteEXTNDB (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
- INT8 Data8;\r
- INT64 Data64;\r
+ INT8 Data8;\r
+ INT64 Data64;\r
+\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
+ Data8 = (INT8)Op2;\r
+ Data64 = (INT64)Data8;\r
\r
- return (UINT64) Data64;\r
+ return (UINT64)Data64;\r
}\r
\r
-\r
/**\r
Execute the EBC EXTNDW instruction to sign-extend a 16-bit value.\r
\r
**/\r
UINT64\r
ExecuteEXTNDW (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
- INT16 Data16;\r
- INT64 Data64;\r
+ INT16 Data16;\r
+ INT64 Data64;\r
+\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
+ Data16 = (INT16)Op2;\r
+ Data64 = (INT64)Data16;\r
\r
- return (UINT64) Data64;\r
+ return (UINT64)Data64;\r
}\r
+\r
//\r
// Execute the EBC EXTNDD instruction.\r
//\r
**/\r
UINT64\r
ExecuteEXTNDD (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT64 Op1,\r
- IN UINT64 Op2\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
)\r
{\r
- INT32 Data32;\r
- INT64 Data64;\r
+ INT32 Data32;\r
+ INT64 Data64;\r
+\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
+ Data32 = (INT32)Op2;\r
+ Data64 = (INT64)Data32;\r
\r
- return (UINT64) Data64;\r
+ return (UINT64)Data64;\r
}\r
\r
-\r
/**\r
Execute all the EBC signed data manipulation instructions.\r
Since the EBC data manipulation instructions all have the same basic form,\r
**/\r
EFI_STATUS\r
ExecuteSignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
//\r
return ExecuteDataManip (VmPtr, TRUE);\r
}\r
\r
-\r
/**\r
Execute all the EBC unsigned data manipulation instructions.\r
Since the EBC data manipulation instructions all have the same basic form,\r
**/\r
EFI_STATUS\r
ExecuteUnsignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
//\r
return ExecuteDataManip (VmPtr, FALSE);\r
}\r
\r
-\r
/**\r
Execute all the EBC data manipulation instructions.\r
Since the EBC data manipulation instructions all have the same basic form,\r
**/\r
EFI_STATUS\r
ExecuteDataManip (\r
- IN VM_CONTEXT *VmPtr,\r
- IN BOOLEAN IsSignedOp\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN BOOLEAN IsSignedOp\r
)\r
{\r
UINT8 Opcode;\r
//\r
// Get opcode and operands\r
//\r
- Opcode = GETOPCODE (VmPtr);\r
- Operands = GETOPERANDS (VmPtr);\r
+ Opcode = GETOPCODE (VmPtr);\r
+ Operands = GETOPERANDS (VmPtr);\r
\r
//\r
// Determine if we have immediate data by the opcode\r
Index16 = 0;\r
Size = 2;\r
}\r
+\r
//\r
// Now get operand2 (source). It's of format {@}R2 {Index16|Immed16}\r
//\r
- Op2 = (UINT64) VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;\r
+ Op2 = (UINT64)VmPtr->Gpr[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) != 0) {\r
- Op2 = VmReadMem64 (VmPtr, (UINTN) Op2);\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
+ Op2 = (UINT64)(INT64)((INT32)VmReadMem32 (VmPtr, (UINTN)Op2));\r
} else {\r
- Op2 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op2);\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
+ Op2 = (UINT64)(INT64)((INT32)Op2);\r
} else {\r
- Op2 = (UINT64) ((UINT32) Op2);\r
+ Op2 = (UINT64)((UINT32)Op2);\r
}\r
}\r
}\r
+\r
//\r
// Get operand1 (destination and sometimes also an actual operand)\r
// of form {@}R1\r
//\r
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
+ Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
if (OPERAND1_INDIRECT (Operands)) {\r
if ((Opcode & DATAMANIP_M_64) != 0) {\r
- Op1 = VmReadMem64 (VmPtr, (UINTN) Op1);\r
+ Op1 = VmReadMem64 (VmPtr, (UINTN)Op1);\r
} else {\r
if (IsSignedOp) {\r
- Op1 = (UINT64) (INT64) ((INT32) VmReadMem32 (VmPtr, (UINTN) Op1));\r
+ Op1 = (UINT64)(INT64)((INT32)VmReadMem32 (VmPtr, (UINTN)Op1));\r
} else {\r
- Op1 = (UINT64) VmReadMem32 (VmPtr, (UINTN) Op1);\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
+ Op1 = (UINT64)(INT64)((INT32)Op1);\r
} else {\r
- Op1 = (UINT64) ((UINT32) Op1);\r
+ Op1 = (UINT64)((UINT32)Op1);\r
}\r
}\r
}\r
+\r
//\r
// Dispatch to the computation function\r
//\r
DataManipDispatchTableIndex = (Opcode & OPCODE_M_OPCODE) - OPCODE_NOT;\r
if ((DataManipDispatchTableIndex < 0) ||\r
- (DataManipDispatchTableIndex >= ARRAY_SIZE (mDataManipDispatchTable))) {\r
+ (DataManipDispatchTableIndex >= ARRAY_SIZE (mDataManipDispatchTable)))\r
+ {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INVALID_OPCODE,\r
EXCEPTION_FLAG_ERROR,\r
} else {\r
Op2 = mDataManipDispatchTable[DataManipDispatchTableIndex](VmPtr, Op1, Op2);\r
}\r
+\r
//\r
// Write back the result.\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
+ Op1 = (UINT64)VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
if ((Opcode & DATAMANIP_M_64) != 0) {\r
- VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);\r
+ VmWriteMem64 (VmPtr, (UINTN)Op1, Op2);\r
} else {\r
- VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);\r
+ VmWriteMem32 (VmPtr, (UINTN)Op1, (UINT32)Op2);\r
}\r
} else {\r
//\r
VmPtr->Gpr[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF;\r
}\r
}\r
+\r
//\r
// Advance the instruction pointer\r
//\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Execute the EBC LOADSP instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteLOADSP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Operands;\r
+ UINT8 Operands;\r
\r
//\r
// Get the operands\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
+ // Set flags\r
//\r
- VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);\r
- break;\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->Gpr[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
+ 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
-\r
/**\r
Execute the EBC STORESP instruction.\r
\r
**/\r
EFI_STATUS\r
ExecuteSTORESP (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
)\r
{\r
- UINT8 Operands;\r
+ UINT8 Operands;\r
\r
//\r
// Get the operands\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
+ // Get flags\r
//\r
- VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (VmPtr->Flags & VMFLAGS_ALL_VALID);\r
- break;\r
+ case 0:\r
+ //\r
+ // Retrieve the value in the flags register, then clear reserved bits\r
+ //\r
+ VmPtr->Gpr[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->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;\r
- break;\r
+ //\r
+ // Get IP -- address of following instruction\r
+ //\r
+ case 1:\r
+ VmPtr->Gpr[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
+ 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
-\r
/**\r
Decode a 16-bit index to determine the offset. Given an index value:\r
\r
**/\r
INT16\r
VmReadIndex16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
)\r
{\r
UINT16 Index;\r
//\r
// Get the mask for NaturalUnits. First get the number of bits from the index.\r
//\r
- NBits = (INT16) ((Index & 0x7000) >> 12);\r
+ NBits = (INT16)((Index & 0x7000) >> 12);\r
\r
//\r
// Scale it for 16-bit indexes\r
//\r
// Now using the number of bits, create a mask.\r
//\r
- Mask = (INT16) ((INT16)~0 << NBits);\r
+ Mask = (INT16)((INT16) ~0 << NBits);\r
\r
//\r
// Now using the mask, extract NaturalUnits from the lower bits of the index.\r
//\r
- NaturalUnits = (INT16) (Index &~Mask);\r
+ NaturalUnits = (INT16)(Index &~Mask);\r
\r
//\r
// Now compute ConstUnits\r
//\r
- ConstUnits = (INT16) (((Index &~0xF000) & Mask) >> NBits);\r
+ ConstUnits = (INT16)(((Index &~0xF000) & Mask) >> NBits);\r
\r
- Offset = (INT16) (NaturalUnits * sizeof (UINTN) + ConstUnits);\r
+ Offset = (INT16)(NaturalUnits * sizeof (UINTN) + ConstUnits);\r
\r
//\r
// Now set the sign\r
//\r
// Offset = -1 * Offset;\r
//\r
- Offset = (INT16) ((INT32) Offset * -1);\r
+ Offset = (INT16)((INT32)Offset * -1);\r
}\r
\r
return Offset;\r
}\r
\r
-\r
/**\r
Decode a 32-bit index to determine the offset.\r
\r
**/\r
INT32\r
VmReadIndex32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
)\r
{\r
UINT32 Index;\r
//\r
// Now using the number of bits, create a mask.\r
//\r
- Mask = (INT32)~0 << NBits;\r
+ Mask = (INT32) ~0 << NBits;\r
\r
//\r
// Now using the mask, extract NaturalUnits from the lower bits of the index.\r
//\r
// Now compute ConstUnits\r
//\r
- ConstUnits = ((Index &~0xF0000000) & Mask) >> NBits;\r
+ ConstUnits = ((Index &~0xF0000000) & Mask) >> NBits;\r
\r
- Offset = NaturalUnits * sizeof (UINTN) + ConstUnits;\r
+ Offset = NaturalUnits * sizeof (UINTN) + ConstUnits;\r
\r
//\r
// Now set the sign\r
return Offset;\r
}\r
\r
-\r
/**\r
Decode a 64-bit index to determine the offset.\r
\r
**/\r
INT64\r
VmReadIndex64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 CodeOffset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 CodeOffset\r
)\r
{\r
UINT64 Index;\r
//\r
// Now using the number of bits, create a mask.\r
//\r
- Mask = (LShiftU64 ((UINT64)~0, (UINTN)NBits));\r
+ Mask = (LShiftU64 ((UINT64) ~0, (UINTN)NBits));\r
\r
//\r
// Now using the mask, extract NaturalUnits from the lower bits of the index.\r
//\r
ConstUnits = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits);\r
\r
- Offset = MultU64x64 ((UINT64) NaturalUnits, sizeof (UINTN)) + ConstUnits;\r
+ Offset = MultU64x64 ((UINT64)NaturalUnits, sizeof (UINTN)) + ConstUnits;\r
\r
//\r
// Now set the sign\r
return Offset;\r
}\r
\r
-\r
/**\r
Writes 8-bit data to memory address.\r
\r
**/\r
EFI_STATUS\r
VmWriteMem8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT8 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT8 Data\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
+ Addr = ConvertStackAddr (VmPtr, Addr);\r
+ *(UINT8 *)Addr = Data;\r
return EFI_SUCCESS;\r
}\r
\r
**/\r
EFI_STATUS\r
VmWriteMem16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT16 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT16 Data\r
)\r
{\r
EFI_STATUS Status;\r
// Do a simple write if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT16))) {\r
- *(UINT16 *) Addr = Data;\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
+ 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
+ if ((Status = VmWriteMem8 (VmPtr, Addr + 1, (UINT8)(Data >> 8))) != EFI_SUCCESS) {\r
return Status;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Writes 32-bit data to memory address.\r
\r
**/\r
EFI_STATUS\r
VmWriteMem32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT32 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT32 Data\r
)\r
{\r
EFI_STATUS Status;\r
// Do a simple write if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT32))) {\r
- *(UINT32 *) Addr = Data;\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
+ 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
+ if ((Status = VmWriteMem16 (VmPtr, Addr + sizeof (UINT16), (UINT16)(Data >> 16))) != EFI_SUCCESS) {\r
return Status;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Writes 64-bit data to memory address.\r
\r
**/\r
EFI_STATUS\r
VmWriteMem64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINT64 Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINT64 Data\r
)\r
{\r
EFI_STATUS Status;\r
// Do a simple write if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT64))) {\r
- *(UINT64 *) Addr = Data;\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
+ if ((Status = VmWriteMem32 (VmPtr, Addr, (UINT32)Data)) != EFI_SUCCESS) {\r
return Status;\r
}\r
\r
MemoryFence ();\r
- if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32) RShiftU64(Data, 32))) != EFI_SUCCESS) {\r
+ if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32)RShiftU64 (Data, 32))) != EFI_SUCCESS) {\r
return Status;\r
}\r
\r
return EFI_SUCCESS;\r
}\r
\r
-\r
/**\r
Writes UINTN data to memory address.\r
\r
**/\r
EFI_STATUS\r
VmWriteMemN (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr,\r
- IN UINTN Data\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr,\r
+ IN UINTN Data\r
)\r
{\r
EFI_STATUS Status;\r
// Do a simple write if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINTN))) {\r
- *(UINTN *) Addr = Data;\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
+ Status = VmWriteMem32 (VmPtr, Addr + Index * sizeof (UINT32), (UINT32)Data);\r
MemoryFence ();\r
- Data = (UINTN) RShiftU64 ((UINT64)Data, 32);\r
+ Data = (UINTN)RShiftU64 ((UINT64)Data, 32);\r
}\r
}\r
\r
return Status;\r
}\r
\r
-\r
/**\r
Reads 8-bit immediate value at the offset.\r
\r
**/\r
INT8\r
VmReadImmed8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
)\r
{\r
//\r
// Simply return the data in flat memory space\r
//\r
- return * (INT8 *) (VmPtr->Ip + Offset);\r
+ return *(INT8 *)(VmPtr->Ip + Offset);\r
}\r
\r
/**\r
**/\r
INT16\r
VmReadImmed16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\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
+ 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
VmPtr\r
);\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- return (INT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));\r
+ return (INT16)(*(UINT8 *)(VmPtr->Ip + Offset) + (*(UINT8 *)(VmPtr->Ip + Offset + 1) << 8));\r
}\r
\r
-\r
/**\r
Reads 32-bit immediate value at the offset.\r
\r
**/\r
INT32\r
VmReadImmed32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\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 * (INT32 *) (VmPtr->Ip + Offset);\r
+ if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT32))) {\r
+ return *(INT32 *)(VmPtr->Ip + Offset);\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
+ Data = (UINT32)VmReadCode16 (VmPtr, Offset);\r
Data |= (UINT32)(VmReadCode16 (VmPtr, Offset + 2) << 16);\r
return Data;\r
}\r
\r
-\r
/**\r
Reads 64-bit immediate value at the offset.\r
\r
**/\r
INT64\r
VmReadImmed64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
)\r
{\r
UINT64 Data64;\r
//\r
// Read direct if aligned\r
//\r
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {\r
- return * (UINT64 *) (VmPtr->Ip + Offset);\r
+ if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT64))) {\r
+ return *(UINT64 *)(VmPtr->Ip + Offset);\r
}\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
+ 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
-\r
/**\r
Reads 16-bit unsigned data from the code stream.\r
\r
**/\r
UINT16\r
VmReadCode16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\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 (UINT16))) {\r
- return * (UINT16 *) (VmPtr->Ip + Offset);\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
VmPtr\r
);\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- return (UINT16) (*(UINT8 *) (VmPtr->Ip + Offset) + (*(UINT8 *) (VmPtr->Ip + Offset + 1) << 8));\r
+ return (UINT16)(*(UINT8 *)(VmPtr->Ip + Offset) + (*(UINT8 *)(VmPtr->Ip + Offset + 1) << 8));\r
}\r
\r
-\r
/**\r
Reads 32-bit unsigned data from the code stream.\r
\r
**/\r
UINT32\r
VmReadCode32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\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 * (UINT32 *) (VmPtr->Ip + Offset);\r
+ if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT32))) {\r
+ return *(UINT32 *)(VmPtr->Ip + Offset);\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
+ Data = (UINT32)VmReadCode16 (VmPtr, Offset);\r
Data |= (VmReadCode16 (VmPtr, Offset + 2) << 16);\r
return Data;\r
}\r
\r
-\r
/**\r
Reads 64-bit unsigned data from the code stream.\r
\r
**/\r
UINT64\r
VmReadCode64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINT32 Offset\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT32 Offset\r
)\r
{\r
UINT64 Data64;\r
//\r
// Read direct if aligned\r
//\r
- if (IS_ALIGNED ((UINTN) VmPtr->Ip + Offset, sizeof (UINT64))) {\r
- return * (UINT64 *) (VmPtr->Ip + Offset);\r
+ if (IS_ALIGNED ((UINTN)VmPtr->Ip + Offset, sizeof (UINT64))) {\r
+ return *(UINT64 *)(VmPtr->Ip + Offset);\r
}\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
+ 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
-\r
/**\r
Reads 8-bit data form the memory address.\r
\r
**/\r
UINT8\r
VmReadMem8 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
//\r
//\r
// Simply return the data in flat memory space\r
//\r
- return * (UINT8 *) Addr;\r
+ return *(UINT8 *)Addr;\r
}\r
\r
/**\r
**/\r
UINT16\r
VmReadMem16 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
//\r
// Read direct if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT16))) {\r
- return * (UINT16 *) Addr;\r
+ return *(UINT16 *)Addr;\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- return (UINT16) (*(UINT8 *) Addr + (*(UINT8 *) (Addr + 1) << 8));\r
+ return (UINT16)(*(UINT8 *)Addr + (*(UINT8 *)(Addr + 1) << 8));\r
}\r
\r
/**\r
**/\r
UINT32\r
VmReadMem32 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
UINT32 Data;\r
// Read direct if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT32))) {\r
- return * (UINT32 *) Addr;\r
+ return *(UINT32 *)Addr;\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
- Data = (UINT32) VmReadMem16 (VmPtr, Addr);\r
+ Data = (UINT32)VmReadMem16 (VmPtr, Addr);\r
Data |= (VmReadMem16 (VmPtr, Addr + 2) << 16);\r
return Data;\r
}\r
**/\r
UINT64\r
VmReadMem64 (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
UINT64 Data;\r
// Read direct if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINT64))) {\r
- return * (UINT64 *) Addr;\r
+ return *(UINT64 *)Addr;\r
}\r
+\r
//\r
// Return unaligned data. Assume little endian.\r
//\r
Data32 = VmReadMem32 (VmPtr, Addr);\r
- Data = (UINT64) VmReadMem32 (VmPtr, Addr + sizeof (UINT32));\r
- Data = LShiftU64 (Data, 32) | Data32;\r
+ Data = (UINT64)VmReadMem32 (VmPtr, Addr + sizeof (UINT32));\r
+ Data = LShiftU64 (Data, 32) | Data32;\r
return Data;\r
}\r
\r
-\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
UINTN\r
ConvertStackAddr (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
- ASSERT(((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));\r
+ ASSERT (((Addr < VmPtr->LowStackTop) || (Addr > VmPtr->HighStackBottom)));\r
return Addr;\r
}\r
\r
-\r
/**\r
Read a natural value from memory. May or may not be aligned.\r
\r
**/\r
UINTN\r
VmReadMemN (\r
- IN VM_CONTEXT *VmPtr,\r
- IN UINTN Addr\r
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINTN Addr\r
)\r
{\r
- UINTN Data;\r
+ UINTN Data;\r
volatile UINT32 Size;\r
- UINT8 *FromPtr;\r
- UINT8 *ToPtr;\r
+ UINT8 *FromPtr;\r
+ UINT8 *ToPtr;\r
+\r
//\r
// Convert the address if it's in the stack gap\r
//\r
// Read direct if aligned\r
//\r
if (IS_ALIGNED (Addr, sizeof (UINTN))) {\r
- return * (UINTN *) Addr;\r
+ return *(UINTN *)Addr;\r
}\r
+\r
//\r
// Return unaligned data\r
//\r
Data = 0;\r
- FromPtr = (UINT8 *) Addr;\r
- ToPtr = (UINT8 *) &Data;\r
+ FromPtr = (UINT8 *)Addr;\r
+ ToPtr = (UINT8 *)&Data;\r
\r
for (Size = 0; Size < sizeof (Data); Size++) {\r
*ToPtr = *FromPtr;\r
VOID\r
)\r
{\r
- return (UINT64) (((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));\r
+ return (UINT64)(((VM_MAJOR_VERSION & 0xFFFF) << 16) | ((VM_MINOR_VERSION & 0xFFFF)));\r
}\r
projects / mirror_edk2.git / blobdiff