// 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
// 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->R[0] <= (UINT64)(UINTN) VmPtr->StackTop)) {\r
EbcDebugSignalException (EXCEPT_EBC_STACK_FAULT, EXCEPTION_FLAG_FATAL, VmPtr);\r
StackCorrupted = 1;\r
}\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
// 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
// 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
// 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
VmPtr->Ip += Size;\r
return EFI_SUCCESS;\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
//\r
// Take jump -- relative or absolute\r
//\r
- if (Operand & JMP_M_RELATIVE) {\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Data64 + Size;\r
} else {\r
VmPtr->Ip = (VMIP) (UINTN) Data64;\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
return EFI_UNSUPPORTED;\r
}\r
\r
- if (Operand & JMP_M_RELATIVE) {\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Addr + Size;\r
} else {\r
VmPtr->Ip = (VMIP) Addr;\r
return EFI_UNSUPPORTED;\r
}\r
\r
- if (Operand & JMP_M_RELATIVE) {\r
+ if ((Operand & JMP_M_RELATIVE) != 0) {\r
VmPtr->Ip += (UINTN) Addr + Size;\r
} else {\r
VmPtr->Ip = (VMIP) Addr;\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
VmPtr->Ip += 2;\r
return EFI_SUCCESS;\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
//\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
//\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
// 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
// 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 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
//\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
} else {\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 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
//\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
//\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
// 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
+ if ((Operands & OPERAND_M_RELATIVE_ADDR) != 0) {\r
EbcLLCALLEX (VmPtr, (UINTN) (Immed64 + VmPtr->Ip + Size), (UINTN) VmPtr->R[0], FramePtr, Size);\r
} else {\r
- if (VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) {\r
+ if ((VmPtr->StopFlags & STOPFLAG_BREAK_ON_CALLEX) != 0) {\r
CpuBreakpoint ();\r
}\r
\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
+ if ((Opcode & OPCODE_M_64BIT) != 0) {\r
Op2 = (INT64) VmReadMem64 (VmPtr, (UINTN) (VmPtr->R[OPERAND2_REGNUM (Operands)] + Index16));\r
} else {\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
// 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
// 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
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
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
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
\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
//\r
// Get the destination register\r
//\r
- if (*VmPtr->Ip & DATAMANIP_M_64) {\r
+ if ((*VmPtr->Ip & DATAMANIP_M_64) != 0) {\r
return (UINT64) (DivU64x64Remainder ((INT64)Op1, (INT64)Op2, &Remainder));\r
} else {\r
return (UINT64) ((UINT32) Op1 / (UINT32) Op2);\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
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
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
//\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
// 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
//\r
Op1 = VmPtr->R[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
if (OPERAND1_INDIRECT (Operands)) {\r
Op1 = VmPtr->R[OPERAND1_REGNUM (Operands)];\r
- if (Opcode & DATAMANIP_M_64) {\r
+ if ((Opcode & DATAMANIP_M_64) != 0) {\r
VmWriteMem64 (VmPtr, (UINTN) Op1, Op2);\r
} else {\r
VmWriteMem32 (VmPtr, (UINTN) Op1, (UINT32) Op2);\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
//\r
// Now set the sign\r
//\r
- if (Index & 0x80000000) {\r
+ if ((Index & 0x80000000) != 0) {\r
Offset = Offset * -1;\r
}\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