public void Bwi_IndirectCallMatchedByPlatform()
{
var platform = mr.StrictMock <IPlatform>();
var reg0 = proc.Frame.EnsureRegister(new RegisterStorage("r0", 0, 0, PrimitiveType.Pointer32));
var reg1 = proc.Frame.EnsureRegister(new RegisterStorage("r1", 1, 0, PrimitiveType.Pointer32));
var sysSvc = new SystemService {
Name = "SysSvc",
Signature = FunctionType.Action(new[] { reg1 }),
Characteristics = new ProcedureCharacteristics()
};
platform.Expect(p => p.FindService(null, arch.CreateProcessorState())).IgnoreArguments().Return(sysSvc);
platform.Stub(p => p.PointerType).Return(PrimitiveType.Pointer32);
program.Platform = platform;
scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x100000))).Return(block);
scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x100004))).Return(block);
scanner.Stub(s => s.GetTrace(null, null, null)).IgnoreArguments().Return(trace);
mr.ReplayAll();
trace.Add(m => m.Call(m.LoadDw(m.IAdd(reg0, -32)), 4));
var wi = CreateWorkItem(Address.Ptr32(0x100000), arch.CreateProcessorState());
wi.Process();
Assert.AreEqual("SysSvc(r1)", block.Statements[0].ToString());
mr.VerifyAll();
}
public void Setup()
{
arch = new FakeArchitecture();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
host = new BackwalkerHost(arch);
}
public void Setup()
{
arch = new X86ArchitectureFlat32();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
SCZO = m.Frame.EnsureFlagGroup(Registers.eflags, (uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost(arch);
}
public void Setup()
{
arch = new FakeArchitecture();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
listener = new FakeDecompilerEventListener();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState(), listener);
host = new BackwalkerHost(arch);
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
SCZO = m.Frame.EnsureFlagGroup((uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost();
}
private EntryPoint LoadEntryPoint(Address addrLoad, ImageReader rdrAddrs, ImageReader rdrNames)
{
uint addr = rdrAddrs.ReadLeUInt32();
int iNameMin = rdrNames.ReadLeInt32();
int j;
for (j = iNameMin; imgLoaded.Bytes[j] != 0; ++j)
;
char[] chars = Encoding.ASCII.GetChars(imgLoaded.Bytes, iNameMin, j - iNameMin);
return new EntryPoint(addrLoad + addr, new string(chars), arch.CreateProcessorState());
}
public override RelocationResults Relocate(Program program, Address addrLoad)
{
var entryNames = LoadEntryNames();
var entryPoints = LoadEntryPoints(entryNames);
entryPoints.Add(new EntryPoint(addrEntry, arch.CreateProcessorState()));
return(new RelocationResults(
entryPoints,
new List <Address>()));
}
private void Enqueue(Address addr, Procedure proc)
{
fakeArch.Test_AddTrace(new RtlTrace(addr.ToUInt32())
{
m => {
m.Assign(m.Mem32(m.Word32(0x3000)), m.Word32(42));
}
});
scan.EnqueueJumpTarget(addr, addr, proc, arch.CreateProcessorState());
}
public void Scanner_AddEntryPoint()
{
Given_Trace(new RtlTrace(0x12314)
{
m => { m.Return(4, 0); }
});
Given_Program(Address.Ptr32(0x12314));
var project = new Project {
Programs = { program }
};
var sc = new Scanner(
program,
null,
new ImportResolver(project),
new FakeDecompilerEventListener());
sc.EnqueueEntryPoint(
new EntryPoint(
Address.Ptr32(0x12314),
arch.CreateProcessorState()));
sc.ScanImage();
Assert.AreEqual(1, program.Procedures.Count);
Assert.AreEqual(0x12314, program.Procedures.Keys[0].Offset);
Assert.IsTrue(program.CallGraph.EntryPoints.Contains(program.Procedures.Values[0]));
}
public static Address GetRawBinaryEntryAddress(
RawFileDefinition rawFile,
byte[] image,
IProcessorArchitecture arch,
Address baseAddr)
{
if (!string.IsNullOrEmpty(rawFile.EntryPoint.Address))
{
if (arch.TryParseAddress(rawFile.EntryPoint.Address, out Address entryAddr))
{
if (rawFile.EntryPoint.Follow)
{
var rdr = arch.CreateImageReader(new MemoryArea(baseAddr, image), entryAddr);
var addr = arch.ReadCodeAddress(0, rdr, arch.CreateProcessorState());
return(addr);
}
else
{
return(entryAddr);
}
}
else
{
return(baseAddr);
}
}
return(baseAddr);
}
public List <ImageSymbol> LoadEntryPoints(Dictionary <int, string> names)
{
var rdr = new LeImageReader(RawImage, this.lfaNew + this.offEntryTable);
var entries = new List <ImageSymbol>();
for (;;)
{
var cEntries = rdr.ReadByte();
if (cEntries == 0)
{
break;
}
var segNum = rdr.ReadByte();
var seg = this.segments[segNum - 1];
for (int i = 0; i < cEntries; ++i)
{
var flags = rdr.ReadByte();
var offset = rdr.ReadUInt16();
string name;
var addr = seg.Address + offset;
var state = arch.CreateProcessorState();
ImageSymbol ep = new ImageSymbol(addr);
if (names.TryGetValue(entries.Count, out name))
{
ep.Name = name;
}
ep.Type = SymbolType.Procedure;
ep.ProcessorState = state;
imageSymbols[ep.Address] = ep;
entries.Add(ep);
}
}
return(entries);
}
public override RelocationResults Relocate(Program program, Address addrLoad)
{
var relocations = imgU.Relocations;
ushort segCode = (ushort)(addrLoad.Selector.Value + (PspSize >> 4));
for (;;)
{
int relocs = (ushort)bitStm.GetByte();
if (relocs == 0)
{
break;
}
uint relocBase = PspSize + bitStm.GetWord() * 0x10u;
do
{
ushort relocOff = bitStm.GetWord();
ushort seg = imgU.ReadLeUInt16(relocBase + relocOff);
seg = (ushort)(seg + segCode);
imgU.WriteLeUInt16(relocBase + relocOff, seg);
relocations.AddSegmentReference(relocBase + relocOff, seg);
segmentMap.AddSegment(Address.SegPtr(seg, 0), seg.ToString("X4"), AccessMode.ReadWriteExecute, 0);
} while (--relocs != 0);
}
ushort pklSs = (ushort)(bitStm.GetWord() + segCode);
ushort pklSp = (ushort)bitStm.GetWord();
pklCs = (ushort)(bitStm.GetWord() + segCode);
pklIp = bitStm.GetWord();
var state = arch.CreateProcessorState();
state.SetRegister(Registers.ds, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.es, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.cs, Constant.Word16(pklCs));
state.SetRegister(Registers.ax, Constant.Word16(0));
state.SetRegister(Registers.bx, Constant.Word16(0));
state.SetRegister(Registers.cx, Constant.Word16(0));
state.SetRegister(Registers.dx, Constant.Word16(0));
state.SetRegister(Registers.bp, Constant.Word16(0));
state.SetRegister(Registers.sp, Constant.Word16(pklSp));
state.SetRegister(Registers.si, Constant.Word16(0));
state.SetRegister(Registers.di, Constant.Word16(0));
var sym = new ImageSymbol(Address.SegPtr(pklCs, pklIp))
{
Type = SymbolType.Procedure,
ProcessorState = state
};
return(new RelocationResults(
new List <ImageSymbol> {
sym
},
new SortedList <Address, ImageSymbol> {
{ sym.Address, sym }
}));
}
/* load file in TLD or XTC Load Module format */
public override Program Load(Address addrLoad, IProcessorArchitecture arch, IPlatform platform)
{
linecnt = 0;
var loadfile_type = TLD_LDM;
this.simreg = arch.CreateProcessorState();
using var mem = new MemoryStream(RawImage);
using var loadfile = new StreamReader(mem, Encoding.ASCII);
for (; ;)
{
string lline = loadfile.ReadLine();
if (lline == null)
{
break;
}
++linecnt;
if (lline.Length < 2)
{
continue;
}
this.load_ldmline[loadfile_type](lline);
}
DumpMap();
return(new Program(MakeSegmentMap(), arch, platform));
}
public override RelocationResults Relocate(Address addrLoad)
{
ImageMap imageMap = imgLoadedMap;
ImageReader rdr = new LeImageReader(exe.RawImage, (uint)exe.e_lfaRelocations);
var relocations = new RelocationDictionary();
int i = exe.e_cRelocations;
while (i != 0)
{
uint offset = rdr.ReadLeUInt16();
ushort segOffset = rdr.ReadLeUInt16();
offset += segOffset * 0x0010u;
ushort seg = (ushort)(imgLoaded.ReadLeUInt16(offset) + addrLoad.Selector);
imgLoaded.WriteLeUInt16(offset, seg);
relocations.AddSegmentReference(offset, seg);
imageMap.AddSegment(Address.SegPtr(seg, 0), seg.ToString("X4"), AccessMode.ReadWriteExecute);
--i;
}
// Found the start address.
Address addrStart = Address.SegPtr((ushort)(exe.e_cs + addrLoad.Selector), exe.e_ip);
imageMap.AddSegment(Address.SegPtr(addrStart.Selector, 0), addrStart.Selector.ToString("X4"), AccessMode.ReadWriteExecute);
return(new RelocationResults(
new List <EntryPoint> {
new EntryPoint(addrStart, arch.CreateProcessorState())
},
relocations));
}
// Fix up the relocations.
public override RelocationResults Relocate(Program program, Address addrLoad)
{
// Seed the scanner with the start location.
var sym = ImageSymbol.Procedure(
program.Architecture,
Address.SegPtr((ushort)(lzCs + addrLoad.Selector !), lzIp),
state: arch.CreateProcessorState());
var imageSymbols = new SortedList <Address, ImageSymbol> {
{ sym.Address, sym }
};
List <ImageSymbol> entryPoints = new List <ImageSymbol>()
{
sym
};
if (isLz91)
{
Relocate91(RawImage, addrLoad.Selector !.Value, imgLoaded);
}
else
{
Relocate90(RawImage, addrLoad.Selector !.Value, imgLoaded);
}
return(new RelocationResults(entryPoints, imageSymbols));
}
public void AddResourcesToImageMap(Address addrLoad, MemoryArea mem, ImageMap imageMap, List <EntryPoint> entryPoints)
{
foreach (ResourceType type in ResourceTypes)
{
foreach (ResourceReference rsrc in type.References)
{
Address addrSegment = addrLoad + rsrc.DataOffset + rsrcDataOff;
var segment = imageMap.AddSegment(new ImageSegment(
ResourceDescriptiveName(type, rsrc),
addrSegment,
mem,
AccessMode.Read));
if (type.Name == "CODE")
{
if (rsrc.ResourceID == 0)
{
ProcessJumpTable(rsrcDataOff + rsrc.DataOffset + 4);
}
else
{
entryPoints.Add(new EntryPoint(addrSegment + 4, arch.CreateProcessorState()));
}
}
}
}
}
private ImageSymbol LoadEntryPoint(Address addrLoad, ImageReader rdrAddrs, ImageReader rdrNames)
{
uint rvaAddr = rdrAddrs.ReadLeUInt32();
int iNameMin = rdrNames.ReadLeInt32();
int j;
for (j = iNameMin; imgLoaded.Bytes[j] != 0; ++j)
{
;
}
char[] chars = Encoding.ASCII.GetChars(imgLoaded.Bytes, iNameMin, j - iNameMin);
return(new ImageSymbol(addrLoad + rvaAddr)
{
Name = new string(chars),
ProcessorState = arch.CreateProcessorState(),
Type = SymbolType.Procedure,
});
}
public List <ImageSymbol> LoadEntryPoints(
uint offEntryTable,
NeSegment [] segments,
Dictionary <int, string> names,
IProcessorArchitecture arch)
{
DebugEx.PrintIf(trace.TraceInfo, "== Loading entry points from offset {0:X}", offEntryTable);
var rdr = new LeImageReader(RawImage, offEntryTable);
var entries = new List <ImageSymbol>();
int bundleOrdinal = 1;
int nextbundleOrdinal = 1;
for (; ;)
{
var cBundleEntries = rdr.ReadByte();
if (cBundleEntries == 0)
{
break;
}
nextbundleOrdinal = bundleOrdinal + cBundleEntries;
var segNum = rdr.ReadByte();
for (int i = 0; i < cBundleEntries; ++i)
{
byte flags = rdr.ReadByte();
if (flags == 0)
{
break;
}
(byte iSeg, ushort offset)entry;
if (segNum == 0xFF)
{
entry = ReadMovableSegmentEntry(rdr);
}
else
{
entry = ReadFixedSegmentEntry(rdr, segNum);
}
var state = arch.CreateProcessorState();
var seg = segments[entry.iSeg - 1];
var addr = seg.Address + entry.offset;
ImageSymbol ep = new ImageSymbol(addr);
if (names.TryGetValue(bundleOrdinal + i, out string name))
{
ep.Name = name;
}
ep.Type = SymbolType.Procedure;
ep.ProcessorState = state;
imageSymbols[ep.Address] = ep;
entries.Add(ep);
DebugEx.PrintIf(trace.TraceVerbose, " {0}", ep);
}
bundleOrdinal = nextbundleOrdinal;
}
return(entries);
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(
new IntelArchitecture(ProcessorMode.Protected32).CreateProcessorState());
SCZO = m.Frame.EnsureFlagGroup((uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost();
}
public void Setup()
{
arch = new FakeArchitecture(new ServiceContainer());
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
listener = new FakeDecompilerEventListener();
var segmentMap = new SegmentMap(Address.Ptr32(0));
expSimp = new ExpressionSimplifier(segmentMap, state, listener);
host = new BackwalkerHost(arch);
}
public List<ImageSymbol> LoadEntryPoints(
uint offEntryTable,
NeSegment [] segments,
Dictionary<int, string> names,
IProcessorArchitecture arch)
{
DebugEx.Inform(trace, "== Loading entry points from offset {0:X}", offEntryTable);
var rdr = new LeImageReader(RawImage, offEntryTable);
var entries = new List<ImageSymbol>();
int bundleOrdinal = 1;
int nextbundleOrdinal = 1;
for (; ; )
{
var cBundleEntries = rdr.ReadByte();
if (cBundleEntries == 0)
break;
nextbundleOrdinal = bundleOrdinal + cBundleEntries;
var segNum = rdr.ReadByte();
if (segNum != 0)
{
// If segNum had been 0, it would have
// meant that all we want to do is allocate
// (skip) some ordinal numbers. Since it wasn't 0,
// we proceed to generate entry points.
for (int i = 0; i < cBundleEntries; ++i)
{
byte flags = rdr.ReadByte();
(byte iSeg, ushort offset) entry;
if (segNum == 0xFF)
{
entry = ReadMovableSegmentEntry(rdr);
}
else
{
entry = ReadFixedSegmentEntry(rdr, segNum);
}
var seg = segments[entry.iSeg - 1];
var addr = seg.Address + entry.offset;
var ep = ImageSymbol.Procedure(arch, addr);
if (names.TryGetValue(bundleOrdinal + i, out string name))
{
ep.Name = name;
}
ep.Type = SymbolType.Procedure;
ep.ProcessorState = arch.CreateProcessorState();
imageSymbols[ep.Address] = ep;
entries.Add(ep);
DebugEx.Verbose(trace, " {0:X2} {1} {2} - {3}", segNum, ep.Address, ep.Name, bundleOrdinal + i);
}
}
bundleOrdinal = nextbundleOrdinal;
}
return entries;
}
public void Setup()
{
arch = new X86ArchitectureFlat32("x86-protected-32");
m = new ProcedureBuilder();
var map = new SegmentMap(Address.Ptr32(0x10000000));
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(map, state, new FakeDecompilerEventListener());
SCZO = m.Frame.EnsureFlagGroup(Registers.eflags, (uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost(arch);
}
/// <summary>
/// Tries to determine if the instruction at <paramref name="addr"/> is
/// a trampoline instruction. If so, we return a call to the imported
/// function directly.
/// procedure.
/// </summary>
/// <remarks>
/// A trampoline is a procedure whose only contents is an indirect
/// JUMP to a location that contains the address of an imported
/// function. Because these trampolines may take on different
/// appearances depending on the processor architecture, we have to
/// call out to the architecture to assist in matching them.
/// </remarks>
/// <param name="addr"></param>
/// <returns>Null if there was no trampoline.</returns>
public ProcedureBase?GetTrampoline(IProcessorArchitecture arch, Address addr)
{
if (!Program.SegmentMap.IsValidAddress(addr))
{
return(null);
}
var rdr = Program.CreateImageReader(arch, addr);
var rw = arch.CreateRewriter(rdr, arch.CreateProcessorState(), arch.CreateFrame(), this);
var target = Program.Platform.GetTrampolineDestination(addr, rw.SelectMany(c => c.Instructions), this);
return(target);
}
public void BwInc()
{
var state = arch.CreateProcessorState();
var di = new Identifier("di", Registers.di.DataType, Registers.di);
Backwalker bw = new Backwalker(host, new RtlGoto(new MemoryAccess(di, di.DataType), RtlClass.Transfer),
new ExpressionSimplifier(state, new FakeDecompilerEventListener()));
var instrs = new StatementList(new Block(null, "foo"));
instrs.Add(0, new Assignment(di, new BinaryExpression(Operator.IAdd, di.DataType, di, Constant.Word16(1))));
bw.BackwalkInstructions(Registers.di, instrs);
Assert.AreSame(Registers.di, bw.Index);
Assert.AreEqual("+ 1", bw.Operations[0].ToString());
}
private ImageSymbol LoadEntryPoint(Address addrLoad, EndianImageReader rdrAddrs, EndianImageReader rdrNames)
{
uint rvaAddr = rdrAddrs.ReadLeUInt32();
string name = null;
if (rdrNames != null)
{
int iNameMin = rdrNames.ReadLeInt32();
int j;
for (j = iNameMin; imgLoaded.Bytes[j] != 0; ++j)
{
;
}
name = Encoding.ASCII.GetString(imgLoaded.Bytes, iNameMin, j - iNameMin);
}
return(new ImageSymbol(addrLoad + rvaAddr)
{
Name = name,
ProcessorState = arch.CreateProcessorState(),
Type = SymbolType.Procedure,
});
}
private ImageSymbol CreateEntryPointSymbol(Address addrLoad, Address addrStart, Address addrStackTop)
{
var state = arch.CreateProcessorState();
state.InstructionPointer = addrStart;
state.SetRegister(Registers.cs, Constant.UInt16(addrLoad.Selector.Value));
state.SetRegister(Registers.ss, Constant.UInt16((ushort)addrStackTop.Selector.Value));
state.SetRegister(Registers.sp, Constant.UInt16((ushort)addrStackTop.Offset));
state.SetRegister(Registers.ds, Constant.UInt16(segPsp));
var ep = ImageSymbol.Procedure(arch, addrStart, state: state);
return(ep);
}
public override Program LoadProgram(Address?addrLoad)
{
Unpack(RawImage, addrLoad ?? PreferredBaseAddress);
var program = new Program(segmentMap, arch, platform);
var sym = ImageSymbol.Procedure(
program.Architecture,
Address.SegPtr((ushort)(lzCs + addrLoad !.Selector !), lzIp),
state: arch.CreateProcessorState());
program.ImageSymbols[sym.Address] = sym;
program.EntryPoints[sym.Address] = sym;
return(program);
}
public override RelocationResults Relocate(Program program, Address addrLoad)
{
EndianImageReader rdr = new LeImageReader(RawImage, hdrOffset + relocationsOffset);
ushort segCode = (ushort)(addrLoad.Selector.Value + (ExeImageLoader.CbPsp >> 4));
ushort dx = 0;
for (; ;)
{
int cx = rdr.ReadLeUInt16();
if (cx != 0)
{
uint relocBase = ExeImageLoader.CbPsp + dx * 0x10u;
do
{
ushort relocOff = rdr.ReadLeUInt16();
ushort seg = imgU.FixupLeUInt16(relocBase + relocOff, segCode);
var segment = segmentMap.AddSegment(new ImageSegment(
seg.ToString("X4"),
Address.SegPtr(seg, 0),
imgU,
AccessMode.ReadWriteExecute));
} while (--cx != 0);
}
if (dx == 0xF000)
{
break;
}
dx += (ushort)0x1000U;
}
this.cs += segCode;
segmentMap.AddOverlappingSegment(cs.ToString("X4"), imgU, Address.SegPtr(cs, 0), AccessMode.ReadWriteExecute);
this.ss += segCode;
var state = arch.CreateProcessorState();
state.SetRegister(Registers.ds, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.es, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.cs, Constant.Word16(cs));
state.SetRegister(Registers.ss, Constant.Word16(ss));
state.SetRegister(Registers.bx, Constant.Word16(0));
var ep = new ImageSymbol(Address.SegPtr(cs, ip))
{
ProcessorState = state
};
var entryPoints = new List <ImageSymbol> {
ep
};
var imageSymbols = entryPoints.ToSortedList(e => e.Address, e => e);
return(new RelocationResults(entryPoints, imageSymbols));
}
public ProcessorState Relocate(Program program, Address addrLoad)
{
var relocations = imgU.Relocations;
ushort segCode = (ushort)(addrLoad.Selector !.Value + (PspSize >> 4));
for (;;)
{
int relocs = (ushort)bitStm.GetByte();
if (relocs == 0)
{
break;
}
uint relocBase = PspSize + bitStm.GetWord() * 0x10u;
do
{
ushort relocOff = bitStm.GetWord();
ushort seg = imgU.ReadLeUInt16(relocBase + relocOff);
seg = (ushort)(seg + segCode);
imgU.WriteLeUInt16(relocBase + relocOff, seg);
relocations.AddSegmentReference(relocBase + relocOff, seg);
segmentMap.AddOverlappingSegment(seg.ToString("X4"), imgU, Address.SegPtr(seg, 0), AccessMode.ReadWriteExecute);
} while (--relocs != 0);
}
ushort pklSs = (ushort)(bitStm.GetWord() + segCode);
ushort pklSp = (ushort)bitStm.GetWord();
pklCs = (ushort)(bitStm.GetWord() + segCode);
pklIp = bitStm.GetWord();
var state = arch.CreateProcessorState();
state.SetRegister(Registers.ds, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.es, Constant.Word16(addrLoad.Selector.Value));
state.SetRegister(Registers.cs, Constant.Word16(pklCs));
state.SetRegister(Registers.ax, Constant.Word16(0));
state.SetRegister(Registers.bx, Constant.Word16(0));
state.SetRegister(Registers.cx, Constant.Word16(0));
state.SetRegister(Registers.dx, Constant.Word16(0));
state.SetRegister(Registers.bp, Constant.Word16(0));
state.SetRegister(Registers.sp, Constant.Word16(pklSp));
state.SetRegister(Registers.si, Constant.Word16(0));
state.SetRegister(Registers.di, Constant.Word16(0));
return(state);
}
public void Setup()
{
arch = new FakeArchitecture();
program = new Program {
Architecture = arch,
SegmentMap = new SegmentMap(
Address.Ptr32(0x00120000),
new ImageSegment(
".text",
new MemoryArea(Address.Ptr32(0x00120000), new byte[0x10000]),
AccessMode.ReadExecute))
};
binder = new StorageBinder();
graph = new DiGraph <RtlBlock>();
host = new RtlBackwalkHost(program, graph);
processorState = arch.CreateProcessorState();
}
private long PerformanceTest_A32Rewriter(IProcessorArchitecture arch, byte[] buf)
{
var mem = new MemoryArea(Address.Ptr32(0x00100000), buf);
var rdr = arch.CreateImageReader(mem, mem.BaseAddress);
var dasm = arch.CreateRewriter(rdr, arch.CreateProcessorState(), new StorageBinder(),
new RewriterPerformanceDialog.RewriterHost(new Dictionary <Address, ImportReference>()));
Stopwatch sw = new Stopwatch();
sw.Start();
foreach (var instr in dasm)
{
}
sw.Stop();
var time = sw.ElapsedMilliseconds;
return(time);
}
public void Setup()
{
arch = new FakeArchitecture();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
host = new BackwalkerHost(arch);
}
private ProcessorState CreateInitialState(IProcessorArchitecture arch, Dictionary<string, object> args)
{
var state = arch.CreateProcessorState();
if (!args.ContainsKey("--reg"))
return state;
var regs = (List<string>)args["--reg"];
foreach (var regValue in regs.Where(r => !string.IsNullOrEmpty(r)))
{
var rr = regValue.Split(':');
if (rr == null || rr.Length != 2)
continue;
var reg = arch.GetRegister(rr[0]);
state.SetRegister(reg, Constant.Create(reg.DataType, Convert.ToInt64(rr[1], 16)));
}
return state;
}
public void Setup()
{
arch = new X86ArchitectureFlat32();
m = new ProcedureBuilder();
state = arch.CreateProcessorState();
expSimp = new ExpressionSimplifier(arch.CreateProcessorState());
SCZO = m.Frame.EnsureFlagGroup(Registers.eflags, (uint)(FlagM.SF | FlagM.CF | FlagM.ZF | FlagM.OF), "SCZO", PrimitiveType.Byte);
host = new BackwalkerHost(arch);
}
