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; }