private void BuildX86RealTest(Action <X86Assembler> test)
{
var addr = Address.SegPtr(0x0C00, 0);
var m = new X86Assembler(sc, new FakePlatform(null, new X86ArchitectureReal()), addr, new List <ImageSymbol>());
test(m);
this.program = m.GetImage();
this.scan = this.CreateScanner(this.program);
var sym = new ImageSymbol(addr);
scan.EnqueueImageSymbol(sym, true);
}
private void Given_x86_Image(Action <X86Assembler> asm)
{
var addrBase = Address.Ptr32(0x100000);
var arch = new X86ArchitectureFlat32("x86-protected-32");
var entry = ImageSymbol.Procedure(arch, addrBase);
var m = new X86Assembler(null, new DefaultPlatform(null, arch), addrBase, new List <ImageSymbol> {
entry
});
asm(m);
this.program = m.GetImage();
}
private ParsedOperand IntegerCommon()
{
if (lexer.PeekToken() == Token.BRA)
{
Expect(Token.BRA);
return(ParseMemoryOperand(RegisterStorage.None));
}
else
{
return(new ParsedOperand(new ImmediateOperand(X86Assembler.IntegralConstant(totalInt, defaultWordWidth))));
}
}
public void IntegralConstant32()
{
Constant c;
c = X86Assembler.IntegralConstant(-2, PrimitiveType.Word32);
Assert.AreSame(PrimitiveType.SByte, c.DataType);
c = X86Assembler.IntegralConstant(-128, PrimitiveType.Word32);
Assert.AreSame(PrimitiveType.SByte, c.DataType);
c = X86Assembler.IntegralConstant(-129, PrimitiveType.Word32);
Assert.AreSame(PrimitiveType.Word32, c.DataType);
c = X86Assembler.IntegralConstant(-129, PrimitiveType.Word16);
Assert.AreSame(PrimitiveType.Word16, c.DataType);
}
private void Given_x86_Image(Action <X86Assembler> asm)
{
var addrBase = Address.Ptr32(0x100000);
var arch = new X86ArchitectureFlat32(new ServiceContainer(), "x86-protected-32", new Dictionary <string, object>());
var entry = ImageSymbol.Procedure(arch, addrBase);
var m = new X86Assembler(arch, addrBase, new List <ImageSymbol> {
entry
});
asm(m);
this.program = m.GetImage();
this.program.Platform = new Win32Platform(arch.Services, arch);
}
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);
}
private void BuildX86RealTest(Action <X86Assembler> test)
{
var addr = Address.SegPtr(0x0C00, 0);
var arch = new X86ArchitectureReal("x86-real-16");
var m = new X86Assembler(arch, addr, new List <ImageSymbol>());
test(m);
this.program = m.GetImage();
this.program.Platform = new MsdosPlatform(sc, arch);
this.scan = this.CreateScanner(this.program);
var sym = ImageSymbol.Procedure(arch, addr);
scan.EnqueueImageSymbol(sym, true);
}
private static void TestAssembler(IReadOnlyList <X86Instruction> instructions)
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
var assembler = new X86Assembler(writer);
foreach (var instruction in instructions)
{
assembler.Write(instruction);
}
ValidateCode(instructions, stream.ToArray());
}
}
public void Scanner_CallGraphTree()
{
var arch = new X86ArchitectureReal(sc, "x86-real-16", new Dictionary <string, object>());
program = new Program();
program.Architecture = arch;
var addr = Address.SegPtr(0xC00, 0);
var m = new X86Assembler(arch, addr, new List <ImageSymbol>());
m.i86();
m.Proc("main");
m.Call("baz");
m.Ret();
m.Endp("main");
m.Proc("foo");
m.Ret();
m.Endp("foo");
m.Proc("bar");
m.Ret();
m.Endp("bar");
m.Proc("baz");
m.Call("foo");
m.Call("bar");
m.Jmp("foo");
m.Endp("baz");
program = m.GetImage();
program.Platform = new FakePlatform(null, arch);
Given_Project();
var scan = new Scanner(
program,
project.LoadedMetadata,
new DynamicLinker(project, program, eventListener),
sc);
var sym = ImageSymbol.Procedure(arch, addr);
scan.EnqueueImageSymbol(sym, true);
scan.ScanImage();
Assert.AreEqual(4, program.Procedures.Count);
}
private static void TestAssembler(IReadOnlyList <X86Instruction> instructions)
{
var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "test.bin");
using (var stream = File.Create(path))
{
var writer = new BinaryStreamWriter(stream);
var assembler = new X86Assembler(writer);
foreach (var instruction in instructions)
{
assembler.Write(instruction);
}
}
ValidateCode(instructions, File.ReadAllBytes(path));
}
private ParsedOperand ParseMemoryOperand(RegisterStorage segOver)
{
MemoryOperand memOp = new MemoryOperand(null);
memOp.SegOverride = segOver;
this.segOverride = segOver;
ParseMemoryFactor(memOp);
for (;;)
{
Token token = lexer.GetToken();
switch (token)
{
default:
OnError("Unexpected token: " + token);
return(null);
case Token.KET:
if (totalInt != 0 || sym != null)
{
if (addrWidth == null || sym != null)
{
memOp.Offset = Constant.Create(defaultAddressWidth, totalInt);
}
else
{
memOp.Offset = X86Assembler.IntegralConstant(totalInt, addrWidth);
}
}
return(new ParsedOperand(memOp, sym));
case Token.PLUS:
break;
case Token.MINUS:
Expect(Token.INTEGER);
totalInt -= lexer.Integer;
continue;
case Token.ID:
break;
}
ParseMemoryFactor(memOp);
}
}
public void Scanner_CallGraphTree()
{
var arch = new X86ArchitectureReal("x86-real-16");
program = new Program();
program.Architecture = arch;
var addr = Address.SegPtr(0xC00, 0);
var m = new X86Assembler(sc, new DefaultPlatform(sc, arch), addr, new List <ImageSymbol>());
m.i86();
m.Proc("main");
m.Call("baz");
m.Ret();
m.Endp("main");
m.Proc("foo");
m.Ret();
m.Endp("foo");
m.Proc("bar");
m.Ret();
m.Endp("bar");
m.Proc("baz");
m.Call("foo");
m.Call("bar");
m.Jmp("foo");
m.Endp("baz");
program = m.GetImage();
program.Platform = new FakePlatform(null, arch);
Given_Project();
var scan = new Scanner(
program,
new ImportResolver(project, program, eventListener),
sc);
var sym = ImageSymbol.Procedure(arch, addr);
scan.EnqueueImageSymbol(sym, true);
scan.ScanImage();
Assert.AreEqual(4, program.Procedures.Count);
}
private void Given_Code(Action <X86Assembler> coder)
{
var asm = new X86Assembler(arch, Address.Ptr32(0x00100000), new List <EntryPoint>());
coder(asm);
var program = asm.GetImage();
this.image = program.Image;
Given_Platform();
var win32 = new Win32Emulator(image, platform, importReferences);
emu = new X86Emulator(arch, program.Image, win32);
emu.InstructionPointer = program.Image.BaseAddress;
emu.WriteRegister(Registers.esp, (uint)program.Image.BaseAddress.ToLinear() + 0x0FFC);
emu.ExceptionRaised += delegate { throw new Exception(); };
}
private void Given_Win32Code(Action <X86Assembler> coder)
{
var asm = new X86Assembler(arch, Address.Ptr32(0x00100000), new List <ImageSymbol>());
coder(asm);
var program = asm.GetImage();
this.segmentMap = program.SegmentMap;
Given_Platform();
var win32 = new Win32Emulator(program.SegmentMap, platform, importReferences);
emu = (X86Emulator)arch.CreateEmulator(program.SegmentMap, win32);
emu.InstructionPointer = program.ImageMap.BaseAddress;
emu.WriteRegister(Registers.esp, (uint)program.ImageMap.BaseAddress.ToLinear() + 0x0FFC);
emu.ExceptionRaised += delegate { throw new Exception(); };
}
private void BuildX86RealTest(Action <X86Assembler> test)
{
var addr = Address.SegPtr(0x0C00, 0);
var m = new X86Assembler(new IntelArchitecture(ProcessorMode.Real), addr, new List <EntryPoint>());
test(m);
var lr = m.GetImage();
program = new Program(
lr.Image,
lr.ImageMap,
lr.Architecture,
new FakePlatform(null, arch));
scan = CreateScanner(program);
EntryPoint ep = new EntryPoint(addr, program.Architecture.CreateProcessorState());
scan.EnqueueEntryPoint(ep);
}
public void Scanner_CallGraphTree()
{
Program prog = new Program();
var addr = Address.SegPtr(0xC00, 0);
var m = new X86Assembler(new IntelArchitecture(ProcessorMode.Real), addr, new List <EntryPoint>());
m.i86();
m.Proc("main");
m.Call("baz");
m.Ret();
m.Endp("main");
m.Proc("foo");
m.Ret();
m.Endp("foo");
m.Proc("bar");
m.Ret();
m.Endp("bar");
m.Proc("baz");
m.Call("foo");
m.Call("bar");
m.Jmp("foo");
m.Endp("baz");
var lr = m.GetImage();
prog.Image = lr.Image;
prog.ImageMap = lr.ImageMap;
prog.Architecture = lr.Architecture;
prog.Platform = new FakePlatform(null, arch);
var proj = new Project {
Programs = { prog }
};
var scan = new Scanner(prog, new Dictionary <Address, ProcedureSignature>(), new ImportResolver(proj), new FakeDecompilerEventListener());
EntryPoint ep = new EntryPoint(addr, prog.Architecture.CreateProcessorState());
scan.EnqueueEntryPoint(ep);
scan.ScanImage();
Assert.AreEqual(4, prog.Procedures.Count);
}
public Program Assemble(Address addr, TextReader rdr)
{
addrBase = addr;
lexer = new Lexer(rdr);
asm = new X86Assembler(arch, addrBase, entryPoints);
asm.Platform = Platform;
// Assemblers are strongly line-oriented.
while (lexer.PeekToken() != Token.EOFile)
{
ProcessLine();
}
asm.ReportUnresolvedSymbols();
addrStart = addrBase;
return(asm.GetImage());
}
public void Scanner_CallGraphTree()
{
program = new Program();
var addr = Address.SegPtr(0xC00, 0);
var m = new X86Assembler(sc, new DefaultPlatform(sc, new X86ArchitectureReal()), addr, new List <EntryPoint>());
m.i86();
m.Proc("main");
m.Call("baz");
m.Ret();
m.Endp("main");
m.Proc("foo");
m.Ret();
m.Endp("foo");
m.Proc("bar");
m.Ret();
m.Endp("bar");
m.Proc("baz");
m.Call("foo");
m.Call("bar");
m.Jmp("foo");
m.Endp("baz");
program = m.GetImage();
program.Platform = new FakePlatform(null, arch);
Given_Project();
var scan = new Scanner(
program,
new ImportResolver(project, program, eventListener),
sc);
var ep = new EntryPoint(addr, program.Architecture.CreateProcessorState());
scan.EnqueueEntryPoint(ep);
scan.ScanImage();
Assert.AreEqual(4, program.Procedures.Count);
}
public override void Build(X86Assembler m)
{
m.i86();
// A straight-forward factorial function + a driver program to ensure the return value
// is USE'd.
m.Mov(cx, 0x100);
m.Push(cx);
m.Call("factorial");
m.Add(Registers.sp, 2);
m.Mov(m.WordPtr(0x0100), ax);
m.Ret();
m.Proc("factorial");
m.Push(bp);
m.Mov(bp, sp);
m.Mov(ax, m.WordPtr(bp, 4));
m.Dec(ax);
m.Jz("base_case");
m.Push(ax);
m.Call("factorial");
m.Inc(sp);
m.Inc(sp);
m.Mov(dx, m.WordPtr(bp, 4));
m.Imul(dx);
m.Jmp("done");
m.Label("base_case");
m.Mov(ax, 1);
m.Label("done");
m.Pop(bp);
m.Ret();
m.Endp("factorial");
}
void before_each()
{
assembler = new X86Assembler();
}
private byte[] GetBytes(X86Assembler m)
{
var bmem = (ByteMemoryArea)m.GetImage().SegmentMap.Segments.Values.First().MemoryArea;
return(bmem.Bytes);
}
public new void Setup()
{
base.Setup();
m = new X86Assembler(sc, new MsdosPlatform(sc, new X86ArchitectureReal()), Address.SegPtr(0x100, 0x0100), new List <EntryPoint>());
}
private byte[] GetBytes(X86Assembler m)
{
return(m.GetImage().SegmentMap.Segments.Values.First().MemoryArea.Bytes);
}
public new void Setup()
{
base.Setup();
m = new X86Assembler(sc, new MsdosPlatform(sc, new X86ArchitectureReal("x86-real-16")), Address.SegPtr(0x100, 0x0100), new List <ImageSymbol>());
}
public void Setup()
{
arch = new X86ArchitectureFlat32();
asm = new X86Assembler(arch, loadAddress, new List <EntryPoint>());
}
public abstract void Build(X86Assembler m);
public void EmitModRM(int reg, RegisterOperand op)
{
reg <<= 3;
emitter.EmitByte(0xC0 | reg | X86Assembler.RegisterEncoding(op.Register));
}
/// <summary>
/// Emits the ModRM byte (and SIB byte if applicable)
/// </summary>
/// <param name="reg"></param>
/// <param name="memOp"></param>
/// <returns>The offset value to be emitted as the last piece of the instruction</returns>
public Constant?EmitModRMPrefix(int reg, MemoryOperand memOp)
{
offset = null;
reg <<= 3;
if (memOp.Base != RegisterStorage.None || memOp.Index != RegisterStorage.None)
{
PrimitiveType baseWidth = memOp.Base.DataType;
PrimitiveType indexWidth = memOp.Index.DataType;
if (memOp.Base != RegisterStorage.None && memOp.Index != RegisterStorage.None)
{
if (baseWidth != indexWidth)
{
OnError("mismatched base and index registers");
return(null);
}
}
// Add the 'mod' bits
if (memOp.Offset != null)
{
Debug.Assert(memOp.Offset.IsValid);
if (memOp.Offset.DataType == PrimitiveType.SByte)
{
reg |= 0x40;
offset = memOp.Offset;
}
else
{
reg |= 0x80;
offset = Constant.Create(defaultWordSize, memOp.Offset.ToInt32());
}
}
bool fNeedsSib = false;
int sib = 0;
if (baseWidth == PrimitiveType.Word16)
{
reg |= Get16AddressingModeMask(memOp);
}
else if (baseWidth == PrimitiveType.Word32 || indexWidth == PrimitiveType.Word32)
{
if (memOp.Index == RegisterStorage.None)
{
if (memOp.Base != Registers.esp)
{
reg |= X86Assembler.RegisterEncoding(memOp.Base);
if (memOp.Offset == null && memOp.Base == Registers.ebp)
{
reg |= 0x40;
offset = Constant.Byte(0);
}
}
else
{
reg |= 0x04;
fNeedsSib = true;
sib = 0x24;
}
}
else
{
reg |= 0x04;
fNeedsSib = true;
switch (memOp.Scale)
{
case 1: sib = 0; break;
case 2: sib = 0x40; break;
case 4: sib = 0x80; break;
case 8: sib = 0xC0; break;
default: OnError("Scale factor must be 1, 2, 4, or 8"); return(Constant.Invalid);
}
if (memOp.Base == RegisterStorage.None)
{
sib |= 0x05;
reg &= ~0xC0; // clear mod part of modRM.
if (memOp.Offset == null)
{
offset = Constant.Word32(0);
}
}
else
{
sib |= X86Assembler.RegisterEncoding(memOp.Base);
}
if (memOp.Index != Registers.esp)
{
sib |= X86Assembler.RegisterEncoding(memOp.Index) << 3;
}
else
{
throw new ApplicationException("ESP register can't be used as an index register");
}
}
}
else
{
throw new ApplicationException("unexpected address width");
}
emitter.EmitByte(reg);
if (fNeedsSib)
{
emitter.EmitByte(sib);
}
return(offset);
}
else
{
return(EmitDirectAddress(reg, memOp));
}
}
public new void Setup()
{
base.Setup();
m = new X86Assembler(new IntelArchitecture(ProcessorMode.Real), Address.SegPtr(0x100, 0x0100), new List <EntryPoint>());
}
private X86Rewriter CreateRewriter32(X86Assembler m)
{
state = new X86State(arch32);
return(new X86Rewriter(arch32, host, state, m.GetImage().Image.CreateLeReader(0), new Frame(arch32.WordWidth)));
}
