private static SparcInstruction DisassembleWord(uint instr)
{
var bytes = new byte[4];
new BeImageWriter(bytes).WriteBeUInt32(0, instr);
var img = new MemoryArea(Address.Ptr32(0x00100000), bytes);
return Disassemble(img);
}
public void Setup()
{
mr = new MockRepository();
form = new MainForm();
sc = new ServiceContainer();
loader = mr.StrictMock<ILoader>();
dec = mr.StrictMock<IDecompiler>();
sc = new ServiceContainer();
uiSvc = new FakeShellUiService();
host = mr.StrictMock<DecompilerHost>();
memSvc = mr.StrictMock<ILowLevelViewService>();
var mem = new MemoryArea(Address.Ptr32(0x10000), new byte[1000]);
var imageMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var arch = mr.StrictMock<IProcessorArchitecture>();
var platform = mr.StrictMock<IPlatform>();
program = new Program(imageMap, arch, platform);
project = new Project { Programs = { program } };
browserSvc = mr.StrictMock<IProjectBrowserService>();
sc.AddService<IDecompilerUIService>(uiSvc);
sc.AddService(typeof(IDecompilerShellUiService), uiSvc);
sc.AddService(typeof(IDecompilerService), new DecompilerService());
sc.AddService(typeof(IWorkerDialogService), new FakeWorkerDialogService());
sc.AddService(typeof(DecompilerEventListener), new FakeDecompilerEventListener());
sc.AddService(typeof(IProjectBrowserService), browserSvc);
sc.AddService(typeof(ILowLevelViewService), memSvc);
sc.AddService<ILoader>(loader);
sc.AddService<DecompilerHost>(host);
i = new TestInitialPageInteractor(sc, dec);
}
public void Setup()
{
mem = new MemoryArea(Address.Ptr32(0x00100000), new byte[1024]);
var arch = new FakeArchitecture();
this.program = new Program
{
Architecture = arch,
SegmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment(".text", mem, AccessMode.ReadWriteExecute)),
Platform = new DefaultPlatform(null, arch),
};
store = program.TypeStore;
factory = program.TypeFactory;
globals = program.Globals;
store.EnsureExpressionTypeVariable(factory, globals);
StructureType s = new StructureType(null, 0);
s.Fields.Add(0x00100000, PrimitiveType.Word32, null);
TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals);
EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals);
eqGlobals.DataType = s;
globals.TypeVariable.DataType = new Pointer(eqGlobals, 4);
globals.DataType = globals.TypeVariable.DataType;
}
private void BuildTest(params ushort[] words)
{
var bytes = words
.SelectMany(u => new byte[] { (byte)u, (byte)(u >> 8), })
.ToArray();
image = new MemoryArea(Address.Ptr32(0x00100000), bytes);
}
public SegmentMap ReadDataBlocks(LeImageReader rdr)
{
var segs = new List<ImageSegment>();
var addrMin = Address.Ptr16(0);
var addrMax = Address.Ptr16(0);
for (;;)
{
var seg = ReadDataBlock(rdr);
if (seg == null)
break;
segs.Add(seg);
addrMax = Address.Max(addrMax, seg.MemoryArea.EndAddress);
}
var image = new MemoryArea(addrMin, new byte[addrMax - addrMin]);
foreach (var seg in segs)
{
var bytes = seg.MemoryArea.Bytes;
Array.Copy(
bytes, 0,
image.Bytes, seg.Address.ToUInt16(),
bytes.Length);
}
return new SegmentMap(
addrMin,
new ImageSegment("image", image, AccessMode.ReadWriteExecute));
}
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();
}
public void Sm_Overlaps()
{
SegmentMap im = new SegmentMap(Address.SegPtr(0x8000, 0));
var mem = new MemoryArea(im.BaseAddress, new byte[40]);
var seg = new ImageSegment("8000", Address.SegPtr(0x8000, 10), mem, AccessMode.ReadWrite);
im.AddSegment(seg);
}
private MachineInstruction RunTest(params byte[] bytes)
{
var image = new MemoryArea(Address.Ptr32(0x200), bytes);
var rdr = new LeImageReader(image, 0);
var dasm = new Disassembler(rdr);
return dasm.First();
}
private void BuildTest(params string[] bitStrings)
{
var bytes = bitStrings.Select(bits => base.ParseBitPattern(bits))
.SelectMany(u => new byte[] { (byte) u, (byte) (u >> 8), (byte) (u >> 16), (byte) (u >> 24) })
.ToArray();
image = new MemoryArea(Address.Ptr32(0x00100000), bytes);
}
public void DecSvc_DecompilerProjectName()
{
IDecompilerService svc = new DecompilerService();
var loader = mr.StrictMock<ILoader>();
var host = mr.StrictMock<DecompilerHost>();
var arch = mr.StrictMock<IProcessorArchitecture>();
var platform = mr.StrictMock<IPlatform>();
var fileName = OsPath.Relative("foo", "bar", "baz.exe");
var bytes = new byte[100];
var mem = new MemoryArea(Address.Ptr32(0x1000), bytes);
var imageMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var prog = new Program(imageMap, arch, platform);
sc.AddService<DecompilerHost>(host);
platform.Stub(p => p.CreateMetadata()).Return(new TypeLibrary());
loader.Stub(l => l.LoadImageBytes(fileName, 0)).Return(bytes);
loader.Stub(l => l.LoadExecutable(fileName, bytes, null)).Return(prog);
loader.Replay();
var dec = new DecompilerDriver(loader, sc);
mr.ReplayAll();
svc.Decompiler = dec;
svc.Decompiler.Load(fileName);
Assert.IsNotNull(svc.Decompiler.Project);
Assert.AreEqual("baz.exe", svc.ProjectName, "Should have project name available.");
mr.VerifyAll();
}
public void UShortFixup()
{
var bytes = new byte[] { 0x01, 0x02, 0x03 };
var img = new MemoryArea(Address.SegPtr(0x0C00, 0), bytes);
ushort newSeg = img.FixupLeUInt16(1, 0x4444);
Assert.AreEqual(0x4746, newSeg);
}
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());
}
private ImageSegment Given_Image(int size)
{
var bytes = Enumerable.Range(0, size).Select(b => (byte)b).ToArray();
var mem = new MemoryArea(Address.Ptr32(0x1000000), bytes);
var seg = new ImageSegment(".text", mem, AccessMode.ReadExecute);
program.SegmentMap = new SegmentMap(mem.BaseAddress, seg);
return seg;
}
public void ReadLeNegativeInt()
{
MemoryArea img = new MemoryArea(Address.Ptr32(0x10000), new byte[] {
0xFE, 0xFF, 0xFF, 0xFF });
Constant c = img.ReadLe(0, PrimitiveType.Int32);
Assert.AreSame(PrimitiveType.Int32, c.DataType);
Assert.AreEqual("-2", c.ToString());
}
private void BuildTest(params ushort[] words)
{
var bytes = words
.SelectMany(
w => new byte[] { (byte)w, (byte)(w >> 8) })
.ToArray();
image = new MemoryArea(LoadAddress, bytes);
}
public void ReadLeUInt32()
{
MemoryArea img = new MemoryArea(Address.Ptr32(0x10000), new byte[] {
0x78, 0x56, 0x34, 0x12 });
Constant c = img.ReadLe(0, PrimitiveType.Word32);
Assert.AreSame(PrimitiveType.Word32, c.DataType);
Assert.AreEqual("0x12345678", c.ToString());
}
public void Sm_AddSegment()
{
var map = new SegmentMap(addrBase);
var mem = new MemoryArea(addrBase, new byte[0x4000]);
var seg = new ImageSegment("8100", Address.SegPtr(0x8100, 0), mem, AccessMode.ReadWriteExecute);
map.AddSegment(seg);
Assert.AreEqual(0x3000, seg.Size);
}
/// <summary>
/// Use this constructor when the segment shares the MemoryArea with
/// other segments.
/// </summary>
/// <param name="name"></param>
/// <param name="addr"></param>
/// <param name="mem"></param>
/// <param name="access"></param>
public ImageSegment(string name, Address addr, MemoryArea mem, AccessMode access) : base()
{
if (name == null)
throw new ArgumentNullException("name", "Segments must have names.");
this.Name = name;
this.Address = addr;
this.MemoryArea = mem;
this.Access = access;
}
public ImageSegment AddSegment(MemoryArea mem, string segmentName, AccessMode mode)
{
var segment = new ImageSegment(
segmentName,
mem,
mode);
AddSegment(segment);
return segment;
}
private void Given_Image(params byte[] bytes)
{
addrBase = Address.Ptr32(0x00010000);
var mem = new MemoryArea(addrBase, bytes);
program.SegmentMap = new SegmentMap(addrBase);
program.SegmentMap.AddSegment(mem, ".text", AccessMode.ReadWriteExecute);
program.ImageMap = program.SegmentMap.CreateImageMap();
arch.Stub(a => a.CreateImageReader(mem, addrBase)).Return(new LeImageReader(mem, 0));
}
private ImageWriter Memory(uint address)
{
mem = new MemoryArea(Address.Ptr32(address), new byte[1024]);
imageMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment(".data", mem, AccessMode.ReadWrite));
var writer = new LeImageWriter(mem.Bytes);
return writer;
}
private void Rewrite(params ushort[] opcodes)
{
byte[] bytes = new byte[opcodes.Length * 2];
var writer = new BeImageWriter(bytes);
foreach (ushort opcode in opcodes)
{
writer.WriteBeUInt16(opcode);
}
mem = new MemoryArea(addrBase, bytes);
}
public Program GetImage()
{
var mem = new MemoryArea(BaseAddress, emitter.GetBytes());
return new Program(
new SegmentMap(
mem.BaseAddress,
new ImageSegment(".text", mem, AccessMode.ReadWriteExecute)),
arch,
new DefaultPlatform(null, arch));
}
private SegmentMap CreateSegmentMap(MemoryArea mem, IPlatform platform)
{
var segmentMap = platform.CreateAbsoluteMemoryMap();
var romSegment = segmentMap.Segments.Values.First(s => s.Name == ".text");
romSegment.ContentSize = (uint)mem.Length;
romSegment.MemoryArea = mem;
var ramSegment = segmentMap.Segments.Values.First(s => s.Name == ".data");
ramSegment.MemoryArea = new MemoryArea(ramSegment.Address, new byte[ramSegment.Size]);
return segmentMap;
}
public ProgramBuilder(MemoryArea mem)
{
Program = new Program
{
SegmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute)),
Architecture = new FakeArchitecture()
};
}
protected override IEnumerable<RtlInstructionCluster> GetInstructionStream(Frame frame, IRewriterHost host)
{
var addr = Address.Ptr16(10);
var image = new MemoryArea(addr, new byte[1]);
return arch.CreateRewriter(
arch.CreateImageReader(image, addr),
arch.CreateProcessorState(),
frame,
host);
}
/// <summary>
/// Use this constructor when the segment's memory area is completely
/// disjoint fromother segments. This is usually the case in PE or ELF
/// binaries.
/// </summary>
/// <param name="name"></param>
/// <param name="mem"></param>
/// <param name="access"></param>
public ImageSegment(string name, MemoryArea mem, AccessMode access)
{
if (name == null)
throw new ArgumentNullException("name", "Segments must have names.");
this.Name = name;
this.Size = (uint)mem.Length;
this.Address = mem.BaseAddress;
this.MemoryArea = mem;
this.Access = access;
}
public override Program Load(Address addrLoad)
{
int iImageStart = (exe.e_cparHeader * 0x10);
int cbImageSize = exe.e_cpImage * ExeImageLoader.CbPageSize - iImageStart;
byte[] bytes = new byte[cbImageSize];
int cbCopy = Math.Min(cbImageSize, RawImage.Length - iImageStart);
Array.Copy(RawImage, iImageStart, bytes, 0, cbCopy);
imgLoaded = new MemoryArea(addrLoad, bytes);
segmentMap = new SegmentMap(addrLoad);
return new Program(segmentMap, arch, platform);
}
private void btnLoad_Click(object sender, EventArgs e)
{
var mem = new MemoryArea(Address.Ptr32(0x12312300),new byte[0x1000]);
var imageMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var arch = new X86ArchitectureFlat32();
var program = new Core.Program(imageMap, arch, new DefaultPlatform(null, arch));
var project = new Project { Programs = { program } };
pbs.Load(project);
}
public override Program Load(Address addrLoad)
{
ldr = CreateParser();
uint ncmds = ldr.ParseHeader(addrLoad);
SegmentMap segmentMap = ldr.ParseLoadCommands(ncmds, addrLoad);
var image = new MemoryArea(addrLoad, RawImage);
return new Program(
segmentMap,
ldr.arch,
new DefaultPlatform(Services, ldr.arch));
}
Control DumpBytes()
{
var mem = new Reko.Core.MemoryArea(Address.Ptr32(0), resource.Bytes);
var memCtrl = new MemoryControl();
memCtrl.Services = services;
memCtrl.SegmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("resource", mem, AccessMode.Read));
memCtrl.Architecture = program.Architecture;
memCtrl.Font = new Font("Lucida Console", 10F); //$TODO: use user preference
return(memCtrl);
}
