public void Setup()
{
mr = new MockRepository();
var services = mr.Stub<IServiceProvider>();
var tlSvc = mr.Stub<ITypeLibraryLoaderService>();
var configSvc = mr.StrictMock<IConfigurationService>();
var win32env = new OperatingEnvironmentElement
{
TypeLibraries =
{
new TypeLibraryElement { Name= "msvcrt.xml" },
new TypeLibraryElement { Name= "windows32.xml" },
}
};
configSvc.Stub(c => c.GetEnvironment("win32")).Return(win32env);
configSvc.Stub(c => c.GetPath(null)).IgnoreArguments()
.Do(new Func<string, string>(s => s));
services.Stub(s => s.GetService(typeof(ITypeLibraryLoaderService))).Return(tlSvc);
services.Stub(s => s.GetService(typeof(IConfigurationService))).Return(configSvc);
tlSvc.Stub(t => t.LoadLibrary(null, null)).IgnoreArguments()
.Do(new Func<IProcessorArchitecture, string, TypeLibrary>((a, n) =>
{
var lib = TypeLibrary.Load(a, Path.ChangeExtension(n, ".xml"));
return lib;
}));
services.Replay();
tlSvc.Replay();
configSvc.Replay();
arch = new IntelArchitecture(ProcessorMode.Protected32);
win32 = new Decompiler.Environments.Win32.Win32Platform(services, arch);
}
public void Setup()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
f = arch.CreateFrame();
liveness = new IdentifierLiveness(arch);
isLiveHelper = new RegisterLiveness.IsLiveHelper();
}
public X86State(X86State st) : base(st)
{
arch = st.arch;
FpuStackItems = st.FpuStackItems;
regs = (ulong[])st.regs.Clone();
valid = (bool []) st.valid.Clone();
}
public void MspRealModeServices()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Platform platform = new MsdosPlatform(null, arch);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.ah, Constant.Byte(0x3E));
SystemService svc = platform.FindService(0x21, state);
Assert.AreEqual("msdos_close_file", svc.Name);
Assert.AreEqual(1, svc.Signature.Parameters.Length);
Assert.IsFalse(svc.Characteristics.Terminates, "close() shouldn't terminate program");
state.SetRegister(Registers.ah, Constant.Byte(0x4C));
svc = platform.FindService(0x21, state);
Assert.AreEqual("msdos_terminate", svc.Name);
Assert.AreEqual(1, svc.Signature.Parameters.Length);
Assert.IsTrue(svc.Characteristics.Terminates, "terminate() should terminate program");
state.SetRegister(Registers.ah, Constant.Byte(0x2F));
svc = platform.FindService(0x21, state);
Assert.AreEqual("msdos_get_disk_transfer_area_address", svc.Name);
Assert.AreEqual(0, svc.Signature.Parameters.Length);
SequenceStorage seq = (SequenceStorage) svc.Signature.ReturnValue.Storage;
Assert.AreEqual("es", seq.Head.Name);
Assert.AreEqual("bx", seq.Tail.Name);
}
public void TestGrfWithOneBit()
{
IProcessorArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
SignatureBuilder sb = new SignatureBuilder(null, arch);
sb.AddFlagGroupReturnValue((uint) FlagM.CF, arch.CreateFrame());
ProcedureSignature sig = sb.BuildSignature();
Assert.AreEqual("bool", sig.ReturnValue.DataType.ToString());
}
public void Fstsw_Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
asm = new X86Assembler(arch, Address.Ptr32(0x10000), new List<EntryPoint>());
Procedure proc = new Procedure("test", arch.CreateFrame());
orw = new OperandRewriter32(arch, proc.Frame, null);
emitter = new ProcedureBuilder();
}
public void Setup()
{
repository = new MockRepository();
sc = new ServiceContainer();
arch = new IntelArchitecture(ProcessorMode.Protected32);
dcSvc = repository.StrictMock<IConfigurationService>();
opEnv = repository.StrictMock<OperatingEnvironment>();
}
public X86Emulator(IntelArchitecture arch, LoadedImage loadedImage, IPlatformEmulator envEmulator)
{
this.arch = arch;
this.img = loadedImage;
this.Registers = new ulong[40];
this.Valid = new bool[40];
this.envEmulator = envEmulator;
}
private X86Assembler Create16bitAssembler()
{
arch = arch16;
baseAddr = baseAddr16;
var asm = new X86Assembler(arch, baseAddr16, new List<EntryPoint>());
host = new RewriterHost(asm.ImportReferences);
return asm;
}
public X86RewriterTests()
{
arch16 = new IntelArchitecture(ProcessorMode.Real);
arch32 = new IntelArchitecture(ProcessorMode.Protected32);
arch64 = new IntelArchitecture(ProcessorMode.Protected64);
baseAddr16 = Address.SegPtr(0x0C00, 0x0000);
baseAddr32 = Address.Ptr32(0x10000000);
baseAddr64 = Address.Ptr64(0x140000000ul);
}
public void IaCreate()
{
arch = new IntelArchitecture(ProcessorMode.Real);
Assert.AreEqual(PrimitiveType.Word16, arch.WordWidth);
arch = new IntelArchitecture(ProcessorMode.Protected32);
Assert.AreEqual(PrimitiveType.Word32, arch.WordWidth);
arch = new IntelArchitecture(ProcessorMode.ProtectedSegmented);
Assert.AreEqual(PrimitiveType.Word16, arch.WordWidth);
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
m = new ProcedureBuilder(arch);
prog = new Program();
prog.Architecture = arch;
exit = new Procedure("exit", new Frame(PrimitiveType.Word32));
flow = new ProgramDataFlow();
p = new ProgramBuilder();
}
public void SetUp()
{
var arch = new IntelArchitecture(ProcessorMode.Real);
prog = new Program()
{
Architecture = arch
};
asm = new X86TextAssembler(arch);
configFile = null;
}
public void OnBeforeCall_DecrementStackRegister()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
var state = new X86State(arch);
var esp = CreateId(Registers.esp);
state.SetRegister(Registers.esp, Constant.Word32(-4));
state.OnProcedureEntered();
var site = state.OnBeforeCall(esp, 4);
Assert.AreEqual(4, site.SizeOfReturnAddressOnStack);
Assert.AreEqual("0xFFFFFFFC", state.GetValue(esp).ToString());
}
public void ReadCodeAddress_ProtectedMode16_Offset()
{
arch = new X86ArchitectureProtected16();
var rdr = CreateImageReader(0x78, 0x56);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.cs, Constant.Word16(0x1234));
Address addr = arch.ReadCodeAddress(2, rdr, state);
Assert.AreEqual("1234:5678", addr.ToString());
}
public void Setup()
{
arch = new X86ArchitectureFlat32("x86-protected-32");
m = new ProcedureBuilder(arch);
program = new Program();
program.Architecture = arch;
program.SegmentMap = new SegmentMap(Address.Ptr32(0));
exit = new Procedure(arch, "exit", new Frame(PrimitiveType.Word32));
flow = new ProgramDataFlow();
p = new ProgramBuilder();
p.Program.Architecture = this.arch;
}
public void X86arch_ReadCodeAddress_ProtectedFlatMode32()
{
arch = new X86ArchitectureFlat32("x86-protected-32");
var rdr = CreateImageReader(0x78, 0x56, 0x34, 0x12);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.cs, Constant.Word16(0x1111));
var addr = arch.ReadCodeAddress(4, rdr, state);
Assert.AreEqual("12345678", addr.ToString());
}
public ApplicationBuilderTests()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
frame = arch.CreateFrame();
ret = frame.EnsureRegister(Registers.eax);
arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32));
arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16));
arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte));
regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx)));
sig = new ProcedureSignature(ret,
new Identifier[] { arg04, arg08, arg0C, regOut });
}
public void ReadCodeAddress_RealMode_SegOffset()
{
arch = new X86ArchitectureReal("x86-real-16");
var rdr = CreateImageReader(0x78, 0x56, 0x34, 0x12);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.cs, Constant.Word16(0x1111));
var addr = arch.ReadCodeAddress(4, rdr, state);
Assert.AreEqual("1234:5678", addr.ToString());
}
public void X86arch_ReadCodeAddress_ProtectedMode16_SegOffset()
{
arch = new X86ArchitectureProtected16(new ServiceContainer(), "x86-protected-16");
var rdr = CreateImageReader(0x78, 0x56, 0x34, 0x12);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.cs, Constant.Word16(0x1111));
var addr = arch.ReadCodeAddress(4, rdr, state);
Assert.AreEqual("1234:5678", addr.ToString());
}
public void FrGrfTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
uint iSz = (uint) (FlagM.ZF|FlagM.SF);
Identifier grfSz = f.EnsureFlagGroup(iSz, arch.GrfToString(iSz), PrimitiveType.Byte);
using (FileUnitTester fut = new FileUnitTester("Core/FrGrfTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void ReadCodeAddress_ProtectedMode16_Offset()
{
arch = new X86ArchitectureProtected16(new ServiceContainer(), "x86-protected-16", new Dictionary <string, object>());
var rdr = CreateImageReader(0x78, 0x56);
var state = arch.CreateProcessorState();
state.SetRegister(Registers.cs, Constant.Word16(0x1234));
var addr = arch.ReadCodeAddress(2, rdr, state);
Assert.AreEqual("1234:5678", addr.ToString());
}
public void FrGrfTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
uint iSz = (uint)(FlagM.ZF | FlagM.SF);
Identifier grfSz = f.EnsureFlagGroup(iSz, arch.GrfToString(iSz), PrimitiveType.Byte);
using (FileUnitTester fut = new FileUnitTester("Core/FrGrfTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void OnBeforeCall_DecrementStackRegister()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
var state = new X86State(arch);
var esp = CreateId(Registers.esp);
state.SetRegister(Registers.esp, Constant.Word32(-4));
state.OnProcedureEntered();
var site = state.OnBeforeCall(esp, 4);
Assert.AreEqual(4, site.SizeOfReturnAddressOnStack);
Assert.AreEqual("0xFFFFFFFC", state.GetValue(esp).ToString());
}
public ApplicationBuilderTests()
{
arch = new X86ArchitectureFlat32();
frame = arch.CreateFrame();
ret = frame.EnsureRegister(Registers.eax);
arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32));
arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16));
arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte));
regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx)));
sig = new FunctionType(
ret,
new Identifier[] { arg04, arg08, arg0C, regOut });
}
public ApplicationBuilderTests()
{
arch = new X86ArchitectureFlat32(new ServiceContainer(), "x86-protected-32", new Dictionary <string, object>());
frame = arch.CreateFrame();
ret = frame.EnsureRegister(Registers.eax);
arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32));
arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16));
arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte));
regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx)));
sig = FunctionType.Func(
ret,
new Identifier[] { arg04, arg08, arg0C, regOut });
}
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());
}
public void Setup()
{
var sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
arch = new X86ArchitectureReal();
platform = new MsdosPlatform(sc, arch);
sigser = new X86ProcedureSerializer(
arch,
new TypeLibraryDeserializer(platform, true, new TypeLibrary()),
"stdapi");
argser = new ArgumentDeserializer(sigser, arch, arch.CreateFrame(), 4);
}
public void Simple()
{
var arch = new IntelArchitecture(ProcessorMode.Real);
X86State st = new X86State(arch);
st.SetRegister(Registers.cs, Constant.Word16(0xC00));
st.SetRegister(Registers.ax, Constant.Word16(0x1234));
Assert.IsTrue(!st.GetRegister(Registers.bx).IsValid);
Assert.IsTrue(st.GetRegister(Registers.ax).IsValid);
Assert.IsTrue(st.GetRegister(Registers.al).IsValid);
Assert.AreEqual(0x34, st.GetRegister(Registers.al).ToUInt32());
Assert.IsTrue(st.GetRegister(Registers.ah).IsValid);
Assert.AreEqual(0x12, st.GetRegister(Registers.ah).ToUInt32());
}
private void BuildTest(IntelArchitecture arch, Address addr, IPlatform platform, Action <X86Assembler> m)
{
this.arch = new X86ArchitectureFlat32();
proc = new Procedure("test", arch.CreateFrame());
block = proc.AddBlock("testblock");
this.state = arch.CreateProcessorState();
var asm = new X86Assembler(sc, new DefaultPlatform(sc, arch), addr, new List <ImageSymbol>());
scanner = mr.StrictMock <IScanner>();
m(asm);
lr = asm.GetImage();
host = new RewriterHost(asm.ImportReferences,
new Dictionary <string, ProcedureSignature>
{
{
"GetDC",
new ProcedureSignature(
new Identifier("", new Pointer(VoidType.Instance, 4), new RegisterStorage("eax", 0, 0, PrimitiveType.Word32)),
new Identifier("arg",
new TypeReference(
"HWND",
new Pointer(VoidType.Instance, 4)),
new StackArgumentStorage(0, new TypeReference(
"HWND",
new Pointer(VoidType.Instance, 4)))))
{
StackDelta = 4,
}
}
});
var rw = arch.CreateRewriter(
lr.SegmentMap.Segments.Values.First().MemoryArea.CreateLeReader(addr),
this.state,
proc.Frame,
host);
var prog = new Program
{
Architecture = arch,
SegmentMap = lr.SegmentMap,
ImageMap = lr.ImageMap,
Platform = platform,
};
using (mr.Record())
{
scanner.Stub(x => x.FindContainingBlock(Arg <Address> .Is.Anything)).Return(block);
scanner.Stub(x => x.GetTrace(null, null, null)).IgnoreArguments().Return(rw);
}
wi = new BlockWorkitem(scanner, prog, state, addr);
}
protected static Program RewriteMsdosAssembler(string relativePath, string configFile)
{
var arch = new IntelArchitecture(ProcessorMode.Real);
Program program;
Assembler asm = new X86TextAssembler(arch);
using (var rdr = new StreamReader(FileUnitTester.MapTestPath(relativePath)))
{
program = asm.Assemble(Address.SegPtr(0xC00, 0), rdr);
program.Platform = new MsdosPlatform(null, arch);
}
Rewrite(program, asm, configFile);
return(program);
}
public ApplicationBuilderTests()
{
arch = new IntelArchitecture(ProcessorMode.Protected32);
frame = arch.CreateFrame();
ret = frame.EnsureRegister(Registers.eax);
arg04 = new Identifier("arg04", PrimitiveType.Word32, new StackArgumentStorage(4, PrimitiveType.Word32));
arg08 = new Identifier("arg08", PrimitiveType.Word16, new StackArgumentStorage(8, PrimitiveType.Word16));
arg0C = new Identifier("arg0C", PrimitiveType.Byte, new StackArgumentStorage(0x0C, PrimitiveType.Byte));
regOut = new Identifier("edxOut", PrimitiveType.Word32, new OutArgumentStorage(frame.EnsureRegister(Registers.edx)));
sig = new ProcedureSignature(ret,
new Identifier[] { arg04, arg08, arg0C, regOut })
{
};
}
public void Simple()
{
var arch = new IntelArchitecture(ProcessorMode.Real);
X86State st = new X86State(arch);
st.SetRegister(Registers.cs, Constant.Word16(0xC00));
st.SetRegister(Registers.ax, Constant.Word16(0x1234));
Assert.IsTrue(!st.GetRegister(Registers.bx).IsValid);
Assert.IsTrue(st.GetRegister(Registers.ax).IsValid);
Assert.IsTrue(st.GetRegister(Registers.al).IsValid);
Assert.AreEqual(0x34, st.GetRegister(Registers.al).ToUInt32());
Assert.IsTrue(st.GetRegister(Registers.ah).IsValid);
Assert.AreEqual(0x12, st.GetRegister(Registers.ah).ToUInt32());
}
public void SequenceTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
Identifier ax = f.EnsureRegister(Registers.ax);
Identifier dx = f.EnsureRegister(Registers.dx);
Identifier dxax = f.EnsureSequence(dx, ax, PrimitiveType.Word32);
using (FileUnitTester fut = new FileUnitTester("Core/SequenceTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
Identifier dxax2 = f.EnsureSequence(dx,ax, PrimitiveType.Word32);
Assert.IsTrue(dxax2 == dxax);
}
public void PsigArguments()
{
using (FileUnitTester fut = new FileUnitTester("Core/PsigArguments.txt"))
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
uint f = (uint)(FlagM.CF | FlagM.ZF);
Identifier argF = new Identifier(arch.GrfToString(f), PrimitiveType.Bool, new FlagGroupStorage(f, "CZ", PrimitiveType.Byte));
Identifier argR = new Identifier(Registers.ax.Name, Registers.ax.DataType, Registers.ax);
argF.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
argR.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
fut.AssertFilesEqual();
}
}
public void PsigArguments()
{
using (FileUnitTester fut = new FileUnitTester("Core/PsigArguments.txt"))
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
uint f = (uint)(FlagM.CF|FlagM.ZF);
Identifier argF = new Identifier(arch.GrfToString(f), PrimitiveType.Bool, new FlagGroupStorage(f, "CZ", PrimitiveType.Byte));
Identifier argR = new Identifier(Registers.ax.Name, Registers.ax.DataType, Registers.ax);
argF.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
argR.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
fut.AssertFilesEqual();
}
}
public void SequenceTest()
{
IntelArchitecture arch = new IntelArchitecture(ProcessorMode.Real);
Frame f = new Frame(PrimitiveType.Word16);
Identifier ax = f.EnsureRegister(Registers.ax);
Identifier dx = f.EnsureRegister(Registers.dx);
Identifier dxax = f.EnsureSequence(dx, ax, PrimitiveType.Word32);
using (FileUnitTester fut = new FileUnitTester("Core/SequenceTest.txt"))
{
f.Write(fut.TextWriter);
fut.AssertFilesEqual();
}
Identifier dxax2 = f.EnsureSequence(dx, ax, PrimitiveType.Word32);
Assert.IsTrue(dxax2 == dxax);
}
private void RunTest(IntelArchitecture arch, RtlTransfer rtlTransfer, string outputFile)
{
using (var fut = new FileUnitTester(outputFile))
{
m.Procedure.Write(false, fut.TextWriter);
fut.TextWriter.Flush();
var ibw = new Backwalker <Block, Instruction>(host, rtlTransfer, expSimp);
var bwoList = ibw.BackWalk(m.CurrentBlock);
Assert.IsNotNull(bwoList);
foreach (BackwalkOperation bwo in bwoList)
{
fut.TextWriter.WriteLine(bwo);
}
fut.TextWriter.WriteLine("Index register: {0}", ibw.Index);
fut.AssertFilesEqual();
}
}
public PkLiteUnpacker(IServiceProvider services, string filename, byte [] rawImg) : base(services, filename, rawImg)
{
var exe = new ExeImageLoader(services, filename, rawImg);
arch = new IntelArchitecture(ProcessorMode.Real);
platform = new MsdosPlatform(services, arch);
uint pkLiteHdrOffset = (uint) (exe.e_cparHeader * 0x10);
if (RawImage[pkLiteHdrOffset] != 0xB8)
throw new ApplicationException(string.Format("Expected MOV AX,XXXX at offset 0x{0:X4}.", pkLiteHdrOffset));
uint cparUncompressed = LoadedImage.ReadLeUInt16(RawImage, pkLiteHdrOffset + 1);
abU = new byte[cparUncompressed * 0x10U];
if (RawImage[pkLiteHdrOffset + 0x04C] != 0x83)
throw new ApplicationException(string.Format("Expected ADD BX,+XX at offset 0x{0:X4}.", pkLiteHdrOffset + 0x04C));
uint offCompressedData = pkLiteHdrOffset + RawImage[pkLiteHdrOffset + 0x04E] * 0x10u - PspSize;
bitStm = new BitStream(RawImage, (int) offCompressedData);
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Real);
var image = new LoadedImage(Address.Ptr32(0x10000), new byte[4]);
var prog = new Program(
image,
image.CreateImageMap(),
arch,
null);
var procAddress = Address.Ptr32(0x10000000);
instr = new IntelInstruction(Opcode.nop, PrimitiveType.Word16, PrimitiveType.Word16)
{
Address = procAddress,
};
proc = Procedure.Create(procAddress, arch.CreateFrame());
orw = new OperandRewriter16(arch, proc.Frame, new FakeRewriterHost(prog));
state = (X86State)arch.CreateProcessorState();
}
public void StackUnderflow_ReportError()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
string reportedError = null;
var state = new X86State(arch)
{
ErrorListener = (err) => { reportedError = err; }
};
state.OnProcedureEntered();
state.SetRegister(Registers.esp, Constant.Word32(-4)); // Push only 4 bytes
var esp = CreateId(Registers.esp);
var site = state.OnBeforeCall(esp, 4);
state.OnAfterCall(esp, new ProcedureSignature
{
StackDelta = 16, // ...but pop 16 bytes
},
new Decompiler.Evaluation.ExpressionSimplifier(state)); //$TODO: hm. Move simplification out of state.
Assert.IsNotNull(reportedError);
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Real);
var image = new LoadedImage(Address.Ptr32(0x10000), new byte[4]);
var prog = new Program(
image,
image.CreateImageMap(),
arch,
null);
var procAddress = Address.Ptr32(0x10000000);
instr = new X86Instruction(Opcode.nop, PrimitiveType.Word16, PrimitiveType.Word16)
{
Address = procAddress,
};
proc = Procedure.Create(procAddress, arch.CreateFrame());
orw = new OperandRewriter16(arch, proc.Frame, new FakeRewriterHost(prog));
state = (X86State)arch.CreateProcessorState();
}
public void AsFragment()
{
var program = asm.AssembleFragment(
Address.SegPtr(0xC00, 0),
@" .i86
hello proc
mov ax,0x30
mov bx,0x40
hello endp
");
LoadedImage img = program.Image;
using (FileUnitTester fut = new FileUnitTester("Intel/AsFragment.txt"))
{
var arch = new IntelArchitecture(ProcessorMode.Real);
var d = new Dumper(arch);
d.DumpData(img, img.BaseAddress, img.Bytes.Length, fut.TextWriter);
fut.AssertFilesEqual();
}
}
public void Setup()
{
var sc = new ServiceContainer();
sc.AddService <IFileSystemService>(new FileSystemServiceImpl());
arch = new X86ArchitectureReal("x86-real-16");
platform = new MsdosPlatform(sc, arch);
sigser = new ProcedureSerializer(
platform,
new TypeLibraryDeserializer(platform, true, new TypeLibrary()),
"stdapi");
argser = new ArgumentDeserializer(
sigser,
arch,
arch.CreateFrame(),
// It's possible that old, hand-written assembler passes
// arguments on unaligned offsets
13,
4);
}
public void SlLookupType()
{
var slib = new SerializedLibrary
{
Types = new SerializedType[]
{
new SerializedTypedef {
Name = "int",
DataType = new PrimitiveType_v1 {
Domain = Reko.Core.Types.Domain.SignedInt, ByteSize = 4
}
}
}
};
var arch = new IntelArchitecture(ProcessorMode.Protected32);
var platform = new SysVPlatform(null, arch);
var lib = TypeLibrary.Load(platform, slib);
Assert.AreEqual(PrimitiveType.Int32, lib.LookupType("int"));
}
public void EP_TestCondition()
{
var p = new ProgramBuilder();
p.Add("main", (m) =>
{
m.Label("foo");
m.BranchCc(ConditionCode.EQ, "foo");
m.Return();
});
var proc = p.BuildProgram().Procedures.Values.First();
var arch = new IntelArchitecture(ProcessorMode.Protected32);
var ctx = new SymbolicEvaluationContext(arch, proc.Frame);
var simplifier = new ExpressionSimplifier(ctx);
var ep = new ExpressionPropagator(null, simplifier, ctx, new ProgramDataFlow());
var newInstr = proc.EntryBlock.Succ[0].Statements[0].Instruction.Accept(ep);
Assert.AreEqual("branch Test(EQ,Z) foo", newInstr.ToString());
}
public void StackUnderflow_ReportError()
{
var arch = new IntelArchitecture(ProcessorMode.Protected32);
string reportedError = null;
var state = new X86State(arch)
{
ErrorListener = (err) => { reportedError = err; }
};
state.OnProcedureEntered();
state.SetRegister(Registers.esp, Constant.Word32(-4)); // Push only 4 bytes
var esp = CreateId(Registers.esp);
var site = state.OnBeforeCall(esp, 4);
state.OnAfterCall(esp, new ProcedureSignature
{
StackDelta = 16, // ...but pop 16 bytes
},
new Reko.Evaluation.ExpressionSimplifier(state)); //$TODO: hm. Move simplification out of state.
Assert.IsNotNull(reportedError);
}
public void Setup()
{
arch = new X86ArchitectureReal("x86-real-16");
var mem = new MemoryArea(Address.Ptr32(0x10000), new byte[4]);
var program = new Program(
new SegmentMap(
mem.BaseAddress,
new ImageSegment(
"code", mem, AccessMode.ReadWriteExecute)),
arch,
new DefaultPlatform(null, arch));
var procAddress = Address.Ptr32(0x10000000);
instr = new X86Instruction(Mnemonic.nop, InstrClass.Linear, PrimitiveType.Word16, PrimitiveType.Word16)
{
Address = procAddress,
};
proc = Procedure.Create(arch, procAddress, arch.CreateFrame());
orw = new OperandRewriter16(arch, new ExpressionEmitter(), proc.Frame, new FakeRewriterHost(program));
state = (X86State)arch.CreateProcessorState();
}
private Dictionary<Symbol, AssembledSegment> symbolSegments; // The segment to which a symbol belongs.
public X86Assembler(IntelArchitecture arch, Address addrBase, List<EntryPoint> entryPoints)
{
this.arch = arch;
this.Platform = new MsdosPlatform(null, arch);
this.addrBase = addrBase;
this.entryPoints = entryPoints;
this.defaultWordSize = arch.WordWidth;
this.textEncoding = Encoding.GetEncoding("ISO_8859-1");
symtab = new SymbolTable();
importReferences = new Dictionary<Address, ImportReference>();
segments = new List<AssembledSegment>();
mpNameToSegment = new Dictionary<string, AssembledSegment>();
symbolSegments = new Dictionary<Symbol, AssembledSegment>();
this.SegmentOverride = RegisterStorage.None;
unknownSegment = new AssembledSegment(new Emitter(), symtab.DefineSymbol("", 0));
segments.Add(unknownSegment);
SwitchSegment(unknownSegment);
SetDefaultWordWidth(defaultWordSize);
}
public void PreservedValues()
{
arch = new IntelArchitecture(ProcessorMode.Real);
p.Add("main", m =>
{
var sp = m.Frame.EnsureRegister(Registers.sp);
var ss = m.Frame.EnsureRegister(Registers.ss);
var ax = m.Frame.EnsureRegister(Registers.ax);
m.Assign(sp, m.ISub(sp, 2));
m.SegStore(ss, sp, ax);
m.Assign(ax, 1);
m.Assign(ax, m.SegMemW(ss, sp));
m.Assign(sp, m.IAdd(sp, 2));
m.Return();
});
RunTest(p,
@"main
main_entry sp:fp
l1 sp:fp
main_exit ax:ax sp:fp");
}
public void TrfPreservedValues()
{
arch = new X86ArchitectureReal("x86-real-16");
p.Program.Architecture = arch;
p.Add("main", m =>
{
var sp = m.Frame.EnsureRegister(Registers.sp);
var ss = m.Frame.EnsureRegister(Registers.ss);
var ax = m.Frame.EnsureRegister(Registers.ax);
m.Assign(sp, m.ISub(sp, 2));
m.SStore(ss, sp, ax);
m.Assign(ax, 1);
m.Assign(ax, m.SegMem16(ss, sp));
m.Assign(sp, m.IAdd(sp, 2));
m.Return();
});
RunTest(p,
@"main
main_entry sp:fp
l1 sp:fp
main_exit ax:ax sp:fp");
}
public void Setup()
{
mr = new MockRepository();
var services = mr.Stub <IServiceProvider>();
var tlSvc = mr.Stub <ITypeLibraryLoaderService>();
var configSvc = mr.StrictMock <IConfigurationService>();
var win32env = new OperatingEnvironmentElement
{
TypeLibraries =
{
new TypeLibraryElement {
Name = "msvcrt.xml"
},
new TypeLibraryElement {
Name = "windows32.xml"
},
}
};
configSvc.Stub(c => c.GetEnvironment("win32")).Return(win32env);
configSvc.Stub(c => c.GetPath(null)).IgnoreArguments()
.Do(new Func <string, string>(s => s));
services.Stub(s => s.GetService(typeof(ITypeLibraryLoaderService))).Return(tlSvc);
services.Stub(s => s.GetService(typeof(IConfigurationService))).Return(configSvc);
tlSvc.Stub(t => t.LoadLibrary(null, null)).IgnoreArguments()
.Do(new Func <Platform, string, TypeLibrary>((p, n) =>
{
var lib = TypeLibrary.Load(p, Path.ChangeExtension(n, ".xml"));
return(lib);
}));
services.Replay();
tlSvc.Replay();
configSvc.Replay();
arch = new IntelArchitecture(ProcessorMode.Protected32);
win32 = new Reko.Environments.Win32.Win32Platform(services, arch);
}
public void Dec_LoadCallSignatures()
{
var arch = new IntelArchitecture(ProcessorMode.Real);
Program program = new Program { Architecture = arch };
decompiler.Project = new Project
{
Programs = { program }
};
List<SerializedCall_v1> al = new List<SerializedCall_v1>();
SerializedSignature sig = new SerializedSignature();
sig.Arguments = new Argument_v1[] {
new Argument_v1 {
Kind = new Register_v1("ds")
},
new Argument_v1 {
Kind = new Register_v1("bx"),
}
};
al.Add(new SerializedCall_v1(Address.SegPtr(0x0C32, 0x3200), sig));
var sigs = decompiler.LoadCallSignatures(program, al);
ProcedureSignature ps = sigs[Address.SegPtr(0x0C32, 0x3200)];
Assert.IsNotNull(ps, "Expected a call signature for address");
}
public OperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host)
{
this.arch = arch;
this.frame = frame;
this.host = host;
}
public abstract OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host);
public StringInstructionRewriter(IntelArchitecture arch, OperandRewriter orw)
{
this.arch = arch;
this.orw = orw;
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Real);
}
public OperandRewriter64(IntelArchitecture arch, Frame frame, IRewriterHost host) : base(arch, frame, host) { }
public override OperandRewriter CreateOperandRewriter(IntelArchitecture arch, Frame frame, IRewriterHost host)
{
return new OperandRewriter64(arch, frame, host);
}
public X86ProcedureSerializer(IntelArchitecture arch, ISerializedTypeVisitor<DataType> typeLoader, string defaultCc)
: base(arch, typeLoader, defaultCc)
{
}
