public InstructionDef(EnumValue code, string opCodeString, string instructionString, EnumValue mnemonic,
EnumValue mem, EnumValue bcst, EnumValue decoderOption, InstructionDefFlags1 flags1, InstructionDefFlags2 flags2,
InstructionDefFlags3 flags3, InstrStrFmtOption instrStrFmtOption, InstructionStringFlags instrStrFlags,
InstrStrImpliedOp[] instrStrImpliedOps,
MandatoryPrefix mandatoryPrefix, OpCodeTableKind table, OpCodeL lBit, OpCodeW wBit, uint opCode, int opCodeLength,
int groupIndex, int rmGroupIndex, CodeSize operandSize, CodeSize addressSize, TupleType tupleType, OpCodeOperandKind[] opKinds,
PseudoOpsKind?pseudoOp, EnumValue encoding, EnumValue flowControl, ConditionCode conditionCode,
BranchKind branchKind, RflagsBits read, RflagsBits undefined, RflagsBits written, RflagsBits cleared, RflagsBits set,
EnumValue[] cpuid, OpInfo[] opInfo,
FastFmtInstructionDef fast, FmtInstructionDef gas, FmtInstructionDef intel, FmtInstructionDef masm, FmtInstructionDef nasm)
{
Code = code;
OpCodeString = opCodeString;
InstructionString = instructionString;
Mnemonic = mnemonic;
Memory = mem;
MemoryBroadcast = bcst;
DecoderOption = decoderOption;
EncodingValue = encoding;
Flags1 = flags1;
Flags2 = flags2;
Flags3 = flags3;
InstrStrFmtOption = instrStrFmtOption;
InstrStrFlags = instrStrFlags;
InstrStrImpliedOps = instrStrImpliedOps;
MandatoryPrefix = mandatoryPrefix;
Table = table;
LBit = lBit;
WBit = wBit;
OpCode = opCode;
OpCodeLength = opCodeLength;
GroupIndex = groupIndex;
RmGroupIndex = rmGroupIndex;
TupleType = tupleType;
OperandSize = operandSize;
AddressSize = addressSize;
OpKinds = opKinds;
PseudoOp = pseudoOp;
ControlFlow = flowControl;
ConditionCode = conditionCode;
BranchKind = branchKind;
RflagsRead = read;
RflagsUndefined = undefined;
RflagsWritten = written;
RflagsCleared = cleared;
RflagsSet = set;
RflagsInfo = null;
Cpuid = cpuid;
CpuidInternal = null;
OpInfo = opInfo;
OpInfoEnum = new EnumValue[opInfo.Length];
Fast = fast;
Gas = gas;
Intel = intel;
Masm = masm;
Nasm = nasm;
}
public SimpleInstrInfo_fword(Code code, CodeSize codeSize, bool forceNoMemSize, string mnemonic, string mnemonic2)
: base(code)
{
this.codeSize = codeSize;
this.forceNoMemSize = forceNoMemSize;
this.mnemonic = mnemonic;
this.mnemonic2 = mnemonic2;
}
public EncodeOptions()
{
MarginSize = 10;
ModuleSize = 5;
Scheme = Scheme.Ascii;
Rotate = 0;
SizeIdx = CodeSize.SymbolSquareAuto;
CodeType = CodeType.DataMatrix;
}
public SimpleInstrInfo_OpSize(Code code, CodeSize codeSize, string mnemonic, string mnemonic16, string mnemonic32, string mnemonic64)
: base(code)
{
this.codeSize = codeSize;
mnemonics = new string[4];
mnemonics[(int)CodeSize.Unknown] = mnemonic;
mnemonics[(int)CodeSize.Code16] = mnemonic16;
mnemonics[(int)CodeSize.Code32] = mnemonic32;
mnemonics[(int)CodeSize.Code64] = mnemonic64;
}
public void CalculateEccOfData_ShouldReturnCorrectEccForGivenData(byte[] data, byte[] expectedResult)
{
// Arrange
CodeSize size = CodeSizes.All.FirstOrDefault(x => x.DataCodewords >= data.Length)
?? throw new InvalidOperationException("Size not found");
// Act
byte[] result = ErrorCorrection.CalculateEcc(data, size);
// Assert
result.Should().BeEquivalentTo(expectedResult);
}
protected OpCodeHandler(EncFlags2 encFlags2, EncFlags3 encFlags3, bool isSpecialInstr, TryConvertToDisp8N?tryConvertToDisp8N, Op[] operands)
{
EncFlags3 = encFlags3;
OpCode = GetOpCode(encFlags2);
Is2ByteOpCode = (encFlags2 & EncFlags2.OpCodeIs2Bytes) != 0;
GroupIndex = (encFlags2 & EncFlags2.HasGroupIndex) == 0 ? -1 : (int)(((uint)encFlags2 >> (int)EncFlags2.GroupIndexShift) & 7);
RmGroupIndex = (encFlags3 & EncFlags3.HasRmGroupIndex) == 0 ? -1 : (int)(((uint)encFlags2 >> (int)EncFlags2.GroupIndexShift) & 7);
IsSpecialInstr = isSpecialInstr;
OpSize = (CodeSize)(((uint)encFlags3 >> (int)EncFlags3.OperandSizeShift) & (uint)EncFlags3.OperandSizeMask);
AddrSize = (CodeSize)(((uint)encFlags3 >> (int)EncFlags3.AddressSizeShift) & (uint)EncFlags3.AddressSizeMask);
TryConvertToDisp8N = tryConvertToDisp8N;
Operands = operands;
}
static int GetCodeSize(CodeSize codeSize)
{
switch (codeSize)
{
case CodeSize.Code16: return(16);
case CodeSize.Code32: return(32);
case CodeSize.Code64: return(64);
default:
case CodeSize.Unknown: return(0);
}
}
public static int GetAddressSizeInBytes(Register baseReg, Register indexReg, int displSize, CodeSize codeSize)
{
if ((Register.EAX <= baseReg && baseReg <= Register.R15D) || (Register.EAX <= indexReg && indexReg <= Register.R15D) || baseReg == Register.EIP)
{
return(4);
}
if ((Register.RAX <= baseReg && baseReg <= Register.R15) || (Register.RAX <= indexReg && indexReg <= Register.R15) || baseReg == Register.RIP)
{
return(8);
}
if (baseReg == Register.BX || baseReg == Register.BP || baseReg == Register.SI || baseReg == Register.DI || indexReg == Register.SI || indexReg == Register.DI)
{
return(2);
}
if (displSize == 2 || displSize == 4 || displSize == 8)
{
return(displSize);
}
if (codeSize == CodeSize.Code32)
{
return(4);
}
if (codeSize == CodeSize.Code64)
{
return(8);
}
if (codeSize == CodeSize.Code16)
{
return(2);
}
return(8);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="segReg">Effective segment register or <see cref="Register.None"/> if the segment register is ignored</param>
/// <param name="baseReg">Base register</param>
/// <param name="indexReg">Index register</param>
/// <param name="scale">1, 2, 4 or 8</param>
/// <param name="displ">Displacement</param>
/// <param name="memorySize">Memory size</param>
/// <param name="access">Access</param>
/// <param name="addressSize">Address size</param>
/// <param name="vsibSize">VSIB size (<c>0</c>, <c>4</c> or <c>8</c>)</param>
public UsedMemory(Register segReg, Register baseReg, Register indexReg, int scale, ulong displ, MemorySize memorySize, OpAccess access, CodeSize addressSize, int vsibSize)
{
this.displ = displ;
Debug.Assert((uint)segReg <= byte.MaxValue);
this.segReg = (byte)segReg;
Debug.Assert((uint)baseReg <= byte.MaxValue);
this.baseReg = (byte)baseReg;
Debug.Assert((uint)indexReg <= byte.MaxValue);
this.indexReg = (byte)indexReg;
Debug.Assert((uint)memorySize <= byte.MaxValue);
this.memorySize = (byte)memorySize;
Debug.Assert(scale == 1 || scale == 2 || scale == 4 || scale == 8);
this.scale = (byte)scale;
Debug.Assert((uint)access <= byte.MaxValue);
this.access = (byte)access;
Debug.Assert((uint)addressSize <= byte.MaxValue);
this.addressSize = (byte)addressSize;
Debug.Assert(vsibSize == 0 || vsibSize == 4 || vsibSize == 8);
this.vsibSize = (byte)vsibSize;
}
public static int GetAddressSizeInBytes(Register baseReg, Register indexReg, int displSize, CodeSize codeSize)
{
if ((Register.RAX <= baseReg && baseReg <= Register.R15) || (Register.RAX <= indexReg && indexReg <= Register.R15) || baseReg == Register.RIP)
{
return(8);
}
if ((Register.EAX <= baseReg && baseReg <= Register.R15D) || (Register.EAX <= indexReg && indexReg <= Register.R15D) || baseReg == Register.EIP)
{
return(4);
}
if ((Register.AX <= baseReg && baseReg <= Register.DI) || (Register.AX <= indexReg && indexReg <= Register.DI))
{
return(2);
}
if (displSize == 2 || displSize == 4 || displSize == 8)
{
return(displSize);
}
return(codeSize switch {
CodeSize.Code64 => 8,
CodeSize.Code32 => 4,
CodeSize.Code16 => 2,
_ => 8
});
static bool IsCode64(CodeSize codeSize) => codeSize == CodeSize.Code64 || codeSize == CodeSize.Unknown;
public SimpleInstrInfo_pushm(Code code, CodeSize codeSize, string mnemonic)
: base(code)
{
this.codeSize = codeSize;
this.mnemonic = mnemonic;
}
public EncodeOptions()
{
MarginSize = 10;
ModuleSize = 5;
Scheme = Scheme.Ascii;
Rotate = 0;
SizeIdx = CodeSize.SymbolSquareAuto;
CodeType = CodeType.DataMatrix;
}
