void EncodeDeclareByte(string hexBytes)
{
const int bitness = 64;
const ulong newRip = 0x8000000000000000;
var data = HexUtils.ToByteArray(hexBytes);
var instructions = new Instruction[] {
Instruction.Create(Code.Nopd),
Instruction.CreateDeclareByte(data),
Instruction.Create(Code.Nopd),
};
var expectedData = new byte[data.Length + 2];
expectedData[0] = 0x90;
Array.Copy(data, 0, expectedData, 1, data.Length);
expectedData[expectedData.Length - 1] = 0x90;
var codeWriter = new CodeWriterImpl();
bool b = BlockEncoder.TryEncode(bitness, new InstructionBlock(codeWriter, instructions, newRip), out var errorMessage, out var result);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Equal(expectedData, codeWriter.ToArray());
Assert.Equal(newRip, result.RIP);
Assert.Null(result.RelocInfos);
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
}
protected void EncodeInvalidBase(int codeSize, Code code, string hexBytes, int invalidCodeSize)
{
var origBytes = HexUtils.ToByteArray(hexBytes);
var decoder = CreateDecoder(codeSize, origBytes);
var origRip = decoder.InstructionPointer;
var origInstr = decoder.Decode();
Assert.Equal(code, origInstr.Code);
Assert.Equal(origBytes.Length, origInstr.ByteLength);
Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength);
Assert.Equal((ushort)origRip, origInstr.IP16);
Assert.Equal((uint)origRip, origInstr.IP32);
Assert.Equal(origRip, origInstr.IP64);
var afterRip = decoder.InstructionPointer;
Assert.Equal((ushort)afterRip, origInstr.NextIP16);
Assert.Equal((uint)afterRip, origInstr.NextIP32);
Assert.Equal(afterRip, origInstr.NextIP64);
var writer = new CodeWriterImpl();
var encoder = CreateEncoder(invalidCodeSize, writer);
var origInstrCopy = origInstr;
int encodedInstrLen = encoder.Encode(ref origInstr, origRip, out string errorMessage);
Assert.True(errorMessage == Encoder.ERROR_ONLY_1632_BIT_MODE || errorMessage == Encoder.ERROR_ONLY_64_BIT_MODE);
Assert.True(Instruction.TEST_BitByBitEquals(ref origInstr, ref origInstrCopy));
Assert.True(encodedInstrLen >= 0);
}
protected void NonDecodeEncodeBase(int codeSize, ref Instruction instr, string hexBytes, ulong rip)
{
var expectedBytes = HexUtils.ToByteArray(hexBytes);
var writer = new CodeWriterImpl();
var encoder = Encoder.Create(codeSize, writer);
Assert.Equal(codeSize, encoder.Bitness);
var origInstrCopy = instr;
bool result = encoder.TryEncode(instr, rip, out uint encodedInstrLen, out string errorMessage);
Assert.True(errorMessage is null, "Unexpected ErrorMessage: " + errorMessage);
Assert.True(result, "Error, result from Encoder.TryEncode must be true");
var encodedBytes = writer.ToArray();
Assert.Equal(encodedBytes.Length, (int)encodedInstrLen);
Assert.True(Instruction.TEST_BitByBitEquals(instr, origInstrCopy));
if (!ArrayEquals(expectedBytes, encodedBytes))
{
#pragma warning disable xUnit2006 // Do not use invalid string equality check
// Show the full string without ellipses by using Equal<string>() instead of Equal()
Assert.Equal <string>(ToString(expectedBytes), ToString(encodedBytes));
throw new InvalidOperationException();
#pragma warning restore xUnit2006 // Do not use invalid string equality check
}
}
protected void EncodeInvalidBase(int codeSize, Code code, string hexBytes, DecoderOptions options, int invalidCodeSize)
{
var origBytes = HexUtils.ToByteArray(hexBytes);
var decoder = CreateDecoder(codeSize, origBytes, options);
var origRip = decoder.IP;
var origInstr = decoder.Decode();
Assert.Equal(code, origInstr.Code);
Assert.Equal(origBytes.Length, origInstr.ByteLength);
Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength);
Assert.Equal((ushort)origRip, origInstr.IP16);
Assert.Equal((uint)origRip, origInstr.IP32);
Assert.Equal(origRip, origInstr.IP);
var afterRip = decoder.IP;
Assert.Equal((ushort)afterRip, origInstr.NextIP16);
Assert.Equal((uint)afterRip, origInstr.NextIP32);
Assert.Equal(afterRip, origInstr.NextIP);
var writer = new CodeWriterImpl();
var encoder = CreateEncoder(invalidCodeSize, writer);
var origInstrCopy = origInstr;
bool result = encoder.TryEncode(origInstr, origRip, out uint encodedInstrLen, out string errorMessage);
Assert.Equal(invalidCodeSize == 64 ? Encoder.ERROR_ONLY_1632_BIT_MODE : Encoder.ERROR_ONLY_64_BIT_MODE, errorMessage);
Assert.False(result);
Assert.True(Instruction.TEST_BitByBitEquals(origInstr, origInstrCopy));
}
protected void EncodeBase(uint id, int bitness, Code code, string hexBytes, string encodedHexBytes, DecoderOptions options)
{
var origBytes = HexUtils.ToByteArray(hexBytes);
var decoder = CreateDecoder(bitness, origBytes, options);
var origRip = decoder.IP;
var origInstr = decoder.Decode();
var origConstantOffsets = decoder.GetConstantOffsets(origInstr);
Assert.Equal(code, origInstr.Code);
Assert.Equal(origBytes.Length, origInstr.Length);
Assert.True(origInstr.Length <= IcedConstants.MaxInstructionLength);
Assert.Equal((ushort)origRip, origInstr.IP16);
Assert.Equal((uint)origRip, origInstr.IP32);
Assert.Equal(origRip, origInstr.IP);
var afterRip = decoder.IP;
Assert.Equal((ushort)afterRip, origInstr.NextIP16);
Assert.Equal((uint)afterRip, origInstr.NextIP32);
Assert.Equal(afterRip, origInstr.NextIP);
var writer = new CodeWriterImpl();
var encoder = Encoder.Create(decoder.Bitness, writer);
Assert.Equal(bitness, encoder.Bitness);
var origInstrCopy = origInstr;
bool result = encoder.TryEncode(origInstr, origRip, out uint encodedInstrLen, out string errorMessage);
Assert.True(errorMessage is null, "Unexpected error message: " + errorMessage);
Assert.True(result, "Error, result from Encoder.TryEncode must be true");
var encodedConstantOffsets = encoder.GetConstantOffsets();
FixConstantOffsets(ref encodedConstantOffsets, origInstr.Length, (int)encodedInstrLen);
Assert.True(Equals(ref origConstantOffsets, ref encodedConstantOffsets));
var encodedBytes = writer.ToArray();
Assert.Equal(encodedBytes.Length, (int)encodedInstrLen);
Assert.True(Instruction.EqualsAllBits(origInstr, origInstrCopy));
var expectedBytes = HexUtils.ToByteArray(encodedHexBytes);
if (!ArrayEquals(expectedBytes, encodedBytes))
{
#pragma warning disable xUnit2006 // Do not use invalid string equality check
// Show the full string without ellipses by using Equal<string>() instead of Equal()
Assert.Equal <string>(ToString(expectedBytes), ToString(encodedBytes));
throw new InvalidOperationException();
#pragma warning restore xUnit2006 // Do not use invalid string equality check
}
var newInstr = CreateDecoder(bitness, encodedBytes, options).Decode();
Assert.Equal(code, newInstr.Code);
Assert.Equal(encodedBytes.Length, newInstr.Length);
newInstr.Length = origInstr.Length;
newInstr.NextIP = origInstr.NextIP;
if (origBytes.Length != expectedBytes.Length && (origInstr.MemoryBase == Register.EIP || origInstr.MemoryBase == Register.RIP))
{
newInstr.MemoryDisplacement += (uint)(expectedBytes.Length - origBytes.Length);
}
Assert.True(Instruction.EqualsAllBits(origInstr, newInstr));
}
void DefaultArgs()
{
const int bitness = 64;
const ulong origRip = 0x123456789ABCDE00;
const ulong newRip = 0x8000000000000000;
var originalData = new byte[] {
/*0000*/ 0xB0, 0x00, // mov al,0
/*0002*/ 0xEB, 0x09, // jmp short 123456789ABCDE0Dh
/*0004*/ 0xB0, 0x01, // mov al,1
/*0006*/ 0xE9, 0x03, 0x00, 0x00, 0x00, // jmp near ptr 123456789ABCDE0Eh
/*000B*/ 0xB0, 0x02, // mov al,2
};
var instructions = BlockEncoderTest.Decode(bitness, origRip, originalData, DecoderOptions.None);
var codeWriter = new CodeWriterImpl();
bool b = BlockEncoder.TryEncode(bitness, new InstructionBlock(codeWriter, instructions, newRip), out var errorMessage, out var result);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Equal(newRip, result.RIP);
Assert.Equal(0x28, codeWriter.ToArray().Length);
Assert.Null(result.RelocInfos);
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
}
protected void EncodeBase(int codeSize, Code code, string hexBytes, string encodedHexBytes, DecoderOptions options)
{
var origBytes = HexUtils.ToByteArray(hexBytes);
var decoder = CreateDecoder(codeSize, origBytes, options);
var origRip = decoder.IP;
var origInstr = decoder.Decode();
var origConstantOffsets = decoder.GetConstantOffsets(origInstr);
Assert.Equal(code, origInstr.Code);
Assert.Equal(origBytes.Length, origInstr.ByteLength);
Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength);
Assert.Equal((ushort)origRip, origInstr.IP16);
Assert.Equal((uint)origRip, origInstr.IP32);
Assert.Equal(origRip, origInstr.IP);
var afterRip = decoder.IP;
Assert.Equal((ushort)afterRip, origInstr.NextIP16);
Assert.Equal((uint)afterRip, origInstr.NextIP32);
Assert.Equal(afterRip, origInstr.NextIP);
var writer = new CodeWriterImpl();
var encoder = Encoder.Create(decoder.Bitness, writer);
Assert.Equal(codeSize, encoder.Bitness);
var origInstrCopy = origInstr;
bool result = encoder.TryEncode(origInstr, origRip, out uint encodedInstrLen, out string errorMessage);
Assert.True(errorMessage is null, "Unexpected ErrorMessage: " + errorMessage);
Assert.True(result, "Error, result from Encoder.TryEncode must be true");
var encodedConstantOffsets = encoder.GetConstantOffsets();
FixConstantOffsets(ref encodedConstantOffsets, origInstr.ByteLength, (int)encodedInstrLen);
Assert.True(Equals(ref origConstantOffsets, ref encodedConstantOffsets));
var encodedBytes = writer.ToArray();
Assert.Equal(encodedBytes.Length, (int)encodedInstrLen);
Assert.True(Instruction.TEST_BitByBitEquals(origInstr, origInstrCopy));
var expectedBytes = HexUtils.ToByteArray(encodedHexBytes);
if (!ArrayEquals(expectedBytes, encodedBytes))
{
#pragma warning disable xUnit2006 // Do not use invalid string equality check
// Show the full string without ellipses by using Equal<string>() instead of Equal()
Assert.Equal <string>(ToString(expectedBytes), ToString(encodedBytes));
throw new InvalidOperationException();
#pragma warning restore xUnit2006 // Do not use invalid string equality check
}
var newInstr = CreateDecoder(codeSize, encodedBytes, options).Decode();
Assert.Equal(code, newInstr.Code);
Assert.Equal(encodedBytes.Length, newInstr.ByteLength);
newInstr.ByteLength = origInstr.ByteLength;
newInstr.NextIP = origInstr.NextIP;
Assert.True(Instruction.TEST_BitByBitEquals(origInstr, newInstr));
// Some tests use useless or extra prefixes, so we can't verify the exact length
Assert.True(encodedBytes.Length <= origBytes.Length, "Unexpected encoded prefixes: " + ToString(encodedBytes));
}
void DisplSize_eq_1_uses_long_form_if_it_does_not_fit_in_1_byte(int bitness, string hexBytes, ulong rip, Instruction instruction)
{
var expectedBytes = HexUtils.ToByteArray(hexBytes);
var codeWriter = new CodeWriterImpl();
var encoder = Encoder.Create(bitness, codeWriter);
Assert.True(encoder.TryEncode(ref instruction, rip, out uint encodedLength, out string errorMessage), $"Could not encode {instruction}, error: {errorMessage}");
Assert.Equal(expectedBytes, codeWriter.ToArray());
Assert.Equal((uint)expectedBytes.Length, encodedLength);
}
protected void EncodeBase(int codeSize, Code code, string hexBytes, DecoderOptions options)
{
var origBytes = HexUtils.ToByteArray(hexBytes);
var decoder = CreateDecoder(codeSize, origBytes, options);
var origRip = decoder.InstructionPointer;
var origInstr = decoder.Decode();
var origConstantOffsets = decoder.GetConstantOffsets(ref origInstr);
Assert.Equal(code, origInstr.Code);
Assert.Equal(origBytes.Length, origInstr.ByteLength);
Assert.True(origInstr.ByteLength <= Iced.Intel.DecoderConstants.MaxInstructionLength);
Assert.Equal((ushort)origRip, origInstr.IP16);
Assert.Equal((uint)origRip, origInstr.IP32);
Assert.Equal(origRip, origInstr.IP64);
var afterRip = decoder.InstructionPointer;
Assert.Equal((ushort)afterRip, origInstr.NextIP16);
Assert.Equal((uint)afterRip, origInstr.NextIP32);
Assert.Equal(afterRip, origInstr.NextIP64);
var writer = new CodeWriterImpl();
var encoder = decoder.CreateEncoder(writer);
Assert.Equal(codeSize, encoder.Bitness);
var origInstrCopy = origInstr;
bool result = encoder.TryEncode(ref origInstr, origRip, out uint encodedInstrLen, out string errorMessage);
Assert.True(errorMessage == null, "Unexpected ErrorMessage: " + errorMessage);
Assert.True(result, "Error, result from Encoder.TryEncode must be true");
var encodedConstantOffsets = encoder.GetConstantOffsets();
FixConstantOffsets(ref encodedConstantOffsets, origInstr.ByteLength, (int)encodedInstrLen);
Assert.True(Equals(ref origConstantOffsets, ref encodedConstantOffsets));
var encodedBytes = writer.ToArray();
Assert.Equal(encodedBytes.Length, (int)encodedInstrLen);
Assert.True(Instruction.TEST_BitByBitEquals(origInstr, origInstrCopy), "Instruction are differing: " + Instruction.TEST_DumpDiff(origInstr, origInstrCopy));
// We don't compare the generated bytes, bit by bit, for many reasons. Eg. prefixes
// can be put in any order. Unused prefixes. [xxxx] can be encoded w/ and w/o a sib
// byte in 32-bit mode. The decoder-tests test ignored bits by setting them to 1, but
// the encoder always writes 0.
// The instruction is decoded again and then it's compared against the old one to
// make sure it matches exactly, bit by bit.
var newInstr = CreateDecoder(codeSize, encodedBytes, options).Decode();
Assert.Equal(code, newInstr.Code);
Assert.Equal(encodedBytes.Length, newInstr.ByteLength);
newInstr.ByteLength = origInstr.ByteLength;
newInstr.NextIP64 = origInstr.NextIP64;
Assert.True(Instruction.TEST_BitByBitEquals(origInstr, newInstr), "Instruction are differing: " + Instruction.TEST_DumpDiff(origInstr, newInstr));
// Some tests use useless or extra prefixes, so we can't verify the exact length
Assert.True(encodedBytes.Length <= origBytes.Length, "Unexpected encoded prefixes: " + HexUtils.ToString(encodedBytes));
}
void WriteByte_works()
{
var codeWriter = new CodeWriterImpl();
var encoder = Encoder.Create(64, codeWriter);
var instruction = Instruction.Create(Code.Add_r64_rm64, Register.R8, Register.RBP);
encoder.WriteByte(0x90);
encoder.Encode(instruction, 0x55555555);
encoder.WriteByte(0xCC);
Assert.Equal(new byte[] { 0x90, 0x4C, 0x03, 0xC5, 0xCC }, codeWriter.ToArray());
}
void Encode_R13_with_no_displ()
{
var writer = new CodeWriterImpl();
var encoder = Encoder.Create(64, writer);
var instr = Instruction.Create(Code.Mov_r64_rm64, Register.RAX, new MemoryOperand(Register.R13));
uint len = encoder.Encode(ref instr, 0);
var expected = new byte[] { 0x49, 0x8B, 0x45, 0x00 };
var actual = writer.ToArray();
Assert.Equal(actual.Length, (int)len);
Assert.Equal(expected, actual);
}
void EncodeRipRelMemOp()
{
var instr = Instruction.Create(Code.Add_r32_rm32, Register.ECX, new MemoryOperand(Register.RIP, Register.None, 1, 0x1234_5678_9ABC_DEF1, 8, false, Register.None));
var codeWriter = new CodeWriterImpl();
bool b = BlockEncoder.TryEncode(64, new InstructionBlock(codeWriter, new[] { instr }, 0x1234_5678_ABCD_EF02), out var errorMessage, out _);
Assert.True(b, $"Couldn't encode it: {errorMessage}");
var encoded = codeWriter.ToArray();
var expected = new byte[] { 0x03, 0x0D, 0xE9, 0xEF, 0xEE, 0xEE };
Assert.Equal(expected, encoded);
}
void Encode_EBP_with_no_displ()
{
var writer = new CodeWriterImpl();
var encoder = Encoder.Create(32, writer);
var instruction = Instruction.Create(Code.Mov_r32_rm32, Register.EAX, new MemoryOperand(Register.EBP));
uint len = encoder.Encode(instruction, 0);
var expected = new byte[] { 0x8B, 0x45, 0x00 };
var actual = writer.ToArray();
Assert.Equal(actual.Length, (int)len);
Assert.Equal(expected, actual);
}
void Encode_MOV_CR8_in_64bit_mode_does_not_add_LOCK(string hexBytes, Code code, string encodedBytes)
{
var decoder = Decoder.Create(64, new ByteArrayCodeReader(hexBytes));
decoder.Decode(out var instr);
Assert.Equal(code, instr.Code);
var writer = new CodeWriterImpl();
var encoder = decoder.CreateEncoder(writer);
encoder.Encode(ref instr, 0);
var expectedBytes = HexUtils.ToByteArray(encodedBytes);
var actualBytes = writer.ToArray();
Assert.Equal(expectedBytes, actualBytes);
}
void Encode_zero_instructions()
{
string errorMessage;
var codeWriter = new CodeWriterImpl();
errorMessage = BlockEncoder.Encode(16, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
errorMessage = BlockEncoder.Encode(32, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
errorMessage = BlockEncoder.Encode(64, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0, Array.Empty <RelocInfo>(), Array.Empty <uint>(), Array.Empty <ConstantOffsets>()), BlockEncoderOptions.None);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
}
void Prevent_VEX2_encoding(string hexBytes, string expectedBytes, Code code, bool preventVEX2)
{
var decoder = Decoder.Create(64, new ByteArrayCodeReader(hexBytes));
decoder.IP = DecoderConstants.DEFAULT_IP64;
decoder.Decode(out var instr);
Assert.Equal(code, instr.Code);
var codeWriter = new CodeWriterImpl();
var encoder = decoder.CreateEncoder(codeWriter);
encoder.PreventVEX2 = preventVEX2;
encoder.Encode(ref instr, DecoderConstants.DEFAULT_IP64);
var encodedBytes = codeWriter.ToArray();
var expectedBytesArray = HexUtils.ToByteArray(expectedBytes);
Assert.Equal(expectedBytesArray, encodedBytes);
}
void Test_EVEX_WIG_LIG(string hexBytes, string expectedBytes, Code code, uint wig, uint lig)
{
var decoder = Decoder.Create(64, new ByteArrayCodeReader(hexBytes));
decoder.IP = DecoderConstants.DEFAULT_IP64;
decoder.Decode(out var instruction);
Assert.Equal(code, instruction.Code);
var codeWriter = new CodeWriterImpl();
var encoder = Encoder.Create(decoder.Bitness, codeWriter);
encoder.EVEX_WIG = wig;
encoder.EVEX_LIG = lig;
encoder.Encode(instruction, DecoderConstants.DEFAULT_IP64);
var encodedBytes = codeWriter.ToArray();
var expectedBytesArray = HexUtils.ToByteArray(expectedBytes);
Assert.Equal(expectedBytesArray, encodedBytes);
}
void DefaultArgs()
{
const int bitness = 64;
const ulong origRip = 0x123456789ABCDE00;
const ulong newRip = 0x8000000000000000;
var originalData = new byte[] {
/*0000*/ 0xB0, 0x00, // mov al,0
/*0002*/ 0xEB, 0x09, // jmp short 123456789ABCDE0Dh
/*0004*/ 0xB0, 0x01, // mov al,1
/*0006*/ 0xE9, 0x03, 0x00, 0x00, 0x00, // jmp near ptr 123456789ABCDE0Eh
/*000B*/ 0xB0, 0x02, // mov al,2
};
var instructions = BlockEncoderTest.Decode(bitness, origRip, originalData, DecoderOptions.None);
var codeWriter = new CodeWriterImpl();
var errorMessage = BlockEncoder.Encode(bitness, new InstructionBlock(codeWriter, instructions, newRip));
Assert.Null(errorMessage);
Assert.Equal(0x28, codeWriter.ToArray().Length);
}
void Encode_zero_instructions()
{
bool b;
string errorMessage;
BlockEncoderResult result;
var codeWriter = new CodeWriterImpl();
b = BlockEncoder.TryEncode(16, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0), out errorMessage, out result, BlockEncoderOptions.None);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
Assert.Equal(0UL, result.RIP);
Assert.Null(result.RelocInfos);
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
b = BlockEncoder.TryEncode(32, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0), out errorMessage, out result, BlockEncoderOptions.None);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
Assert.Equal(0UL, result.RIP);
Assert.Null(result.RelocInfos);
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
b = BlockEncoder.TryEncode(64, new InstructionBlock(codeWriter, Array.Empty <Instruction>(), 0), out errorMessage, out result, BlockEncoderOptions.None);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Empty(codeWriter.ToArray());
Assert.Equal(0UL, result.RIP);
Assert.Null(result.RelocInfos);
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
}
void VerifyResultArrays(BlockEncoderOptions options)
{
const int bitness = 64;
const ulong origRip1 = 0x123456789ABCDE00;
const ulong origRip2 = 0x223456789ABCDE00;
const ulong newRip1 = 0x8000000000000000;
const ulong newRip2 = 0x9000000000000000;
{
var instructions1 = BlockEncoderTest.Decode(bitness, origRip1, new byte[] { 0xE9, 0x56, 0x78, 0xA5, 0x5A }, DecoderOptions.None);
var codeWriter1 = new CodeWriterImpl();
bool b = BlockEncoder.TryEncode(bitness, new InstructionBlock(codeWriter1, instructions1, newRip1), out var errorMessage, out var result, options);
Assert.True(b);
Assert.Null(errorMessage);
Assert.Equal(newRip1, result.RIP);
if ((options & BlockEncoderOptions.ReturnRelocInfos) != 0)
{
Assert.NotNull(result.RelocInfos);
Assert.True(result.RelocInfos.Count == 1);
}
else
{
Assert.Null(result.RelocInfos);
}
if ((options & BlockEncoderOptions.ReturnNewInstructionOffsets) != 0)
{
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 1);
}
else
{
Assert.NotNull(result.NewInstructionOffsets);
Assert.True(result.NewInstructionOffsets.Length == 0);
}
if ((options & BlockEncoderOptions.ReturnConstantOffsets) != 0)
{
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 1);
}
else
{
Assert.NotNull(result.ConstantOffsets);
Assert.True(result.ConstantOffsets.Length == 0);
}
}
{
var instructions1 = BlockEncoderTest.Decode(bitness, origRip1, new byte[] { 0xE9, 0x56, 0x78, 0xA5, 0x5A }, DecoderOptions.None);
var instructions2 = BlockEncoderTest.Decode(bitness, origRip2, new byte[] { 0x90, 0xE9, 0x56, 0x78, 0xA5, 0x5A }, DecoderOptions.None);
var codeWriter1 = new CodeWriterImpl();
var codeWriter2 = new CodeWriterImpl();
var block1 = new InstructionBlock(codeWriter1, instructions1, newRip1);
var block2 = new InstructionBlock(codeWriter2, instructions2, newRip2);
bool b = BlockEncoder.TryEncode(bitness, new[] { block1, block2 }, out var errorMessage, out var resultArray, options);
Assert.True(b);
Assert.Null(errorMessage);
Assert.NotNull(resultArray);
Assert.Equal(2, resultArray.Length);
Assert.Equal(newRip1, resultArray[0].RIP);
Assert.Equal(newRip2, resultArray[1].RIP);
if ((options & BlockEncoderOptions.ReturnRelocInfos) != 0)
{
Assert.NotNull(resultArray[0].RelocInfos);
Assert.NotNull(resultArray[1].RelocInfos);
Assert.True(resultArray[0].RelocInfos.Count == 1);
Assert.True(resultArray[1].RelocInfos.Count == 1);
}
else
{
Assert.Null(resultArray[0].RelocInfos);
Assert.Null(resultArray[1].RelocInfos);
}
if ((options & BlockEncoderOptions.ReturnNewInstructionOffsets) != 0)
{
Assert.NotNull(resultArray[0].NewInstructionOffsets);
Assert.NotNull(resultArray[1].NewInstructionOffsets);
Assert.True(resultArray[0].NewInstructionOffsets.Length == 1);
Assert.True(resultArray[1].NewInstructionOffsets.Length == 2);
}
else
{
Assert.NotNull(resultArray[0].NewInstructionOffsets);
Assert.True(resultArray[0].NewInstructionOffsets.Length == 0);
Assert.NotNull(resultArray[1].NewInstructionOffsets);
Assert.True(resultArray[1].NewInstructionOffsets.Length == 0);
}
if ((options & BlockEncoderOptions.ReturnConstantOffsets) != 0)
{
Assert.NotNull(resultArray[0].ConstantOffsets);
Assert.NotNull(resultArray[1].ConstantOffsets);
Assert.True(resultArray[0].ConstantOffsets.Length == 1);
Assert.True(resultArray[1].ConstantOffsets.Length == 2);
}
else
{
Assert.NotNull(resultArray[0].ConstantOffsets);
Assert.True(resultArray[0].ConstantOffsets.Length == 0);
Assert.NotNull(resultArray[1].ConstantOffsets);
Assert.True(resultArray[1].ConstantOffsets.Length == 0);
}
}
}
