/** @file\r
Contains code that implements the virtual machine.\r
\r
-Copyright (c) 2006 - 2008, Intel Corporation\r
-All rights reserved. This program and the accompanying materials\r
+Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>\r
+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
#include "EbcInt.h"\r
#include "EbcExecute.h"\r
+#include "EbcDebuggerHook.h"\r
\r
\r
//\r
b14:12 - number of bits in this index assigned to natural units (=a)\r
ba:11 - constant units = ConstUnits\r
b0:a - natural units = NaturalUnits\r
- \r
+\r
Given this info, the offset can be computed by:\r
offset = sign_bit * (ConstUnits + NaturalUnits * 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
+ Min offset is achieved with index =\r
\r
@param VmPtr A pointer to VM context.\r
@param CodeOffset Offset from IP of the location of the 16-bit index\r
@return The decoded offset.\r
\r
**/\r
-STATIC\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
@return Converted index per EBC VM specification.\r
\r
**/\r
-STATIC\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
@return Converted index per EBC VM specification\r
\r
**/\r
-STATIC\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
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 8-bit value from the memory adress.\r
+ @return The 8-bit value from the memory address.\r
\r
**/\r
-STATIC\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
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 16-bit value from the memory adress.\r
+ @return The 16-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT16\r
VmReadMem16 (\r
IN VM_CONTEXT *VmPtr,\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 32-bit value from the memory adress.\r
+ @return The 32-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT32\r
VmReadMem32 (\r
IN VM_CONTEXT *VmPtr,\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 64-bit value from the memory adress.\r
+ @return The 64-bit value from the memory address.\r
\r
**/\r
-STATIC\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
@return The natural value at address Addr.\r
\r
**/\r
-STATIC\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
Writes 8-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\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
Writes 16-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\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
Writes 32-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\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
- Reads 16-bit unsinged data from the code stream.\r
+ Reads 16-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 16-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT16\r
VmReadCode16 (\r
IN VM_CONTEXT *VmPtr,\r
);\r
\r
/**\r
- Reads 32-bit unsinged data from the code stream.\r
+ Reads 32-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 32-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT32\r
VmReadCode32 (\r
IN VM_CONTEXT *VmPtr,\r
);\r
\r
/**\r
- Reads 64-bit unsinged data from the code stream.\r
+ Reads 64-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 64-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT64\r
VmReadCode64 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT8\r
VmReadImmed8 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT16\r
VmReadImmed16 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT32\r
VmReadImmed32 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT64\r
VmReadImmed64 (\r
IN VM_CONTEXT *VmPtr,\r
adjust for the stack gap and return the modified address.\r
\r
**/\r
-STATIC\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
@param VmPtr A pointer to VM context.\r
@param IsSignedOp Indicates whether the operand is signed or not.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteDataManip (\r
IN VM_CONTEXT *VmPtr,\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteBREAK (\r
IN VM_CONTEXT *VmPtr\r
Instruction syntax:\r
JMP64{cs|cc} Immed64\r
JMP32{cs|cc} {@}R1 {Immed32|Index32}\r
- \r
+\r
Encoding:\r
b0.7 - immediate data present\r
b0.6 - 1 = 64 bit immediate data\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteJMP (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteJMP8 (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCALL (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteRET (\r
IN VM_CONTEXT *VmPtr\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCMP (\r
IN VM_CONTEXT *VmPtr\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCMPI (\r
IN VM_CONTEXT *VmPtr\r
Execute the MOVxx instructions.\r
\r
Instruction format:\r
- \r
+\r
MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32}\r
MOVqq {@}R1 {Index64}, {@}R2 {Index64}\r
- \r
+\r
Copies contents of [R2] -> [R1], zero extending where required.\r
- \r
+\r
First character indicates the size of the move.\r
Second character indicates the size of the index(s).\r
- \r
+\r
Invalid to have R1 direct with index.\r
\r
@param VmPtr A pointer to a VM context.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVxx (\r
IN VM_CONTEXT *VmPtr\r
Execute the EBC MOVI.\r
\r
Instruction syntax:\r
- \r
+\r
MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
- \r
+\r
First variable character specifies the move size\r
Second variable character specifies size of the immediate data\r
- \r
+\r
Sign-extend the immediate data to the size of the operation, and zero-extend\r
if storing to a register.\r
- \r
+\r
Operand1 direct with index/immed is invalid.\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVI (\r
IN VM_CONTEXT *VmPtr\r
index value into a register or memory location.\r
\r
Instruction syntax:\r
- \r
+\r
MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVIn (\r
IN VM_CONTEXT *VmPtr\r
Dest <- Ip + ImmData\r
\r
Instruction syntax:\r
- \r
+\r
MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVREL (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePUSHn (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePUSH (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePOPn (\r
IN VM_CONTEXT *VmPtr\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePOP (\r
IN VM_CONTEXT *VmPtr\r
\r
@param VmPtr A pointer to VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteSignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
\r
@param VmPtr A pointer to VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteUnsignedDataManip (\r
- IN VM_CONTEXT *VmPtr\r
+ IN VM_CONTEXT *VmPtr\r
);\r
\r
/**\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteLOADSP (\r
IN VM_CONTEXT *VmPtr\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteSTORESP (\r
IN VM_CONTEXT *VmPtr\r
is a register.\r
\r
Instruction syntax:\r
- \r
+\r
MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32}\r
- \r
+\r
0:7 1=>operand1 index present\r
0:6 1=>operand2 index present\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVsnd (\r
IN VM_CONTEXT *VmPtr\r
is a register.\r
\r
Instruction syntax:\r
- \r
+\r
MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16}\r
- \r
+\r
0:7 1=>operand1 index present\r
0:6 1=>operand2 index present\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVsnw (\r
IN VM_CONTEXT *VmPtr\r
@return ~Op2\r
\r
**/\r
-STATIC\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
@return Op2 * -1\r
\r
**/\r
-STATIC\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
@return Op1 + Op2\r
\r
**/\r
-STATIC\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
@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
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
@return Op1 * Op2\r
\r
**/\r
-STATIC\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
@return (unsigned)Op1 * (unsigned)Op2\r
\r
**/\r
-STATIC\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
@return Op1 / Op2\r
\r
**/\r
-STATIC\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
@return (unsigned)Op1 / (unsigned)Op2\r
\r
**/\r
-STATIC\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
@return Op1 MODULUS Op2\r
\r
**/\r
-STATIC\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
@return Op1 UNSIGNED_MODULUS Op2\r
\r
**/\r
-STATIC\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
@return Op1 AND Op2\r
\r
**/\r
-STATIC\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
@return Op1 OR Op2\r
\r
**/\r
-STATIC\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
@return Op1 XOR Op2\r
\r
**/\r
-STATIC\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
@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
+ IN VM_CONTEXT *VmPtr,\r
+ IN UINT64 Op1,\r
+ IN UINT64 Op2\r
);\r
\r
/**\r
@return Op1 >> Op2 (unsigned operands)\r
\r
**/\r
-STATIC\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
@return Op1 >> Op2 (signed)\r
\r
**/\r
-STATIC\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
@return (INT64)(INT8)Op2\r
\r
**/\r
-STATIC\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
@return (INT64)(INT16)Op2\r
\r
**/\r
-STATIC\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
@return (INT64)(INT32)Op2\r
\r
**/\r
-STATIC\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
-STATIC CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {\r
+CONST DATA_MANIP_EXEC_FUNCTION mDataManipDispatchTable[] = {\r
ExecuteNOT,\r
ExecuteNEG,\r
ExecuteADD,\r
ExecuteEXTNDD,\r
};\r
\r
-STATIC CONST VM_TABLE_ENTRY mVmOpcodeTable[] = {\r
+CONST VM_TABLE_ENTRY mVmOpcodeTable[] = {\r
{ ExecuteBREAK }, // opcode 0x00\r
{ ExecuteJMP }, // opcode 0x01\r
{ ExecuteJMP8 }, // opcode 0x02\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
+ { 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
-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
+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
\r
**/\r
EFI_STATUS\r
+EFIAPI\r
EbcExecuteInstructions (\r
IN EFI_EBC_VM_TEST_PROTOCOL *This,\r
IN VM_CONTEXT *VmPtr,\r
// call it if it's not null.\r
//\r
while (InstructionsLeft != 0) {\r
- ExecFunc = (UINTN) mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction;\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
- mVmOpcodeTable[(*VmPtr->Ip & 0x3F)].ExecuteFunction (VmPtr);\r
+ mVmOpcodeTable[(*VmPtr->Ip & OPCODE_M_OPCODE)].ExecuteFunction (VmPtr);\r
*InstructionCount = *InstructionCount + 1;\r
}\r
\r
StackCorrupted = 1;\r
}\r
\r
- VmPtr->FramePtr = (VOID *) ((UINT8 *) (UINTN) VmPtr->R[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
- &mEbcSimpleDebuggerProtocolGuid,\r
+ &gEfiEbcSimpleDebuggerProtocolGuid,\r
NULL,\r
(VOID **) &EbcSimpleDebugger\r
);\r
// instruction sets it if it runs out of stack.\r
//\r
VmPtr->StopFlags = 0;\r
- while (!(VmPtr->StopFlags & STOPFLAG_APP_DONE)) {\r
+ while ((VmPtr->StopFlags & STOPFLAG_APP_DONE) == 0) {\r
//\r
// If we've found a simple debugger protocol, call it\r
//\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
Status = EFI_UNSUPPORTED;\r
goto Done;\r
}\r
+\r
+ EbcDebuggerHookExecuteStart (VmPtr);\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
+ EbcDebuggerHookExecuteEnd (VmPtr);\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
// Make sure stack has not been corrupted. Only report it once though.\r
//\r
- if (!StackCorrupted && (*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 && ((UINT64)VmPtr->R[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {\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
Execute the MOVxx instructions.\r
\r
Instruction format:\r
- \r
+\r
MOV[b|w|d|q|n]{w|d} {@}R1 {Index16|32}, {@}R2 {Index16|32}\r
MOVqq {@}R1 {Index64}, {@}R2 {Index64}\r
- \r
+\r
Copies contents of [R2] -> [R1], zero extending where required.\r
- \r
+\r
First character indicates the size of the move.\r
Second character indicates the size of the index(s).\r
- \r
+\r
Invalid to have R1 direct with index.\r
\r
@param VmPtr A pointer to a VM context.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVxx (\r
IN VM_CONTEXT *VmPtr\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
+ if ((Opcode & (OPCODE_M_IMMED_OP1 | OPCODE_M_IMMED_OP2)) != 0) {\r
//\r
// Determine size of the index from the opcode. Then get it.\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
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
Index64Op1 = (INT64) Index16;\r
Size += sizeof (UINT16);\r
}\r
\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, Size);\r
Index64Op2 = (INT64) Index16;\r
Size += sizeof (UINT16);\r
//\r
// MOVBD, MOVWD, MOVDD, MOVQD, and MOVND have 32-bit immediate index\r
//\r
- if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
Index32 = VmReadIndex32 (VmPtr, 2);\r
Index64Op1 = (INT64) Index32;\r
Size += sizeof (UINT32);\r
}\r
\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
Index32 = VmReadIndex32 (VmPtr, Size);\r
Index64Op2 = (INT64) Index32;\r
Size += sizeof (UINT32);\r
//\r
// MOVqq -- only form with a 64-bit index\r
//\r
- if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
Index64Op1 = VmReadIndex64 (VmPtr, 2);\r
Size += sizeof (UINT64);\r
}\r
\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
Index64Op2 = VmReadIndex64 (VmPtr, Size);\r
Size += sizeof (UINT64);\r
}\r
//\r
// Indirect form @R2. Compute address of operand2\r
//\r
- Source = (UINTN) (VmPtr->R[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
// Not indirect source: MOVxx {@}Rx, Ry [Index]\r
//\r
- Data64 = VmPtr->R[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
//\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\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
//\r
// Reuse the Source variable to now be dest.\r
//\r
- Source = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index64Op1);\r
+ Source = (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index64Op1);\r
//\r
// Do the write based on the size\r
//\r
// Operand1 direct.\r
// Make sure we didn't have an index on operand1.\r
//\r
- if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_FATAL,\r
// Direct storage in register. Clear unused bits and store back to\r
// register.\r
//\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Data64 & DataMask;\r
}\r
//\r
// Advance the instruction pointer\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteBREAK (\r
IN VM_CONTEXT *VmPtr\r
)\r
{\r
+ EFI_STATUS Status;\r
UINT8 Operands;\r
VOID *EbcEntryPoint;\r
VOID *Thunk;\r
UINT64 U64EbcEntryPoint;\r
INT32 Offset;\r
\r
+ Thunk = NULL;\r
Operands = GETOPERANDS (VmPtr);\r
switch (Operands) {\r
//\r
// 16-8 = Major version\r
// 7-0 = Minor version\r
//\r
- VmPtr->R[7] = GetVmVersion ();\r
+ VmPtr->Gpr[7] = GetVmVersion ();\r
break;\r
\r
//\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
+ 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
- EbcCreateThunks (VmPtr->ImageHandle, EbcEntryPoint, &Thunk, 0);\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->R[7], (UINT64) (UINTN) Thunk);\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->R[7];\r
+ VmPtr->CompilerVersion = (UINT32) VmPtr->Gpr[7];\r
//\r
// Check compiler version against VM version?\r
//\r
Instruction syntax:\r
JMP64{cs|cc} Immed64\r
JMP32{cs|cc} {@}R1 {Immed32|Index32}\r
- \r
+\r
Encoding:\r
b0.7 - immediate data present\r
b0.6 - 1 = 64 bit immediate data\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteJMP (\r
IN VM_CONTEXT *VmPtr\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
+ CompareSet = (UINT8) (((Operand & JMP_M_CS) != 0) ? 1 : 0);\r
ConditionFlag = (UINT8) VMFLAG_ISSET (VmPtr, VMFLAGS_CC);\r
- if (Operand & CONDITION_M_CONDITIONAL) {\r
+ if ((Operand & CONDITION_M_CONDITIONAL) != 0) {\r
if (CompareSet != ConditionFlag) {\r
+ EbcDebuggerHookJMPStart (VmPtr);\r
VmPtr->Ip += Size;\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
return EFI_SUCCESS;\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
+ if ((Opcode & OPCODE_M_IMMDATA64) != 0) {\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
+ if ((Opcode & OPCODE_M_IMMDATA) == 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_ERROR,\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
+ Data64 = (UINT64) VmReadImmed64 (VmPtr, 2);\r
if (!IS_ALIGNED ((UINTN) Data64, sizeof (UINT16))) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_ALIGNMENT_CHECK,\r
//\r
// Take jump -- relative or absolute\r
//\r
- if (Operand & JMP_M_RELATIVE) {\r
+ EbcDebuggerHookJMPStart (VmPtr);\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Data64 + Size;\r
} else {\r
VmPtr->Ip = (VMIP) (UINTN) Data64;\r
}\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
\r
return EFI_SUCCESS;\r
}\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 ((Opcode & OPCODE_M_IMMDATA) != 0) {\r
if (OPERAND1_INDIRECT (Operand)) {\r
Index32 = VmReadIndex32 (VmPtr, 2);\r
} else {\r
if (OPERAND1_REGNUM (Operand) == 0) {\r
Data64 = 0;\r
} else {\r
- Data64 = OPERAND1_REGDATA (VmPtr, Operand);\r
+ Data64 = (UINT64) OPERAND1_REGDATA (VmPtr, Operand);\r
}\r
//\r
// Decode the forms\r
return EFI_UNSUPPORTED;\r
}\r
\r
- if (Operand & JMP_M_RELATIVE) {\r
+ EbcDebuggerHookJMPStart (VmPtr);\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Addr + Size;\r
} else {\r
VmPtr->Ip = (VMIP) Addr;\r
}\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
+\r
} else {\r
//\r
// Form: JMP32 Rx {Immed32}\r
return EFI_UNSUPPORTED;\r
}\r
\r
- if (Operand & JMP_M_RELATIVE) {\r
+ EbcDebuggerHookJMPStart (VmPtr);\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Addr + Size;\r
} else {\r
VmPtr->Ip = (VMIP) Addr;\r
}\r
+ EbcDebuggerHookJMPEnd (VmPtr);\r
+\r
}\r
\r
return EFI_SUCCESS;\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteJMP8 (\r
IN VM_CONTEXT *VmPtr\r
// Decode instruction.\r
//\r
Opcode = GETOPCODE (VmPtr);\r
- CompareSet = (UINT8) ((Opcode & JMP_M_CS) ? 1 : 0);\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
//\r
- if (Opcode & CONDITION_M_CONDITIONAL) {\r
+ if ((Opcode & CONDITION_M_CONDITIONAL) != 0) {\r
if (CompareSet != ConditionFlag) {\r
+ EbcDebuggerHookJMP8Start (VmPtr);\r
VmPtr->Ip += 2;\r
+ EbcDebuggerHookJMP8End (VmPtr);\r
return EFI_SUCCESS;\r
}\r
}\r
//\r
// Want to check for offset == -2 and then raise an exception?\r
//\r
+ EbcDebuggerHookJMP8Start (VmPtr);\r
VmPtr->Ip += (Offset * 2) + 2;\r
+ EbcDebuggerHookJMP8End (VmPtr);\r
return EFI_SUCCESS;\r
}\r
\r
Execute the EBC MOVI.\r
\r
Instruction syntax:\r
- \r
+\r
MOVI[b|w|d|q][w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
- \r
+\r
First variable character specifies the move size\r
Second variable character specifies size of the immediate data\r
- \r
+\r
Sign-extend the immediate data to the size of the operation, and zero-extend\r
if storing to a register.\r
- \r
+\r
Operand1 direct with index/immed is invalid.\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVI (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get the index (16-bit) if present\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
Size = 4;\r
} else {\r
//\r
// Operand1 direct. Make sure it didn't have an index.\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_FATAL,\r
Mask64 = (UINT64)~0;\r
}\r
\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmData64 & Mask64;\r
+ VmPtr->Gpr[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
+ Op1 = (UINT64) VmPtr->Gpr[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
} else if ((Operands & MOVI_M_MOVEWIDTH) == MOVI_MOVEWIDTH32) {\r
VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) ImmData64);\r
} else {\r
- VmWriteMem64 (VmPtr, (UINTN) Op1, ImmData64);\r
+ VmWriteMem64 (VmPtr, (UINTN) Op1, (UINT64) ImmData64);\r
}\r
}\r
//\r
index value into a register or memory location.\r
\r
Instruction syntax:\r
- \r
+\r
MOVIn[w|d|q] {@}R1 {Index16}, Index16|32|64\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVIn (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get the operand1 index (16-bit) if present\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
Size = 4;\r
} else {\r
// Check for MOVIn R1 Index16, Immed (not indirect, with index), which\r
// is illegal\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_FATAL,\r
return EFI_UNSUPPORTED;\r
}\r
\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] = ImmedIndex64;\r
+ VmPtr->Gpr[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
+ Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
+ VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN)(INTN) ImmedIndex64);\r
}\r
//\r
// Advance the instruction pointer\r
Dest <- Ip + ImmData\r
\r
Instruction syntax:\r
- \r
+\r
MOVREL[w|d|q] {@}R1 {Index16}, ImmData16|32|64\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVREL (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get the Operand 1 index (16-bit) if present\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
Size = 4;\r
} else {\r
//\r
// Check for illegal combination of operand1 direct with immediate data\r
//\r
- if (Operands & MOVI_M_IMMDATA) {\r
+ if ((Operands & MOVI_M_IMMDATA) != 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_FATAL,\r
return EFI_UNSUPPORTED;\r
}\r
\r
- VmPtr->R[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->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16;\r
VmWriteMemN (VmPtr, (UINTN) Op1, (UINTN) Op2);\r
}\r
//\r
is a register.\r
\r
Instruction syntax:\r
- \r
+\r
MOVsnw {@}R1 {Index16}, {@}R2 {Index16|Immed16}\r
- \r
+\r
0:7 1=>operand1 index present\r
0:6 1=>operand2 index present\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVsnw (\r
IN VM_CONTEXT *VmPtr\r
// Get the indexes if present.\r
//\r
Size = 2;\r
- if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) !=0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Op1Index = VmReadIndex16 (VmPtr, 2);\r
} else {\r
Size += sizeof (UINT16);\r
}\r
\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
if (OPERAND2_INDIRECT (Operands)) {\r
Op2Index = VmReadIndex16 (VmPtr, Size);\r
} else {\r
//\r
// Get the data from the source.\r
//\r
- Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index));\r
+ Op2 = (UINT64)(INT64)(INTN)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);\r
if (OPERAND2_INDIRECT (Operands)) {\r
- Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2);\r
+ Op2 = (UINT64)(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
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;\r
} else {\r
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
}\r
//\r
// Advance the instruction pointer\r
is a register.\r
\r
Instruction syntax:\r
- \r
+\r
MOVsnd {@}R1 {Indx32}, {@}R2 {Index32|Immed32}\r
- \r
+\r
0:7 1=>operand1 index present\r
0:6 1=>operand2 index present\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteMOVsnd (\r
IN VM_CONTEXT *VmPtr\r
// Get the indexes if present.\r
//\r
Size = 2;\r
- if (Opcode & OPCODE_M_IMMED_OP1) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP1) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Op1Index = VmReadIndex32 (VmPtr, 2);\r
} else {\r
Size += sizeof (UINT32);\r
}\r
\r
- if (Opcode & OPCODE_M_IMMED_OP2) {\r
+ if ((Opcode & OPCODE_M_IMMED_OP2) != 0) {\r
if (OPERAND2_INDIRECT (Operands)) {\r
Op2Index = VmReadIndex32 (VmPtr, Size);\r
} else {\r
//\r
// Get the data from the source.\r
//\r
- Op2 = (INT64) ((INTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Op2Index));\r
+ Op2 = (UINT64)(INT64)(INTN)(INT64)(VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Op2Index);\r
if (OPERAND2_INDIRECT (Operands)) {\r
- Op2 = (INT64) (INTN) VmReadMemN (VmPtr, (UINTN) Op2);\r
+ Op2 = (UINT64)(INT64)(INTN)(INT64)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
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;\r
} else {\r
- VmWriteMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Op1Index), (UINTN) Op2);\r
}\r
//\r
// Advance the instruction pointer\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePUSHn (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get index if present\r
//\r
- if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
} else {\r
// Get the data to push\r
//\r
if (OPERAND1_INDIRECT (Operands)) {\r
- DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ DataN = VmReadMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- DataN = (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16);\r
+ DataN = (UINTN) (VmPtr->Gpr[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
+ VmPtr->Gpr[0] -= sizeof (UINTN);\r
+ VmWriteMemN (VmPtr, (UINTN) VmPtr->Gpr[0], DataN);\r
return EFI_SUCCESS;\r
}\r
\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePUSH (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get immediate index if present, then advance the IP.\r
//\r
- if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
} else {\r
//\r
// Get the data to push\r
//\r
- if (Opcode & PUSHPOP_M_64) {\r
+ if ((Opcode & PUSHPOP_M_64) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
- Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ Data64 = VmReadMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- Data64 = (UINT64) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Data64 = (UINT64) VmPtr->Gpr[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
+ VmPtr->Gpr[0] -= sizeof (UINT64);\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->R[OPERAND1_REGNUM (Operands)] + Index16));\r
+ Data32 = VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16));\r
} else {\r
- Data32 = (UINT32) VmPtr->R[OPERAND1_REGNUM (Operands)] + Index16;\r
+ Data32 = (UINT32) VmPtr->Gpr[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
+ VmPtr->Gpr[0] -= sizeof (UINT32);\r
+ VmWriteMem32 (VmPtr, (UINTN) VmPtr->Gpr[0], Data32);\r
}\r
\r
return EFI_SUCCESS;\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePOPn (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get immediate data if present, and advance the IP\r
//\r
- if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
} else {\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
+ 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->R[OPERAND1_REGNUM (Operands)] + Index16), DataN);\r
+ VmWriteMemN (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), DataN);\r
} else {\r
- VmPtr->R[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
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecutePOP (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get immediate data if present, and advance the IP.\r
//\r
- if (Opcode & PUSHPOP_M_IMMDATA) {\r
+ if ((Opcode & PUSHPOP_M_IMMDATA) != 0) {\r
if (OPERAND1_INDIRECT (Operands)) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
} else {\r
//\r
// Get the data off the stack, then write it to the appropriate location\r
//\r
- if (Opcode & PUSHPOP_M_64) {\r
+ if ((Opcode & PUSHPOP_M_64) != 0) {\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
+ 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->R[OPERAND1_REGNUM (Operands)] + Index16), Data64);\r
+ VmWriteMem64 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data64);\r
} else {\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] = Data64 + Index16;\r
+ VmPtr->Gpr[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
+ 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->R[OPERAND1_REGNUM (Operands)] + Index16), Data32);\r
+ VmWriteMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND1_REGNUM (Operands)] + Index16), Data32);\r
} else {\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (INT64) Data32 + Index16;\r
}\r
}\r
\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCALL (\r
IN VM_CONTEXT *VmPtr\r
//\r
Opcode = GETOPCODE (VmPtr);\r
Operands = GETOPERANDS (VmPtr);\r
+\r
+ if ((Operands & OPERAND_M_NATIVE_CALL) != 0) {\r
+ EbcDebuggerHookCALLEXStart (VmPtr);\r
+ } else {\r
+ EbcDebuggerHookCALLStart (VmPtr);\r
+ }\r
+\r
//\r
// Assign these as well to avoid compiler warnings\r
//\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
+ if ((Opcode & OPCODE_M_IMMDATA) != 0) {\r
+ if ((Opcode & OPCODE_M_IMMDATA64) != 0) {\r
Immed64 = VmReadImmed64 (VmPtr, 2);\r
Size = 10;\r
} else {\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
+ 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
}\r
//\r
// If 64-bit data, then absolute jump only\r
//\r
- if (Opcode & OPCODE_M_IMMDATA64) {\r
+ if ((Opcode & OPCODE_M_IMMDATA64) != 0) {\r
//\r
// Native or EBC call?\r
//\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
+ 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->R[OPERAND1_REGNUM (Operands)];\r
+ Immed64 = (UINT64) (UINTN) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
}\r
//\r
// Get final address\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
+ if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {\r
VmPtr->Ip += Immed64 + Size;\r
} else {\r
VmPtr->Ip = (VMIP) (UINTN) Immed64;\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
+ if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {\r
+ EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->Gpr[0], FramePtr, Size);\r
} else {\r
- if (VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) {\r
+ if ((VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) != 0) {\r
CpuBreakpoint ();\r
}\r
\r
- EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->R[0], FramePtr, Size);\r
+ EbcLLCALLEX (VmPtr, (UINTN) Immed64, (UINTN) VmPtr->Gpr[0], FramePtr, Size);\r
}\r
}\r
}\r
\r
+ if ((Operands & OPERAND_M_NATIVE_CALL) != 0) {\r
+ EbcDebuggerHookCALLEXEnd (VmPtr);\r
+ } else {\r
+ EbcDebuggerHookCALLEnd (VmPtr);\r
+ }\r
+\r
return EFI_SUCCESS;\r
}\r
\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteRET (\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->R[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->R[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
//\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
+ 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
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCMP (\r
IN VM_CONTEXT *VmPtr\r
//\r
// Get the register data we're going to compare to\r
//\r
- Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ Op1 = VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
//\r
// Get immediate data\r
//\r
- if (Opcode & OPCODE_M_IMMDATA) {\r
+ if ((Opcode & OPCODE_M_IMMDATA) != 0) {\r
if (OPERAND2_INDIRECT (Operands)) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
} else {\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
+ if ((Opcode & OPCODE_M_64BIT) != 0) {\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->R[OPERAND2_REGNUM (Operands)] + Index16)));\r
+ Op2 = (INT64) (UINT64) ((UINT32) VmReadMem32 (VmPtr, (UINTN) (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16)));\r
}\r
} else {\r
- Op2 = VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16;\r
+ Op2 = VmPtr->Gpr[OPERAND2_REGNUM (Operands)] + Index16;\r
}\r
//\r
// Now do the compare\r
//\r
Flag = 0;\r
- if (Opcode & OPCODE_M_64BIT) {\r
+ if ((Opcode & OPCODE_M_64BIT) != 0) {\r
//\r
// 64-bit compares\r
//\r
//\r
// Now set the flag accordingly for the comparison\r
//\r
- if (Flag) {\r
+ if (Flag != 0) {\r
VMFLAG_SET (VmPtr, VMFLAGS_CC);\r
} else {\r
- VMFLAG_CLEAR (VmPtr, VMFLAGS_CC);\r
+ VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);\r
}\r
//\r
// Advance the IP\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteCMPI (\r
IN VM_CONTEXT *VmPtr\r
// Get operand1 index if present\r
//\r
Size = 2;\r
- if (Operands & OPERAND_M_CMPI_INDEX) {\r
+ if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {\r
Index16 = VmReadIndex16 (VmPtr, 2);\r
Size += 2;\r
} else {\r
//\r
// Get operand1 data we're going to compare to\r
//\r
- Op1 = (INT64) VmPtr->R[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) {\r
+ if ((Opcode & OPCODE_M_CMPI64) != 0) {\r
Op1 = (INT64) VmReadMem64 (VmPtr, (UINTN) Op1 + Index16);\r
} else {\r
Op1 = (INT64) VmReadMem32 (VmPtr, (UINTN) Op1 + Index16);\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
+ if ((Operands & OPERAND_M_CMPI_INDEX) != 0) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INSTRUCTION_ENCODING,\r
EXCEPTION_FLAG_ERROR,\r
//\r
// Get immediate data -- 16- or 32-bit sign extended\r
//\r
- if (Opcode & OPCODE_M_CMPI32_DATA) {\r
+ if ((Opcode & OPCODE_M_CMPI32_DATA) != 0) {\r
Op2 = (INT64) VmReadImmed32 (VmPtr, Size);\r
Size += 4;\r
} else {\r
// Now do the compare\r
//\r
Flag = 0;\r
- if (Opcode & OPCODE_M_CMPI64) {\r
+ if ((Opcode & OPCODE_M_CMPI64) != 0) {\r
//\r
// 64 bit comparison\r
//\r
//\r
// Now set the flag accordingly for the comparison\r
//\r
- if (Flag) {\r
+ if (Flag != 0) {\r
VMFLAG_SET (VmPtr, VMFLAGS_CC);\r
} else {\r
- VMFLAG_CLEAR (VmPtr, VMFLAGS_CC);\r
+ VMFLAG_CLEAR (VmPtr, (UINT64)VMFLAGS_CC);\r
}\r
//\r
// Advance the IP\r
@return ~Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteNOT (\r
IN VM_CONTEXT *VmPtr,\r
@return Op2 * -1\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteNEG (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 + Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteADD (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 - Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteSUB (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return (UINT64) ((INT64) ((INT64) Op1 - (INT64) Op2));\r
} else {\r
- return (UINT64) ((INT64) ((INT32) Op1 - (INT32) Op2));\r
+ return (UINT64) ((INT64) ((INT32) ((INT32) Op1 - (INT32) Op2)));\r
}\r
}\r
\r
@return Op1 * Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteMUL (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return MultS64x64 ((INT64)Op1, (INT64)Op2);\r
} else {\r
- return (UINT64) ((INT64) ((INT32) Op1 * (INT32) Op2));\r
+ return (UINT64) ((INT64) ((INT32) ((INT32) Op1 * (INT32) Op2)));\r
}\r
}\r
\r
@return (unsigned)Op1 * (unsigned)Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteMULU (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return MultU64x64 (Op1, Op2);\r
} else {\r
- return (UINT64) ((UINT32) Op1 * (UINT32) Op2);\r
+ return (UINT64) ((UINT32) ((UINT32) Op1 * (UINT32) Op2));\r
}\r
}\r
\r
@return Op1 / Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteDIV (\r
IN VM_CONTEXT *VmPtr,\r
\r
return 0;\r
} else {\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return (UINT64) (DivS64x64Remainder (Op1, Op2, &Remainder));\r
} else {\r
return (UINT64) ((INT64) ((INT32) Op1 / (INT32) Op2));\r
@return (unsigned)Op1 / (unsigned)Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteDIVU (\r
IN VM_CONTEXT *VmPtr,\r
//\r
// Get the destination register\r
//\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
- return (UINT64) (DivU64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder));\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
+ return (UINT64) (DivU64x64Remainder (Op1, Op2, &Remainder));\r
} else {\r
return (UINT64) ((UINT32) Op1 / (UINT32) Op2);\r
}\r
@return Op1 MODULUS Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteMOD (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 UNSIGNED_MODULUS Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteMODU (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 AND Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteAND (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 OR Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteOR (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 XOR Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteXOR (\r
IN VM_CONTEXT *VmPtr,\r
@return Op1 << Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteSHL (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\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 Op1 >> Op2 (unsigned operands)\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteSHR (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\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 Op1 >> Op2 (signed)\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteASHR (\r
IN VM_CONTEXT *VmPtr,\r
IN UINT64 Op2\r
)\r
{\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\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 (INT64)(INT8)Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteEXTNDB (\r
IN VM_CONTEXT *VmPtr,\r
@return (INT64)(INT16)Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteEXTNDW (\r
IN VM_CONTEXT *VmPtr,\r
@return (INT64)(INT32)Op2\r
\r
**/\r
-STATIC\r
UINT64\r
ExecuteEXTNDD (\r
IN VM_CONTEXT *VmPtr,\r
\r
@param VmPtr A pointer to VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteSignedDataManip (\r
IN VM_CONTEXT *VmPtr\r
\r
@param VmPtr A pointer to VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteUnsignedDataManip (\r
IN VM_CONTEXT *VmPtr\r
@param VmPtr A pointer to VM context.\r
@param IsSignedOp Indicates whether the operand is signed or not.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteDataManip (\r
IN VM_CONTEXT *VmPtr,\r
UINT8 Size;\r
UINT64 Op1;\r
UINT64 Op2;\r
+ INTN DataManipDispatchTableIndex;\r
\r
//\r
// Get opcode and operands\r
//\r
// Determine if we have immediate data by the opcode\r
//\r
- if (Opcode & DATAMANIP_M_IMMDATA) {\r
+ if ((Opcode & DATAMANIP_M_IMMDATA) != 0) {\r
//\r
// Index16 if Ry is indirect, or Immed16 if Ry direct.\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
+ 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) {\r
+ if ((Opcode & DATAMANIP_M_64) != 0) {\r
Op2 = VmReadMem64 (VmPtr, (UINTN) Op2);\r
} else {\r
//\r
// Get operand1 (destination and sometimes also an actual operand)\r
// of form {@}R1\r
//\r
- Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
+ Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
if (OPERAND1_INDIRECT (Operands)) {\r
- if (Opcode & DATAMANIP_M_64) {\r
+ if ((Opcode & DATAMANIP_M_64) != 0) {\r
Op1 = VmReadMem64 (VmPtr, (UINTN) Op1);\r
} else {\r
if (IsSignedOp) {\r
//\r
// Dispatch to the computation function\r
//\r
- if (((Opcode & OPCODE_M_OPCODE) - OPCODE_NOT) >=\r
- (sizeof (mDataManipDispatchTable) / sizeof (mDataManipDispatchTable[0]))\r
- ) {\r
+ DataManipDispatchTableIndex = (Opcode & OPCODE_M_OPCODE) - OPCODE_NOT;\r
+ if ((DataManipDispatchTableIndex < 0) ||\r
+ (DataManipDispatchTableIndex >= ARRAY_SIZE (mDataManipDispatchTable))) {\r
EbcDebugSignalException (\r
EXCEPT_EBC_INVALID_OPCODE,\r
EXCEPTION_FLAG_ERROR,\r
VmPtr->Ip += Size;\r
return EFI_UNSUPPORTED;\r
} else {\r
- Op2 = mDataManipDispatchTable[(Opcode & OPCODE_M_OPCODE) - OPCODE_NOT](VmPtr, Op1, Op2);\r
+ Op2 = mDataManipDispatchTable[DataManipDispatchTableIndex](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
+ Op1 = (UINT64) VmPtr->Gpr[OPERAND1_REGNUM (Operands)];\r
+ if ((Opcode & DATAMANIP_M_64) != 0) {\r
VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);\r
} else {\r
VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);\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
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = Op2;\r
if ((Opcode & DATAMANIP_M_64) == 0) {\r
- VmPtr->R[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF;\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] &= 0xFFFFFFFF;\r
}\r
}\r
//\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteLOADSP (\r
IN VM_CONTEXT *VmPtr\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
+ VmPtr->Flags = (VmPtr->Flags &~VMFLAGS_ALL_VALID) | (VmPtr->Gpr[OPERAND2_REGNUM (Operands)] & VMFLAGS_ALL_VALID);\r
break;\r
\r
default:\r
\r
@param VmPtr A pointer to a VM context.\r
\r
- @retval EFI_UNSUPPORTED The opcodes/operands is not supported. \r
+ @retval EFI_UNSUPPORTED The opcodes/operands is not supported.\r
@retval EFI_SUCCESS The instruction is executed successfully.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
ExecuteSTORESP (\r
IN VM_CONTEXT *VmPtr\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
+ 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->R[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;\r
+ VmPtr->Gpr[OPERAND1_REGNUM (Operands)] = (UINT64) (UINTN) VmPtr->Ip + 2;\r
break;\r
\r
default:\r
b14:12 - number of bits in this index assigned to natural units (=a)\r
ba:11 - constant units = ConstUnits\r
b0:a - natural units = NaturalUnits\r
- \r
+\r
Given this info, the offset can be computed by:\r
offset = sign_bit * (ConstUnits + NaturalUnits * 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
+ Min offset is achieved with index =\r
\r
@param VmPtr A pointer to VM context.\r
@param CodeOffset Offset from IP of the location of the 16-bit index\r
@return The decoded offset.\r
\r
**/\r
-STATIC\r
INT16\r
VmReadIndex16 (\r
IN VM_CONTEXT *VmPtr,\r
//\r
// Now set the sign\r
//\r
- if (Index & 0x8000) {\r
+ if ((Index & 0x8000) != 0) {\r
//\r
// Do it the hard way to work around a bogus compiler warning\r
//\r
@return Converted index per EBC VM specification.\r
\r
**/\r
-STATIC\r
INT32\r
VmReadIndex32 (\r
IN VM_CONTEXT *VmPtr,\r
//\r
// Now set the sign\r
//\r
- if (Index & 0x80000000) {\r
+ if ((Index & 0x80000000) != 0) {\r
Offset = Offset * -1;\r
}\r
\r
@return Converted index per EBC VM specification\r
\r
**/\r
-STATIC\r
INT64\r
VmReadIndex64 (\r
IN VM_CONTEXT *VmPtr,\r
//\r
ConstUnits = ARShiftU64 (((Index &~0xF000000000000000ULL) & Mask), (UINTN)NBits);\r
\r
- Offset = MultU64x64 (NaturalUnits, sizeof (UINTN)) + ConstUnits;\r
+ Offset = MultU64x64 ((UINT64) NaturalUnits, sizeof (UINTN)) + ConstUnits;\r
\r
//\r
// Now set the sign\r
//\r
- if (Index & 0x8000000000000000ULL) {\r
+ if ((Index & 0x8000000000000000ULL) != 0) {\r
Offset = MultS64x64 (Offset, -1);\r
}\r
\r
\r
/**\r
Writes 8-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
VmWriteMem8 (\r
IN VM_CONTEXT *VmPtr,\r
\r
/**\r
Writes 16-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
VmWriteMem16 (\r
IN VM_CONTEXT *VmPtr,\r
\r
/**\r
Writes 32-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
-STATIC\r
EFI_STATUS\r
VmWriteMem32 (\r
IN VM_CONTEXT *VmPtr,\r
\r
/**\r
Writes 64-bit data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
)\r
{\r
EFI_STATUS Status;\r
- UINT32 Data32;\r
\r
//\r
// Convert the address if it's in the stack gap\r
}\r
\r
MemoryFence ();\r
- Data32 = (UINT32) (((UINT32 *) &Data)[1]);\r
- if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), Data32)) != EFI_SUCCESS) {\r
+ if ((Status = VmWriteMem32 (VmPtr, Addr + sizeof (UINT32), (UINT32) RShiftU64(Data, 32))) != EFI_SUCCESS) {\r
return Status;\r
}\r
\r
\r
/**\r
Writes UINTN data to memory address.\r
- \r
+\r
This routine is 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
[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
+ 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
@param VmPtr A pointer to a VM context.\r
- @param Addr Adddress to write to.\r
+ @param Addr Address to write to.\r
@param Data Value to write to Addr.\r
\r
- @retval EFI_SUCCESS The instruction is executed successfully. \r
+ @retval EFI_SUCCESS The instruction is executed successfully.\r
@retval Other Some error occurs when writing data to the address.\r
\r
**/\r
MemoryFence ();\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 Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT8\r
VmReadImmed8 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT16\r
VmReadImmed16 (\r
IN VM_CONTEXT *VmPtr,\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT32\r
VmReadImmed32 (\r
IN VM_CONTEXT *VmPtr,\r
//\r
// Return unaligned data\r
//\r
- Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
- Data |= (UINT32) (VmReadCode16 (VmPtr, Offset + 2) << 16);\r
+ Data = (UINT32) VmReadCode16 (VmPtr, Offset);\r
+ Data |= (UINT32)(VmReadCode16 (VmPtr, Offset + 2) << 16);\r
return Data;\r
}\r
\r
@return Signed data of the requested size from the specified address.\r
\r
**/\r
-STATIC\r
INT64\r
VmReadImmed64 (\r
IN VM_CONTEXT *VmPtr,\r
Ptr = (UINT8 *) &Data64;\r
Data32 = VmReadCode32 (VmPtr, Offset);\r
*(UINT32 *) Ptr = Data32;\r
- Ptr += sizeof (Data32);\r
+ Ptr += sizeof (Data32);\r
Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));\r
*(UINT32 *) Ptr = Data32;\r
return Data64;\r
\r
\r
/**\r
- Reads 16-bit unsinged data from the code stream.\r
+ Reads 16-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 16-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT16\r
VmReadCode16 (\r
IN VM_CONTEXT *VmPtr,\r
\r
\r
/**\r
- Reads 32-bit unsinged data from the code stream.\r
+ Reads 32-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 32-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT32\r
VmReadCode32 (\r
IN VM_CONTEXT *VmPtr,\r
\r
\r
/**\r
- Reads 64-bit unsinged data from the code stream.\r
+ Reads 64-bit unsigned data from the code stream.\r
\r
This routine provides the ability to read raw unsigned data from the code\r
stream.\r
@return The raw unsigned 64-bit value from the code stream.\r
\r
**/\r
-STATIC\r
UINT64\r
VmReadCode64 (\r
IN VM_CONTEXT *VmPtr,\r
Ptr = (UINT8 *) &Data64;\r
Data32 = VmReadCode32 (VmPtr, Offset);\r
*(UINT32 *) Ptr = Data32;\r
- Ptr += sizeof (Data32);\r
+ Ptr += sizeof (Data32);\r
Data32 = VmReadCode32 (VmPtr, Offset + sizeof (UINT32));\r
*(UINT32 *) Ptr = Data32;\r
return Data64;\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 8-bit value from the memory adress.\r
+ @return The 8-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT8\r
VmReadMem8 (\r
IN VM_CONTEXT *VmPtr,\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 16-bit value from the memory adress.\r
+ @return The 16-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT16\r
VmReadMem16 (\r
IN VM_CONTEXT *VmPtr,\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 32-bit value from the memory adress.\r
+ @return The 32-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT32\r
VmReadMem32 (\r
IN VM_CONTEXT *VmPtr,\r
@param VmPtr A pointer to VM context.\r
@param Addr The memory address.\r
\r
- @return The 64-bit value from the memory adress.\r
+ @return The 64-bit value from the memory address.\r
\r
**/\r
-STATIC\r
UINT64\r
VmReadMem64 (\r
IN VM_CONTEXT *VmPtr,\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
+ Data32 = VmReadMem32 (VmPtr, Addr);\r
+ Data = (UINT64) VmReadMem32 (VmPtr, Addr + sizeof (UINT32));\r
+ Data = LShiftU64 (Data, 32) | Data32;\r
return Data;\r
}\r
\r
adjust for the stack gap and return the modified address.\r
\r
**/\r
-STATIC\r
UINTN\r
ConvertStackAddr (\r
IN VM_CONTEXT *VmPtr,\r
@return The natural value at address Addr.\r
\r
**/\r
-STATIC\r
UINTN\r
VmReadMemN (\r
IN VM_CONTEXT *VmPtr,\r
\r
/**\r
Returns the version of the EBC virtual machine.\r
- \r
+\r
@return The 64-bit version of EBC virtual machine.\r
\r
**/\r
projects / mirror_edk2.git / blobdiff