protected static Arm32Instruction Disassemble(byte[] bytes)
{
var image = new MemoryArea(Address.Ptr32(0x00100000), bytes);
var dasm = new Arm32Disassembler(new Arm32ProcessorArchitecture(), image.CreateLeReader(0));
return(dasm.First());
}
protected static MachineInstruction Disassemble(byte[] bytes)
{
var image = new MemoryArea(Address.Ptr32(0x00100000), bytes);
var dasm = new Arm32Architecture("arm32").CreateDisassembler(image.CreateLeReader(0));
return(dasm.First());
}
public C64BasicInstruction ReadLine(Address addr)
{
var rdr = image.CreateLeReader(addr);
if (!rdr.TryReadLeUInt16(out ushort next))
{
return(null);
}
if (!rdr.TryReadLeUInt16(out ushort line))
{
return(null);
}
if (next < 0x0801)
{
return(null);
}
var mem = new List <byte>();
while (rdr.TryReadByte(out byte b) && b != 0)
{
mem.Add(b);
}
return(new C64BasicInstruction
{
Address = Address.Ptr16(line),
Length = (int)(rdr.Address - addr),
NextAddress = next,
Line = mem.ToArray()
});
}
public C64BasicInstruction ReadLine(Address addr)
{
var rdr = image.CreateLeReader(addr);
ushort next;
ushort line;
byte b;
if (!rdr.TryReadLeUInt16(out next))
{
return(null);
}
if (!rdr.TryReadLeUInt16(out line))
{
return(null);
}
if (next < 0x0801)
{
return(null);
}
var mem = new MemoryStream();
while (rdr.TryReadByte(out b) && b != 0)
{
mem.WriteByte(b);
}
return(new C64BasicInstruction
{
Address = Address.Ptr16(line),
NextAddress = next,
Line = mem.ToArray()
});
}
public void Rotations()
{
X86TextAssembler asm = new X86TextAssembler(sc, new X86ArchitectureReal());
var lr = asm.AssembleFragment(
Address.SegPtr(0xB96, 0),
"foo proc\r\n"+
"rol ax,cl\r\n"+
"ror word ptr [bx+2],cl\r\n"+
"rcr word ptr [bp+4],4\r\n"+
"rcl ax,1\r\n");
MemoryArea img = lr.SegmentMap.Segments.Values.First().MemoryArea;
CreateDisassembler16(img.CreateLeReader(img.BaseAddress));
StringBuilder sb = new StringBuilder();
foreach (var instr in dasm.Take(4))
{
sb.AppendFormat("{0}\r\n", instr.ToString());
}
string s = sb.ToString();
Assert.AreEqual(
"rol\tax,cl\r\n" +
"ror\tword ptr [bx+02],cl\r\n" +
"rcr\tword ptr [bp+04],04\r\n" +
"rcl\tax,01\r\n", s);
}
protected override IEnumerable <RtlInstructionCluster> GetRtlStream(MemoryArea mem, IStorageBinder binder, IRewriterHost host)
{
return(new AlphaRewriter(
arch,
mem.CreateLeReader(0),
binder,
host));
}
private X86Instruction Disassemble32(params byte[] bytes)
{
var img = new MemoryArea(Address.Ptr32(0x10000), bytes);
var rdr = img.CreateLeReader(img.BaseAddress);
var dasm = new X86Disassembler(ProcessorMode.Protected32, rdr, PrimitiveType.Word32, PrimitiveType.Word32, false);
return(dasm.First());
}
private void Given_TypedDataDumper(byte[] bytes)
{
this.sw = new StringWriter();
var fmt = new TextFormatter(sw);
var mem = new MemoryArea(Address.Ptr32(0x00123400), bytes);
var rdr = mem.CreateLeReader(0);
this.tdd = new TypedDataDumper(rdr, (uint)mem.Length, fmt);
}
private void CreateDisassembler32(MemoryArea image)
{
dasm = new X86Disassembler(
ProcessorMode.Protected32,
image.CreateLeReader(image.BaseAddress),
PrimitiveType.Word32,
PrimitiveType.Word32,
false);
}
private void RunTest(string sExp, params byte[] bytes)
{
var image = new MemoryArea(Address.Ptr32(0x0100000), bytes);
var dasm = new CilDisassembler(image.CreateLeReader(0)).GetEnumerator();
Assert.IsTrue(dasm.MoveNext());
var instr = dasm.Current;
Assert.AreEqual(sExp, instr.ToString());
}
/// <summary>
/// Establishes a disassembler instance for further tests.
/// </summary>
/// <param name="instrs"></param>
private void Given_Instructions(params ushort[] instrs)
{
var w = new LeImageWriter();
foreach (var instr in instrs)
{
w.WriteLeUInt16(instr);
}
var image = new MemoryArea(Address.Ptr32(0x00100000), w.ToArray());
var arch = CreateArchitecture();
this.dasm = CreateDisassembler(arch, image.CreateLeReader(0));
}
public void ArmArch_CreateRewriter()
{
this.arch = new Arm32Architecture("arm32");
var mem = new MemoryArea(Address.Ptr32(0x00123400), new byte[] { 0x03, 0x10, 0x12, 0xE0 });
var rdr = mem.CreateLeReader(0);
var rw = arch.CreateRewriter(rdr, new AArch32ProcessorState(arch), new StorageBinder(), null);
var rtl = rw.First().Instructions[0];
Assert.AreEqual("r1 = r2 & r3", rtl.ToString());
}
public void ArmArch_CreateDisassembler()
{
this.arch = new Arm32Architecture("arm32");
var mem = new MemoryArea(Address.Ptr32(0x00123400), new byte[] { 0x03, 0x10, 0x12, 0xE0 });
var rdr = mem.CreateLeReader(0);
var dasm = arch.CreateDisassembler(rdr);
var str = dasm.First().ToString();
Assert.AreEqual("ands\tr1,r2,r3", str);
}
public List <DecodedInstruction> Decode(int count = int.MaxValue)
{
var decoded = new List <DecodedInstruction>();
try
{
var dasm = arch.CreateDisassembler(memoryArea.CreateLeReader((uint)Offset));
foreach (var instr in dasm)
{
var len = instr.Length;
var address = instr.Address.Offset;
var instruction = instr.ToString().Replace('\t', ' ');
// preference
instruction = instruction.Replace(",", ", ");
// fix up
instruction = ChangeHex(instruction);
var sb = new StringBuilder();
sb.AppendFormat("{0:x8}", address);
sb.Append(' ');
sb.Append(BytesToHex(memory, (uint)Offset, len));
sb.Append(string.Empty.PadRight(41 - sb.Length, ' '));
sb.Append(instruction);
decoded.Add(new DecodedInstruction()
{
Address = address,
Length = len,
Instruction = instruction,
Full = sb.ToString()
});
count--;
if (count == 0)
{
break;
}
Offset += (uint)len;
}
return(decoded);
}
catch
{
return(decoded);
}
}
private X86Instruction Disassemble16(params byte[] bytes)
{
MemoryArea img = new MemoryArea(Address.SegPtr(0xC00, 0), bytes);
ImageReader rdr = img.CreateLeReader(img.BaseAddress);
var dasm = new X86Disassembler(ProcessorMode.Real, rdr, PrimitiveType.Word16, PrimitiveType.Word16, false);
if (options != null)
{
dasm.Emulate8087 = options.Emulate8087;
}
return(dasm.First());
}
protected override MemoryArea RewriteCode(uint[] words)
{
byte[] bytes = words.SelectMany(w => new byte[]
{
(byte) w,
(byte) (w >> 8),
(byte) (w >> 16),
(byte) (w >> 24)
}).ToArray();
this.image = new MemoryArea(LoadAddress, bytes);
var dasm = new XtensaDisassembler(arch, image.CreateLeReader(LoadAddress));
return image;
}
private void CreateDisassembler16(MemoryArea mem)
{
dasm = new X86Disassembler(
ProcessorMode.Real,
mem.CreateLeReader(mem.BaseAddress),
PrimitiveType.Word16,
PrimitiveType.Word16,
false);
if (options != null)
{
dasm.Emulate8087 = options.Emulate8087;
}
}
protected MachineInstruction DisassembleBits(string bitPattern)
{
var image = new MemoryArea(Address.Ptr32(0x00100000), new byte[4]);
LeImageWriter w = new LeImageWriter(image.Bytes);
uint instr = ParseBitPattern(bitPattern);
w.WriteLeUInt32(0, instr);
var b = image.Bytes;
//Debug.Print("Instruction bytes: {0:X2} {1:X2} {2:X2} {3:X2}", b[0], b[1], b[2], b[3]); // Spews in the unit tests
var arch = CreateArchitecture();
var dasm = arch.CreateDisassembler(image.CreateLeReader(0));
return(dasm.First());
}
public void X86Dis_RelocatedSegment()
{
byte[] image = new byte[] { 0x2E, 0xC7, 0x06, 0x01, 0x00, 0x00, 0x08 }; // mov cs:[0001],0800
MemoryArea img = new MemoryArea(Address.SegPtr(0x900, 0), image);
img.Relocations.AddSegmentReference(5, 0x0800);
ImageReader rdr = img.CreateLeReader(img.BaseAddress);
CreateDisassembler16(rdr);
X86Instruction instr = dasm.First();
Assert.AreEqual("mov\tword ptr cs:[0001],0800", instr.ToString());
Assert.AreEqual("selector", instr.op2.Width.ToString());
}
protected MachineInstruction Disassemble32(uint instr)
{
var image = new MemoryArea(Address.Ptr32(0x00100000), new byte[4]);
LeImageWriter w = new LeImageWriter(image.Bytes);
w.WriteLeUInt32(0, instr);
var arch = CreateArchitecture();
var dasm = CreateDisassembler(arch, image.CreateLeReader(0));
Assert.IsTrue(dasm.MoveNext());
this.armInstr = (AArch32Instruction)dasm.Current;
dasm.Dispose();
return(armInstr);
}
public void V850Dis_Generate()
{
var buf = new byte[10000];
var rnd = new Random(0x4711);
rnd.NextBytes(buf);
var mem = new MemoryArea(addr, buf);
var rdr = mem.CreateLeReader(mem.BaseAddress);
var dasm = arch.CreateDisassembler(rdr);
foreach (var instr in dasm)
{
dasm.ToString();
}
}
private void RunTest(string sExp, params byte[] bytes)
{
var image = new MemoryArea(Address.Ptr32(0x0100000), bytes);
var sc = new ServiceContainer();
sc.AddService <ITestGenerationService>(new UnitTestGenerationService(sc));
var arch = new CilArchitecture {
Services = sc,
};
var dasm = new CilDisassembler(arch, image.CreateLeReader(0)).GetEnumerator();
Assert.IsTrue(dasm.MoveNext());
var instr = dasm.Current;
Assert.AreEqual(sExp, instr.ToString());
}
protected MachineInstruction Disassemble16(params ushort[] instrs)
{
var image = new MemoryArea(Address.Ptr32(0x00100000), new byte[4]);
LeImageWriter w = new LeImageWriter(image.Bytes);
foreach (var instr in instrs)
{
w.WriteLeUInt16(instr);
}
var arch = CreateArchitecture();
var dasm = CreateDisassembler(arch, image.CreateLeReader(0));
Assert.IsTrue(dasm.MoveNext());
var armInstr = dasm.Current;
dasm.Dispose();
return(armInstr);
}
public void X86Dis_RelocatedOperand()
{
byte[] image = new byte[] { 0xB8, 0x78, 0x56, 0x34, 0x12 }; // mov eax,0x12345678
MemoryArea img = new MemoryArea(Address.Ptr32(0x00100000), image);
img.Relocations.AddPointerReference(0x00100001ul - img.BaseAddress.ToLinear(), 0x12345678);
ImageReader rdr = img.CreateLeReader(img.BaseAddress);
X86Disassembler dasm = new X86Disassembler(
ProcessorMode.Protected32,
rdr,
PrimitiveType.Word32,
PrimitiveType.Word32,
false);
X86Instruction instr = dasm.First();
Assert.AreEqual("mov\teax,12345678", instr.ToString());
Assert.AreEqual("ptr32", instr.op2.Width.ToString());
}
private void Given_Program()
{
var addrBase = Address.Ptr32(0x10000);
var mem = new MemoryArea(addrBase, new byte[100]);
var map = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var arch = new Mock <IProcessorArchitecture>();
var dasm = new Mock <IEnumerable <MachineInstruction> >();
var e = new Mock <IEnumerator <MachineInstruction> >();
arch.Setup(a => a.CreateDisassembler(It.IsNotNull <EndianImageReader>())).Returns(dasm.Object);
arch.Setup(a => a.InstructionBitSize).Returns(8);
arch.Setup(a => a.CreateImageReader(
It.IsNotNull <MemoryArea>(),
It.IsNotNull <Address>())).Returns(mem.CreateLeReader(addrBase));
dasm.Setup(d => d.GetEnumerator()).Returns(e.Object);
this.program = new Program(map, arch.Object, null);
}
private void Given_Program()
{
var addrBase = Address.Ptr32(0x10000);
var mem = new MemoryArea(addrBase, new byte[100]);
var map = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var arch = mr.Stub <IProcessorArchitecture>();
var dasm = mr.Stub <IEnumerable <MachineInstruction> >();
var e = mr.Stub <IEnumerator <MachineInstruction> >();
arch.Stub(a => a.CreateDisassembler(Arg <EndianImageReader> .Is.NotNull)).Return(dasm);
arch.Stub(a => a.InstructionBitSize).Return(8);
arch.Stub(a => a.CreateImageReader(
Arg <MemoryArea> .Is.NotNull,
Arg <Address> .Is.NotNull)).Return(mem.CreateLeReader(addrBase));
dasm.Stub(d => d.GetEnumerator()).Return(e);
arch.Replay();
dasm.Replay();
e.Replay();
this.program = new Program(map, arch, null);
}
public void Vb_CreateVector_ModifiesImageMap()
{
Given_Program(new byte[]
{
0x10, 0x00, 0x01, 0x00,
0x11, 0x00, 0x01, 0x00,
0x12, 0x00, 0x01, 0x00,
0xCC, 0xCC, 0xCC, 0xCC,
0xC3, 0xC3, 0xC3, 0xCC,
});
var scanner = mr.Stub <IScanner>();
scanner.Stub(s => s.CreateReader(program.ImageMap.BaseAddress))
.Return(mem.CreateLeReader(0));
var state = mr.Stub <ProcessorState>();
mr.ReplayAll();
var vb = new VectorBuilder(scanner, program, new DirectedGraphImpl <object>());
var vector = vb.BuildTable(program.ImageMap.BaseAddress, 12, null, 4, state);
Assert.AreEqual(3, vector.Count);
}
public void X86Arch_Inline_x86get_pc_thunk_bx()
{
arch = new X86ArchitectureFlat32("x86-protected-32");
var mem = new MemoryArea(Address.Ptr32(0x1000), new byte[]
{
0x8B, 0x1C, 0x24, // mov ebx,[esp]
0xC3 // ret
});
var cluster = arch.InlineCall(Address.Ptr16(0x1000), Address.Ptr32(0x2305), mem.CreateLeReader(0), arch.CreateFrame());
Assert.AreEqual(1, cluster.Count);
Assert.AreEqual("ebx = 00002305", cluster[0].ToString());
}
protected override IEnumerable <RtlInstructionCluster> GetInstructionStream(IStorageBinder binder, IRewriterHost host)
{
var state = new Mos6502ProcessorState(arch);
return(new Rewriter(arch, image.CreateLeReader(0), state, new Frame(arch.FramePointerType), host));
}
protected override IEnumerable <RtlInstructionCluster> GetRtlStream(MemoryArea mem, IStorageBinder binder, IRewriterHost host)
{
var rdr = mem.CreateLeReader(mem.BaseAddress);
return(arch.CreateRewriter(rdr, arch.CreateProcessorState(), binder, host));
}
