private void Given_Table_UInt32(Address address, params uint[] entries)
{
ImageSegment seg;
program.SegmentMap.Segments.TryGetValue(address, out seg);
var writer = new LeImageWriter(seg.MemoryArea, address);
foreach (uint entry in entries)
{
writer.WriteLeUInt32(entry);
}
}
protected MachineInstruction Disassemble(uint instr)
{
var image = new LoadedImage(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());
return(dasm.Current);
}
protected MemoryArea CreateMemoryArea(Address addr, params uint[] opcodes)
{
byte[] bytes = new byte[0x20];
var writer = new LeImageWriter(bytes);
uint offset = 0;
for (int i = 0; i < opcodes.Length; ++i, offset += 4)
{
writer.WriteLeUInt32(offset, opcodes[i]);
}
return(new MemoryArea(addr, bytes));
}
/// <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 mem = new ByteMemoryArea(Address.Ptr32(0x00100000), w.ToArray());
var arch = CreateArchitecture();
this.dasm = CreateDisassembler(arch, mem.CreateLeReader(0));
}
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);
}
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());
}
private MachineInstruction RunTest(params ushort[] words)
{
var bytes = new byte[words.Length * 2];
LeImageWriter writer = new LeImageWriter(bytes);
foreach (ushort word in words)
{
writer.WriteLeUInt16(word);
}
var image = new MemoryArea(Address.Ptr16(0x200), bytes);
var rdr = new LeImageReader(image, 0);
var arch = new Pdp11Architecture(new ServiceContainer(), "pdp11");
var dasm = new Pdp11Disassembler(rdr, arch);
return(dasm.First());
}
private MachineInstruction[] DisassembleWords(params ushort[] words)
{
var bytes = new byte[words.Length * 2];
LeImageWriter writer = new LeImageWriter(bytes);
foreach (ushort word in words)
{
writer.WriteLeUInt16(word);
}
var image = new MemoryArea(Address.Ptr16(0x200), bytes);
var rdr = new LeImageReader(image, 0);
var arch = new Pdp11Architecture();
var dasm = new Pdp11Disassembler(rdr, arch);
return(dasm.ToArray());
}
private void Given_IndirectTable_UInt32(Address address, Address addrIndirect, params uint[] entries)
{
ImageSegment seg;
program.SegmentMap.Segments.TryGetValue(address, out seg);
var writer = new LeImageWriter(seg.MemoryArea, address);
foreach (uint entry in entries)
{
writer.WriteLeUInt32(entry);
}
writer = new LeImageWriter(seg.MemoryArea, addrIndirect);
for (int i = 0; i < entries.Length; ++i)
{
writer.WriteByte((byte)i);
}
}
protected ImageWriter Given_section(string name, uint uAddress, int len)
{
var addr = Address.Ptr32(uAddress);
var mem = new ByteMemoryArea(addr, new byte[len]);
var writer = new LeImageWriter(mem, 0);
var section = new ElfSection
{
Name = name,
Address = Address.Ptr32(uAddress)
};
loader.Sections.Add(section);
var seg = new ImageSegment(section.Name, mem, AccessMode.ReadWriteExecute);
program.SegmentMap.AddSegment(seg);
return(writer);
}
private byte[] CreateMsdosHeader()
{
ImageWriter stm = new LeImageWriter(new byte[16]);
stm.WriteByte(0x4D); // MZ
stm.WriteByte(0x5A);
stm.WriteBytes(0xCC, 4);
stm.WriteLeUInt16(0x0090);
stm.WriteBytes(0xCC, 0x12);
stm.WriteByte(0x00);
stm.WriteByte(0x00);
stm.WriteByte(0x05);
stm.WriteByte(0x21);
stm.WriteString("PKLITE", Encoding.ASCII);
stm.WriteBytes(0xCC, 0x0C);
return(stm.Bytes);
}
public void DynLink_LP32_weirdness()
{
var memText = new ByteMemoryArea(Address.Ptr64(0x00123400), new byte[100]);
var memGot = new ByteMemoryArea(Address.Ptr64(0x00200000), new byte[100]);
var wr = new LeImageWriter(memGot.Bytes);
wr.WriteLeUInt32(0x00300000);
wr.WriteLeUInt32(0x00300004);
var arch = new FakeArchitecture64(new ServiceContainer());
//var arch = new Mock<IProcessorArchitecture>();
//arch.Setup(a => a.Endianness).Returns(EndianServices.Little);
//arch.Setup(a => a.Name).Returns("fakeArch");
//arch.Setup(a => a.PointerType).Returns(PrimitiveType.Ptr64);
//arch.Setup(a => a.MakeAddressFromConstant(
// It.IsAny<Constant>(),
// It.IsAny<bool>())).Returns((Constant c, bool b) =>
// Address.Ptr64(c.ToUInt32()));
var project = new Project();
var sc = new ServiceContainer();
var program = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(sc, arch),
SegmentMap = new SegmentMap(memGot.BaseAddress,
new ImageSegment(".text", memText, AccessMode.ReadExecute),
new ImageSegment(".got", memGot, AccessMode.Read)),
};
program.ImportReferences.Add(
Address.Ptr32(0x00200000),
new NamedImportReference(
Address.Ptr32(0x00200000), null, "my_global_var", SymbolType.Data));
var dynlink = new DynamicLinker(project, program, new FakeDecompilerEventListener());
var m = new ExpressionEmitter();
var addr = Address.Ptr64(0x00123000);
var proc = program.EnsureProcedure(program.Architecture, addr, "foo_proc");
var block = new Block(proc, addr, "foo");
var stm = new Statement(0x00123400, new Store(m.Word64(0x00123400), Constant.Real32(1.0F)), block);
var result = dynlink.ResolveToImportedValue(stm, Constant.Word32(0x00200000));
Assert.AreEqual("0x300000<64>", result.ToString()); //$LIT: pointer? p64?
}
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 Setup()
{
sc = new ServiceContainer();
mr = new MockRepository();
addrLoad = Address.Ptr32(0x00100000);
fileImage = new byte[0x4000];
writer = new LeImageWriter(fileImage);
var cfgSvc = mr.StrictMock <IConfigurationService>();
Given_i386_Architecture();
var win32 = new Win32Platform(sc, arch_386);
var win32Env = mr.Stub <OperatingEnvironment>();
cfgSvc.Stub(c => c.GetArchitecture("x86-protected-32")).Return(arch_386);
cfgSvc.Stub(c => c.GetEnvironment("win32")).Return(win32Env);
win32Env.Stub(w => w.Load(null, null)).IgnoreArguments().Return(win32);
sc.AddService <IConfigurationService>(cfgSvc);
}
private void Given_MzExeProgram(uint size)
{
this.writer = new LeImageWriter();
writer.WriteBytes(0, size);
var pos = writer.Position;
writer.Position = 0;
writer.WriteString("MZ", Encoding.ASCII);
uint cPages = size / ExeImageLoader.CbPageSize;
uint cbLastPage = size % ExeImageLoader.CbPageSize;
if (cbLastPage > 0)
{
++cPages;
}
writer.WriteLeUInt16((ushort)cbLastPage);
writer.WriteLeUInt16((ushort)cPages);
writer.Position = pos;
}
public void Setup()
{
sc = new ServiceContainer();
mr = new MockRepository();
addrLoad = Address.Ptr32(0x00100000);
fileImage = new byte[0x4000];
writer = new LeImageWriter(fileImage);
var cfgSvc = mr.StrictMock <IConfigurationService>();
var dcSvc = mr.Stub <DecompilerEventListener>();
Given_i386_Architecture();
this.win32 = mr.PartialMock <Win32Platform>(sc, arch_386);
// Avoid complications with the FindMainProcedure call.
this.win32.Stub(w => w.FindMainProcedure(null, null)).IgnoreArguments().Return(null);
var win32Env = mr.Stub <OperatingEnvironment>();
cfgSvc.Stub(c => c.GetArchitecture("x86-protected-32")).Return(arch_386);
cfgSvc.Stub(c => c.GetEnvironment("win32")).Return(win32Env);
win32Env.Stub(w => w.Load(null, null)).IgnoreArguments().Return(win32);
sc.AddService <IConfigurationService>(cfgSvc);
sc.AddService <DecompilerEventListener>(dcSvc);
}
private void Given_String(string str, uint addr)
{
var w = new LeImageWriter(mem.Bytes, addr - (uint)mem.BaseAddress.ToLinear());
w.WriteString(str, Encoding.ASCII);
}
public void Setup()
{
this.writer = null;
this.exeLoader = null;
this.offNames = -1;
}
public void Setup()
{
this.writer = new LeImageWriter();
}
/// <summary>
/// Unpacks the packed raw image into <paramref name="image" />.
/// </summary>
private void UnpackImage(FileHeader fileHeader, ByteMemoryArea image)
{
var w = new LeImageWriter(image.Bytes);
//
// Still looking for additional information on Pharlap file packing
//
// Packing implemented is currently based on reviewing code and interpretation of data against loading program in debugger.
// Record is 16 bit word.
// If bit 15 is clear ie 0-7FFF, load the next record number of bytes into memory
//
// If bit 15 is set, ie 8000-FFFF use value lower 15 bits for size of repeat area
// Next byte (dataSize) defines size of item to be repeated
// If dataSize size is larger than size of repeat area, corrupt file
// if dataSize is 0, then is either fill with zero or skip, size of repeat area
// Read itemSize number of bytes for the repeatData
// copying repeatData until filled size of repeat area
//
var rdr = new LeImageReader(RawImage, FileHeaderOffset + fileHeader.offset_load_image);
while (w.Position < fileHeader.memory_requirements)
{
if (!rdr.TryReadUInt16(out ushort us))
{
throw new BadImageFormatException("Unexpected EOF while loading program.");
}
if ((us & 0x8000) == 0)
{
rdr.ReadBytes(w.Bytes, w.Position, us);
w.Position += us;
}
else
{
us &= 0x7FFF;
if (!rdr.TryReadByte(out var dataSize))
{
throw new BadImageFormatException("Unexpected EOF while loading program.");
}
if (dataSize > us)
{
throw new BadImageFormatException("Corrupt file"); // Corrupt file, Repeated data shouldn't be bigger than size of repeat block
}
if (dataSize == 0)
{
for (int i = 0; i < us; ++i)
{
w.WriteByte(dataSize);
}
}
else
{
var repeatData = new byte[dataSize];
for (int i = 0; i < dataSize; ++i)
{
if (!rdr.TryReadByte(out var b))
{
throw new BadImageFormatException("Unexpected EOF while loading program.");
}
repeatData[i] = b;
}
for (int i = 0; i < us; i += dataSize)
{
w.WriteBytes(repeatData);
}
}
}
}
}
