public void Setup()
{
this.sc = new ServiceContainer();
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
arch = new IntelArchitecture(ProcessorMode.Real);
asm = new X86TextAssembler(sc, arch);
}
protected Program RewriteX86RealFragment(string asmFragment, Address addrBase)
{
var asm = new X86TextAssembler(sc, new X86ArchitectureReal());
program = asm.AssembleFragment(addrBase, asmFragment);
program.Platform = new DefaultPlatform(null, program.Architecture);
program.EntryPoints.Add(new EntryPoint(addrBase, program.Architecture.CreateProcessorState()));
return RewriteProgram();
}
protected Program RewriteX86RealFragment(string asmFragment, Address addrBase)
{
sc = new ServiceContainer();
sc.AddService<DecompilerEventListener>(new FakeDecompilerEventListener());
var asm = new X86TextAssembler(sc, new X86ArchitectureReal());
program = asm.AssembleFragment(addrBase, asmFragment);
program.Platform = new DefaultPlatform(null, program.Architecture);
program.EntryPoints.Add(
addrBase,
new ImageSymbol(addrBase));
return RewriteProgram();
}
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 void DisEdiTimes2()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureFlat32());
var program = asm.AssembleFragment(Address.SegPtr(0x0B00, 0),
@" .i386
mov ebx,[edi*2]
");
CreateDisassembler32(program.Image);
var instr = dasm.First();
MemoryOperand mem = (MemoryOperand)instr.op2;
Assert.AreEqual(2, mem.Scale);
Assert.AreEqual(RegisterStorage.None, mem.Base);
Assert.AreEqual(Registers.edi, mem.Index);
}
public void DisFpuInstructions()
{
using (FileUnitTester fut = new FileUnitTester("Intel/DisFpuInstructions.txt"))
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
Program lr;
using (var rdr = new StreamReader(FileUnitTester.MapTestPath("Fragments/fpuops.asm")))
{
lr = asm.Assemble(Address.SegPtr(0xC32, 0), rdr);
}
CreateDisassembler16(lr.Image);
foreach (X86Instruction instr in dasm)
{
fut.TextWriter.WriteLine("{0}", instr.ToString());
}
fut.AssertFilesEqual();
}
}
protected static Program RewriteMsdosAssembler(string relativePath, string configFile)
{
var arch = new IntelArchitecture(ProcessorMode.Real);
var sc = new ServiceContainer();
var cfgSvc = MockRepository.GenerateStub<IConfigurationService>();
var env = MockRepository.GenerateStub<OperatingEnvironment>();
var tlSvc = MockRepository.GenerateStub<ITypeLibraryLoaderService>();
cfgSvc.Stub(c => c.GetEnvironment("ms-dos")).Return(env);
cfgSvc.Replay();
env.Stub(e => e.TypeLibraries).Return(new TypeLibraryElementCollection());
env.CharacteristicsLibraries = new TypeLibraryElementCollection();
env.Replay();
tlSvc.Replay();
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
sc.AddService<IConfigurationService>(cfgSvc);
sc.AddService<ITypeLibraryLoaderService>(tlSvc);
Program program;
Assembler asm = new X86TextAssembler(sc, arch);
using (var rdr = new StreamReader(FileUnitTester.MapTestPath(relativePath)))
{
program = asm.Assemble(Address.SegPtr(0xC00, 0), rdr);
program.Platform = new MsdosPlatform(sc, arch);
}
Rewrite(program, asm, configFile);
return program;
}
public void Setup()
{
arch = new IntelArchitecture(ProcessorMode.Real);
asm = new X86TextAssembler(arch);
}
public void Rotations()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
var lr = asm.AssembleFragment(
Address.SegPtr(0xB96, 0),
"foo proc\r\n" +
"rol ax,cl\r\n" +
"ror word ptr [bx+2],cl\r\n" +
"rcr word ptr [bp+4],4\r\n" +
"rcl ax,1\r\n");
LoadedImage img = lr.Image;
CreateDisassembler16(img.CreateLeReader(img.BaseAddress));
StringBuilder sb = new StringBuilder();
foreach (var instr in dasm.Take(4))
{
sb.AppendFormat("{0}\r\n", instr.ToString());
}
string s = sb.ToString();
Assert.AreEqual(
"rol\tax,cl\r\n" +
"ror\tword ptr [bx+02],cl\r\n" +
"rcr\tword ptr [bp+04],04\r\n" +
"rcl\tax,01\r\n", s);
}
public void Extensions()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
var program = asm.AssembleFragment(
Address.SegPtr(0xA14, 0),
@" .i86
foo proc
movsx ecx,word ptr [bp+8]
movzx edx,cl
movsx ebx,bx
movzx ax,byte ptr [bp+04]
");
CreateDisassembler16(program.Image);
StringBuilder sb = new StringBuilder();
foreach (var ii in dasm.Take(4))
{
sb.AppendLine(string.Format("{0}", ii.ToString()));
}
string s = sb.ToString();
Assert.AreEqual(
@"movsx ecx,word ptr [bp+08]
movzx edx,cl
movsx ebx,bx
movzx ax,byte ptr [bp+04]
", s);
}
protected Program RewriteCodeFragment32(string s)
{
Assembler asm = new X86TextAssembler(new X86ArchitectureFlat32());
var program = asm.AssembleFragment(Address.Ptr32(0x00400000), s);
program.Platform = new DefaultPlatform(null, program.Architecture);
Rewrite(program, asm, null);
return program;
}
private Program RewriteFile32(string relativePath, string configFile)
{
Program program;
var asm = new X86TextAssembler(new X86ArchitectureReal());
using (var rdr = new StreamReader(FileUnitTester.MapTestPath(relativePath)))
{
if (this.platform == null)
{
this.platform = new Reko.Environments.Windows.Win32Platform(null, new X86ArchitectureFlat32());
}
asm.Platform = this.platform;
program = asm.Assemble(Address.Ptr32(0x10000000), rdr);
}
foreach (var item in asm.ImportReferences)
{
program.ImportReferences.Add(item.Key, item.Value);
}
Rewrite(program, asm, configFile);
return program;
}
protected Program RewriteCodeFragment(string s)
{
Assembler asm = new X86TextAssembler(new X86ArchitectureReal());
var program = asm.AssembleFragment(Address.SegPtr(0xC00, 0), s);
program.Platform = new DefaultPlatform(null, program.Architecture);
Rewrite(program, asm, null);
return program;
}
public void Dis_x86_StringOps()
{
X86TextAssembler asm = new X86TextAssembler(sc, new X86ArchitectureFlat32());
var lr = asm.AssembleFragment(
Address.Ptr32(0x01001000),
"movsb\r\n" +
"movsw\r\n" +
"movsd\r\n" +
"scasb\r\n" +
"scasw\r\n" +
"scasd\r\n" +
"cmpsb\r\n" +
"cmpsw\r\n" +
"cmpsd\r\n" +
"lodsb\r\n" +
"lodsw\r\n" +
"lodsd\r\n" +
"stosb\r\n" +
"stosw\r\n" +
"stosd\r\n");
MemoryArea img = lr.SegmentMap.Segments.Values.First().MemoryArea;
CreateDisassembler32(img);
var instructions = dasm.GetEnumerator();
List<X86Instruction> instr = new List<X86Instruction>();
for (int i = 0; i < 5 * 3; i++)
{
instr.Add(DisEnumerator_TakeNext(instructions));
}
Assert.AreEqual(Opcode.movsb, instr[0].code);
Assert.AreEqual(Opcode.movs, instr[1].code);
Assert.AreEqual("word16", instr[1].dataWidth.Name);
Assert.AreEqual(Opcode.movs, instr[2].code);
Assert.AreEqual("word32", instr[2].dataWidth.Name);
Assert.AreEqual(Opcode.scasb, instr[3].code);
Assert.AreEqual(Opcode.scas, instr[4].code);
Assert.AreEqual("word16", instr[4].dataWidth.Name);
Assert.AreEqual(Opcode.scas, instr[5].code);
Assert.AreEqual("word32", instr[5].dataWidth.Name);
Assert.AreEqual(Opcode.cmpsb, instr[6].code);
Assert.AreEqual(Opcode.cmps, instr[7].code);
Assert.AreEqual("word16", instr[7].dataWidth.Name);
Assert.AreEqual(Opcode.cmps, instr[8].code);
Assert.AreEqual("word32", instr[8].dataWidth.Name);
Assert.AreEqual(Opcode.lodsb, instr[9].code);
Assert.AreEqual(Opcode.lods, instr[10].code);
Assert.AreEqual("word16", instr[10].dataWidth.Name);
Assert.AreEqual(Opcode.lods, instr[11].code);
Assert.AreEqual("word32", instr[11].dataWidth.Name);
Assert.AreEqual(Opcode.stosb, instr[12].code);
Assert.AreEqual(Opcode.stos, instr[13].code);
Assert.AreEqual("word16", instr[13].dataWidth.Name);
Assert.AreEqual(Opcode.stos, instr[14].code);
Assert.AreEqual("word32", instr[14].dataWidth.Name);
}
private void RunTest(string sourceFile, string outputFile)
{
Program program;
var asm = new X86TextAssembler(new X86ArchitectureFlat32());
using (StreamReader rdr = new StreamReader(FileUnitTester.MapTestPath(sourceFile)))
{
program = asm.Assemble(Address.Ptr32(0x10000000), rdr);
program.Platform = win32;
}
foreach (var item in asm.ImportReferences)
{
program.ImportReferences.Add(item.Key, item.Value);
}
var project = new Project { Programs = { program } };
Scanner scan = new Scanner(
program,
new Dictionary<Address, ProcedureSignature>(),
new ImportResolver(project),
services);
foreach (var ep in asm.EntryPoints)
{
scan.EnqueueEntryPoint(ep);
}
scan.ScanImage();
using (FileUnitTester fut = new FileUnitTester(outputFile))
{
foreach (Procedure proc in program.Procedures.Values)
{
proc.Write(true, fut.TextWriter);
fut.TextWriter.WriteLine();
}
fut.AssertFilesEqual();
}
}
public void X86Dis_Sequence()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
var program = asm.AssembleFragment(
Address.SegPtr(0xB96, 0),
@" mov ax,0
cwd
foo:
lodsb
dec cx
jnz foo
");
CreateDisassembler16(program.Image);
StringBuilder sb = new StringBuilder();
foreach (var instr in dasm.Take(5))
{
Address addr = instr.Address;
sb.AppendFormat("{0}\t{1}\r\n", addr, instr.ToString());
}
string s = sb.ToString();
Assert.AreEqual(
"0B96:0000\tmov\tax,0000\r\n" +
"0B96:0003\tcwd\t\r\n" +
"0B96:0004\tlodsb\t\r\n" +
"0B96:0005\tdec\tcx\r\n" +
"0B96:0006\tjnz\t0004\r\n",
s);
}
public void SegmentOverrides()
{
X86TextAssembler asm = new X86TextAssembler(new X86ArchitectureReal());
var program = asm.AssembleFragment(
Address.SegPtr(0xB96, 0),
"foo proc\r\n" +
" mov bx,[bp+4]\r\n" +
" mov ax,[bx+4]\r\n" +
" mov cx,cs:[si+4]\r\n");
CreateDisassembler16(program.Image);
X86Instruction[] instrs = dasm.Take(3).ToArray();
Assert.AreEqual(Registers.ss, ((MemoryOperand)instrs[0].op2).DefaultSegment);
Assert.AreEqual(Registers.ds, ((MemoryOperand)instrs[1].op2).DefaultSegment);
Assert.AreEqual(Registers.cs, ((MemoryOperand)instrs[2].op2).DefaultSegment);
}
private void RunFileTestx86_32(string relativePath, string outputFile)
{
Program program;
var sc = new ServiceContainer();
var fsSvc = new FileSystemServiceImpl();
var el = new FakeDecompilerEventListener();
sc.AddService<IFileSystemService>(fsSvc);
sc.AddService<DecompilerEventListener>(el);
var arch = new X86ArchitectureFlat32();
var asm = new X86TextAssembler(sc, arch);
using (var rdr = new StreamReader(FileUnitTester.MapTestPath(relativePath)))
{
var platform = new DefaultPlatform(sc, arch);
asm.Platform = platform;
program = asm.Assemble(Address.Ptr32(0x10000000), rdr);
}
var scanner = new Scanner(program, new Dictionary<Address, ProcedureSignature>(), null, sc);
scanner.EnqueueEntryPoint(new EntryPoint(program.Image.BaseAddress, arch.CreateProcessorState()));
scanner.ScanImage();
using (var fut = new FileUnitTester(outputFile))
{
foreach (var proc in program.Procedures.Values)
{
proc.Write(false, fut.TextWriter);
}
fut.AssertFilesEqual();
}
}
public void Dis_x86_InvalidKeptStateRegression()
{
X86TextAssembler asm = new X86TextAssembler(sc, new X86ArchitectureFlat32());
var lr = asm.AssembleFragment(
Address.Ptr32(0x01001000),
"db 0xf2, 0x0f, 0x70, 0x00, 0x00\r\n" +
"db 0xf3, 0x0f, 0x70, 0x00, 0x00\r\n");
/* Before (incorrect):
* pshuflw xmm0, dqword ptr ds:[eax], 0
* pshuflw xmm0, dqword ptr ds:[eax], 0
*
*
* After (correct):
* pshuflw xmm0, dqword ptr ds:[eax], 0
* pshufhw xmm0, dqword ptr ds:[eax], 0
*/
MemoryArea img = lr.SegmentMap.Segments.Values.First().MemoryArea;
CreateDisassembler32(img);
var instructions = dasm.GetEnumerator();
X86Instruction one = DisEnumerator_TakeNext(instructions);
X86Instruction two = DisEnumerator_TakeNext(instructions);
Assert.AreEqual(Opcode.pshuflw, one.code);
Assert.AreEqual("xmm0", one.op1.ToString());
Assert.AreEqual("[eax]", one.op2.ToString());
Assert.AreEqual(Opcode.pshufhw, two.code);
Assert.AreEqual("xmm0", two.op1.ToString());
Assert.AreEqual("[eax]", two.op2.ToString());
}
