public Program(SegmentMap segmentMap, IProcessorArchitecture arch, IPlatform platform) : this()
{
this.SegmentMap = segmentMap;
this.ImageMap = segmentMap.CreateImageMap();
this.Architecture = arch;
this.Platform = platform;
}
public Program(SegmentMap segmentMap, IProcessorArchitecture arch, IPlatform platform) : this()
{
this.SegmentMap = segmentMap;
this.ImageMap = segmentMap.CreateImageMap();
this.Architecture = arch;
this.Platform = platform;
}
/// <summary>
/// Seed the imagemap with image symbols
/// </summary>
public void BuildImageMap()
{
if (!this.NeedsScanning)
{
return;
}
this.ImageMap = SegmentMap.CreateImageMap();
foreach (var sym in this.ImageSymbols.Values.Where(
s => s.Type == SymbolType.Data && s.DataType.BitSize != 0))
{
this.ImageMap.AddItemWithSize(
sym.Address,
new ImageMapItem
{
Address = sym.Address,
DataType = sym.DataType,
Size = (uint)sym.DataType.Size,
});
}
var tlDeser = CreateTypeLibraryDeserializer();
foreach (var kv in User.Globals)
{
var dt = kv.Value.DataType.Accept(tlDeser);
var size = GetDataSize(Architecture, kv.Key, dt);
var item = new ImageMapItem(size)
{
Address = kv.Key,
DataType = dt,
Name = kv.Value.Name,
};
if (item.Size > 0)
{
this.ImageMap.AddItemWithSize(kv.Key, item);
}
else
{
this.ImageMap.AddItem(kv.Key, item);
}
//$BUGBUG: what about x86 segmented binaries?
int offset = (int)kv.Key.ToLinear();
GlobalFields.Fields.Add(offset, dt, kv.Value.Name);
}
}
private void chkShowData_CheckedChanged(object sender, EventArgs e)
{
if (chkShowData.Checked)
{
var mem = new MemoryArea(Address.Ptr32(0x00100000), new byte[2560]);
var segMap = new SegmentMap(mem.BaseAddress,
new ImageSegment("", mem, AccessMode.ReadWriteExecute));
var imgMap = segMap.CreateImageMap();
imgMap.AddItemWithSize(Address.Ptr32(0x00100000), new ImageMapBlock { Size = 30 });
imgMap.AddItemWithSize(Address.Ptr32(0x00100100), new ImageMapBlock { Size = 300 });
imgMap.AddItemWithSize(Address.Ptr32(0x00100500), new ImageMapBlock { Size = 600 });
memoryControl1.Architecture = new X86ArchitectureFlat32();
imageMapView1.ImageMap = imgMap;
}
else
{
memoryControl1.Architecture = null;
}
}
private void Given_Program(byte[] bytes)
{
var addr = Address.Ptr32(0x1000);
var mem = new MemoryArea(addr, bytes);
this.segmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment(
"code", mem, AccessMode.ReadWriteExecute));
this.imageMap = segmentMap.CreateImageMap();
this.program = new Program(
segmentMap,
arch,
new DefaultPlatform(null, arch));
this.program.ImageMap = imageMap;
}
public Scanner(
Program program,
IImportResolver importResolver,
IServiceProvider services)
{
this.program = program;
this.segmentMap = program.SegmentMap;
this.importResolver = importResolver;
this.Services = services;
this.eventListener = services.RequireService<DecompilerEventListener>();
this.cancelSvc = services.GetService<CancellationTokenSource>();
if (segmentMap == null)
throw new InvalidOperationException("Program must have an segment map.");
if (program.ImageMap == null)
{
program.ImageMap = segmentMap.CreateImageMap();
}
this.imageMap = program.ImageMap;
this.queue = new PriorityQueue<WorkItem>();
this.blocks = new SortedList<Address, BlockRange>();
this.blockStarts = new Dictionary<Block, Address>();
this.pseudoProcs = program.PseudoProcedures;
this.importReferences = program.ImportReferences;
this.visitedProcs = new HashSet<Procedure>();
this.noDecompiledProcs = new Dictionary<Address, Procedure_v1>();
}
public void Im_CreateCoveringItem()
{
var segmentMap = new SegmentMap(Address.Ptr32(0x01000),
new ImageSegment(
".text",
new MemoryArea(Address.Ptr32(0x01010), new byte[0x10]),
AccessMode.ReadExecute));
var map = segmentMap.CreateImageMap();
Assert.AreEqual(1, map.Items.Count);
var item = map.Items.Values.First();
Assert.AreEqual(Address.Ptr32(0x1010), item.Address);
Assert.AreEqual(16, item.Size);
}
public void Im_RemoveItem_DoNotMergeDisjointItems()
{
var mem = new MemoryArea(addrBase, new byte[0x0100]);
var segmentMap = new SegmentMap(addrBase,
new ImageSegment("", mem, AccessMode.ReadWriteExecute));
var codeAddr = addrBase;
var dataAddr = addrBase + 0x1000;
var textAddr = addrBase + 0x2000;
segmentMap.AddSegment(codeAddr, "code", AccessMode.ReadWrite, 0x100);
segmentMap.AddSegment(dataAddr, "data", AccessMode.ReadWrite, 0x4);
segmentMap.AddSegment(textAddr, "text", AccessMode.ReadWrite, 0x100);
var map = segmentMap.CreateImageMap();
CreateImageMapItem(map, PrimitiveType.Int32, addrBase + 0x1000);
map.Dump();
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:1000", "8000:2000");
CheckImageMapSizes(map, 0x100, 0x4, 0x100);
map.RemoveItem(codeAddr);
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:1000", "8000:2000");
CheckImageMapSizes(map, 0x100, 0x4, 0x100);
map.RemoveItem(dataAddr);
CheckImageMapTypes(map, "<unknown>", "<unknown>", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:1000", "8000:2000");
CheckImageMapSizes(map, 0x100, 0x4, 0x100);
map.RemoveItem(textAddr);
CheckImageMapTypes(map, "<unknown>", "<unknown>", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:1000", "8000:2000");
CheckImageMapSizes(map, 0x100, 0x4, 0x100);
}
public void Im_RemoveItem()
{
var segmentMap = new SegmentMap(addrBase,
new ImageSegment("code", addrBase, 0x100, AccessMode.ReadWrite));
var map = segmentMap.CreateImageMap();
var itemAddress1 = addrBase;
var itemAddress2 = CreateImageMapItem(map, PrimitiveType.Int32);
var itemAddress3 = CreateImageMapItem(map, PrimitiveType.Int32);
var itemAddress4 = CreateImageMapItem(map, PrimitiveType.Int32);
var itemAddress5 = CreateImageMapItem(map, PrimitiveType.Int32);
map.Dump();
Assert.AreEqual(5, map.Items.Count);
map.RemoveItem(itemAddress5);
CheckImageMapTypes(map, "int32", "int32", "int32", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:0004", "8000:0008", "8000:000C", "8000:0010");
CheckImageMapSizes(map, 4, 4, 4, 4, 240);
map.RemoveItem(itemAddress1);
CheckImageMapTypes(map, "<unknown>", "int32", "int32", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:0004", "8000:0008", "8000:000C", "8000:0010");
CheckImageMapSizes(map, 4, 4, 4, 4, 240);
map.RemoveItem(itemAddress3);
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:0004", "8000:0008", "8000:000C", "8000:0010");
CheckImageMapSizes(map, 4, 4, 4, 4, 240);
map.RemoveItem(itemAddress2);
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:000C", "8000:0010");
CheckImageMapSizes(map, 12, 4, 240);
CreateImageMapItem(map, PrimitiveType.Int32, itemAddress3);
map.RemoveItem(itemAddress4);
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:0008", "8000:000C");
CheckImageMapSizes(map, 8, 4, 244);
CreateImageMapItem(map, PrimitiveType.Int32, itemAddress4);
map.RemoveItem(itemAddress3);
CheckImageMapTypes(map, "<unknown>", "int32", "<unknown>");
CheckImageMapAddresses(map, "8000:0000", "8000:000C", "8000:0010");
CheckImageMapSizes(map, 12, 4, 240);
map.RemoveItem(itemAddress4);
CheckImageMapTypes(map, "<unknown>");
CheckImageMapAddresses(map, "8000:0000");
CheckImageMapSizes(map, 256);
}
public void Im_CreateItem_AtExistingRange()
{
var segmentMap = new SegmentMap(addrBase,
new ImageSegment("code", addrBase, 0x100, AccessMode.ReadWrite));
var map = segmentMap.CreateImageMap();
map.AddItemWithSize(
addrBase,
new ImageMapItem(0x10) { DataType = new ArrayType(PrimitiveType.Byte, 0x10) });
map.Dump();
ImageMapItem item;
Assert.IsTrue(map.TryFindItemExact(addrBase, out item));
Assert.AreEqual("(arr byte 16)", item.DataType.ToString());
Assert.IsTrue(map.TryFindItemExact(addrBase + 0x10, out item));
Assert.IsInstanceOf<UnknownType>(item.DataType);
}
public void Im_CreateItem_MiddleOfEmptyRange()
{
var mem = new MemoryArea(addrBase, new byte[0x100]);
var segmentMap = new SegmentMap(addrBase,
new ImageSegment("code", mem, AccessMode.ReadWriteExecute));
var map = segmentMap.CreateImageMap();
map.AddItemWithSize(
addrBase + 0x10,
new ImageMapItem(0x10) { DataType = new ArrayType(PrimitiveType.Byte, 10) });
map.Dump();
Assert.AreEqual(3, map.Items.Count);
ImageMapItem item;
Assert.IsTrue(map.TryFindItemExact(addrBase, out item));
Assert.AreEqual(0x10, item.Size);
Assert.IsInstanceOf<UnknownType>(item.DataType);
}
private void Given_ExecutableProgram(string exeName, Address address)
{
var bytes = new byte[0x1000];
var mem = new MemoryArea(address, bytes);
var segmentMap = new SegmentMap(address,
new ImageSegment(".text", mem, AccessMode.ReadWriteExecute));
var program = new Program
{
Architecture = arch,
Platform = mockFactory.CreatePlatform(),
SegmentMap = segmentMap,
ImageMap = segmentMap.CreateImageMap()
};
loader.Stub(l => l.LoadImageBytes(
Arg<string>.Matches(s => s.EndsWith(exeName)),
Arg<int>.Is.Anything)).Return(bytes);
loader.Stub(l => l.LoadExecutable(
Arg<string>.Matches(s => s.EndsWith(exeName)),
Arg<byte[]>.Is.NotNull,
Arg<Address>.Is.Null)).Return(program);
}
