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))); }