private IEnumerable <DataType> ParseVarargsFormat( string varargsParserTypename, Address addrInstr, ProcedureCharacteristics chr, string format) { var svc = services.RequireService <IPluginLoaderService>(); var type = svc.GetType(varargsParserTypename); if (type == null) { throw new TypeLoadException( string.Format( "Unable to load {0} varargs parser.", chr.VarargsParserClass)); } var varargsParser = (IVarargsFormatParser)Activator.CreateInstance( type, program, addrInstr, format, services); varargsParser.Parse(); return(varargsParser.ArgumentTypes); }
public void Setup() { this.sc = new ServiceContainer(); this.x86 = new X86ArchitectureFlat32(); this.ppc = new PowerPcArchitecture32(); this.m = new ProcedureBuilder(); this.printfChr = new ProcedureCharacteristics() { VarargsParserClass = "Reko.Libraries.Libc.PrintfFormatParser,Reko.Libraries.Libc" }; this.x86PrintfSig = new FunctionType( null, StackId(null, 4, CStringType()), StackId("...", 8, new UnknownType())); this.x86SprintfSig = new FunctionType( null, StackId(null, 4, CStringType()), StackId(null, 8, CStringType()), StackId("...", 12, new UnknownType())); this.ppcPrintfSig = new FunctionType( null, RegId(null, ppc, "r3", CStringType()), RegId("...", ppc, "r4", new UnknownType())); this.addrInstr = Address.Ptr32(0x123400); var listener = new FakeDecompilerEventListener(); sc.AddService <DecompilerEventListener>(listener); }
private static ProcedureCharacteristics DeserializeXml(string x) { XmlSerializer ser = SerializedLibrary.CreateSerializer_v1(typeof(ProcedureCharacteristics)); ProcedureCharacteristics pc = (ProcedureCharacteristics)ser.Deserialize(new StringReader(x)); return(pc); }
public UserProcedure(Address address, string name) { Address = address; Name = name; Assume = new List <RegisterValue_v2>(); Characteristics = new ProcedureCharacteristics(); }
public Expression Intrinsic(string name, bool isIdempotent, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var intrinsic = EnsureIntrinsic(name, isIdempotent, returnType, args.Length); intrinsic.Characteristics = c; return(new Application(new ProcedureConstant(PrimitiveType.Ptr32, intrinsic), returnType, args)); }
public Expression PseudoProcedure(string name, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var ppp = EnsurePseudoProcedure(name, returnType, args.Length); ppp.Characteristics = c; return(new Application(new ProcedureConstant(PrimitiveType.Ptr32, ppp), returnType, args)); }
public IntrinsicBuilder(string intrinsicName, bool hasSideEffect, ProcedureCharacteristics characteristics) { this.intrinsicName = intrinsicName; this.hasSideEffect = hasSideEffect; this.characteristics = characteristics; this.parameters = new List <Identifier>(); }
public void DynLink_MangledProcedureCharacteristics() { var chr = new ProcedureCharacteristics { VarargsParserClass = "FakeParser", }; program.EnvironmentMetadata.Characteristics.Add("foo@mangled", chr); platform.Setup(p => p.SignatureFromName( It.Is <string>(n => n == "foo@mangled"))) .Returns(new Procedure_v1 { Name = "foo", Signature = new SerializedSignature(), }); var eventListener = new FakeDecompilerEventListener(); var proj = new Project(); var impres = new DynamicLinker(proj, program, eventListener); var ep = impres.ResolveProcedure("", "foo@mangled", platform.Object); var expected = @" void foo() VarargsParserClass: FakeParser"; AssertExternalProcedure(expected, ep); }
/// <summary> /// Bind the formal parameters of the signature to actual arguments in /// the frame of the calling procedure. /// </summary> /// <param name="sigCallee"></param> /// <param name="chr"></param> /// <returns></returns> public virtual List <Expression> BindArguments(FunctionType sigCallee, ProcedureCharacteristics chr) { var actuals = new List <Expression>(); for (int i = 0; i < sigCallee.Parameters.Length; ++i) { var formalArg = sigCallee.Parameters[i]; if (formalArg.Storage is OutArgumentStorage) { var outArg = BindOutArg(formalArg); actuals.Add(outArg); } else { var actualArg = Bind(formalArg); actuals.Add(actualArg); } } if (sigCallee.IsVariadic) { return(BindVariadicArguments(sigCallee, chr, actuals)); } else { return(actuals); } }
private void RewriteIll() { var c = new ProcedureCharacteristics { Terminates = true, }; m.SideEffect(host.Intrinsic("__ill", false, c, VoidType.Instance)); }
private void RewriteIll() { var c = new ProcedureCharacteristics { Terminates = true, }; emitter.SideEffect(host.PseudoProcedure("__ill", c, VoidType.Instance)); }
private void RewriteHalt() { var c = new ProcedureCharacteristics { Terminates = true, }; m.SideEffect(host.PseudoProcedure("__halt", c, VoidType.Instance)); }
public Expression PseudoProcedure(string name, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var ppp = new PseudoProcedure(name, returnType, args.Length); return(new Application( new ProcedureConstant(arch.PointerType, ppp), returnType, args)); }
private void RewriteSigrie(MipsInstruction instr) { var chr = new ProcedureCharacteristics { Terminates = true }; m.SideEffect(host.PseudoProcedure("__reserved_instruction", chr, VoidType.Instance, RewriteOperand(instr.Operands[0]))); }
public Expression Intrinsic(string name, bool hasSideEffect, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var intrinsic = program.EnsureIntrinsicProcedure(name, hasSideEffect, returnType, args); intrinsic.Characteristics = c; return(new Application( new ProcedureConstant(PrimitiveType.Ptr32, intrinsic), returnType, args)); }
private void RewriteHlt() { var c = new ProcedureCharacteristics { Terminates = true, }; var intrinsic = host.Intrinsic("__hlt", false, c, VoidType.Instance); m.SideEffect(intrinsic, InstrClass.Terminates); }
public Expression Intrinsic(string name, bool isIdempotent, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var intrinsic = Program.EnsureIntrinsicProcedure(name, isIdempotent, returnType, args); intrinsic.Characteristics = c; return(new Application( new ProcedureConstant(Program.Architecture.PointerType, intrinsic), returnType, args)); }
public Expression PseudoProcedure(string name, ProcedureCharacteristics c, DataType returnType, params Expression[] args) { var ppp = Program.EnsurePseudoProcedure(name, returnType, args); ppp.Characteristics = c; return(new Application( new ProcedureConstant(Program.Architecture.PointerType, ppp), returnType, args)); }
public void ProcChar_DeserializeIsMalloc() { string x = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + "<ProcedureCharacteristics>" + " <allocator>1</allocator>" + "</ProcedureCharacteristics>"; ProcedureCharacteristics pc = DeserializeXml(x); Assert.IsTrue(pc.Allocator); }
private void RewriteHalt() { iclass = InstrClass.Terminates; var c = new ProcedureCharacteristics { Terminates = true, }; m.SideEffect(host.Intrinsic("__halt", false, c, VoidType.Instance)); }
private void RewriteHlt() { rtlc = RtlClass.Terminates; var c = new ProcedureCharacteristics { Terminates = true, }; var ppp = host.PseudoProcedure("__hlt", c, VoidType.Instance); m.SideEffect(ppp); }
public Instruction BuildInstruction( Expression callee, CallSite site, ProcedureCharacteristics chr) { if (callee is ProcedureConstant pc) { pc.Procedure.Signature = this.expandedSig; } var ab = arch.CreateFrameApplicationBuilder(frame, site, callee); return(ab.CreateInstruction(this.expandedSig, chr)); }
public void Setup() { this.sc = new ServiceContainer(); var cfg = new Mock <IConfigurationService>(); var env = new Mock <PlatformDefinition>(); cfg.Setup(c => c.GetEnvironment(It.IsAny <string>())).Returns(env.Object); env.Setup(e => e.Architectures).Returns(new List <PlatformArchitectureDefinition>()); sc.AddService <IConfigurationService>(cfg.Object); sc.AddService <IPluginLoaderService>(new PluginLoaderService()); this.win32 = new Win32Platform(sc, new X86ArchitectureFlat32(sc, "x86-protected-32", new Dictionary <string, object>())); this.win_x86_64 = new Win_x86_64_Platform(sc, new X86ArchitectureFlat64(sc, "x86-protected-64", new Dictionary <string, object>())); this.sysV_ppc = new SysVPlatform(sc, new PowerPcBe32Architecture(sc, "ppc-be-32", new Dictionary <string, object>())); this.m = new ProcedureBuilder(); this.printfChr = new ProcedureCharacteristics() { VarargsParserClass = "Reko.Libraries.Libc.PrintfFormatParser,Reko.Libraries.Libc" }; this.x86PrintfSig = new FunctionType( null, StackId(null, 4, CStringType32())) { IsVariadic = true }; this.x86SprintfSig = new FunctionType( null, StackId(null, 4, CStringType32()), StackId(null, 8, CStringType32())) { IsVariadic = true }; this.win_x86_64PrintfSig = new FunctionType( null, RegId(null, win_x86_64, "rcx", CStringType64())) { IsVariadic = true }; this.ppcPrintfSig = new FunctionType( null, RegId(null, sysV_ppc, "r3", CStringType32())) { IsVariadic = true }; this.addrInstr = Address.Ptr32(0x123400); this.listener = new FakeDecompilerEventListener(); sc.AddService <DecompilerEventListener>(listener); this.dummyPc = new ProcedureConstant(PrimitiveType.Ptr32, new ExternalProcedure("dummy", x86PrintfSig)); }
private void RewriteBinOv(Func <Expression, Expression, Expression> fn) { RewriteBin(fn); var dst = Rewrite(instr.op3); m.BranchInMiddleOfInstruction( m.Not(host.PseudoProcedure("OV", PrimitiveType.Bool, dst)), instr.Address + instr.Length, RtlClass.ConditionalTransfer); var ch = new ProcedureCharacteristics { Terminates = true }; m.SideEffect(host.PseudoProcedure("__trap_overflow", ch, VoidType.Instance)); }
public void Vafs_NoVarargs() { Given_VaScanner(win32); var emptyChr = new ProcedureCharacteristics(); var emptySig = new FunctionType(); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, null, null)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, emptySig, null)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, null, emptyChr)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, emptySig, emptyChr)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, x86PrintfSig, null)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, x86PrintfSig, emptyChr)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, null, printfChr)); Assert.IsFalse(vafs.TryScan(addrInstr, dummyPc, emptySig, printfChr)); }
public bool TryScan(Address addrInstr, FunctionType sig, ProcedureCharacteristics chr) { if ( sig == null || !sig.IsVarargs() || chr == null || !VarargsParserSet(chr) ) { this.sig = null; //$out parameter return(false); } var format = ReadVarargsFormat(sig); var argTypes = ParseVarargsFormat(addrInstr, chr, format); this.sig = ReplaceVarargs(sig, argTypes); return(true); }
/// <summary> /// Creates an instruction: /// a = foo(b) /// or /// foo(b) /// depending on whether the signature returns a value or is of /// type 'void' /// </summary> /// <returns></returns> public Instruction CreateInstruction( FunctionType sigCallee, ProcedureCharacteristics chr) { if (sigCallee == null || !sigCallee.ParametersValid) { throw new InvalidOperationException("No signature available; application cannot be constructed."); } this.sigCallee = sigCallee; Expression expOut = null; DataType dtOut = VoidType.Instance; if (!sigCallee.HasVoidReturn) { expOut = BindReturnValue(sigCallee.ReturnValue); dtOut = sigCallee.ReturnValue.DataType; } var actuals = BindArguments(sigCallee, chr); Expression appl = new Application( callee, dtOut, actuals.ToArray()); if (expOut == null) { return(new SideEffect(appl)); } else if (expOut is Identifier idOut) { int extraBits = expOut.DataType.BitSize - sigCallee.ReturnValue.DataType.BitSize; if (extraBits > 0) { // The non-live bits of expOut can safely be replaced with anything, // since they won't be used. Later stages of the decompilation // process should remove the unused bits. var dtUnused = PrimitiveType.CreateWord(extraBits); var unused = Constant.Create(dtUnused, 0); appl = new MkSequence(expOut.DataType, unused, appl); } return(new Assignment(idOut, appl)); } else { return(new Store(expOut, appl)); } }
private void RewriteBinOv(Func <Expression, Expression, Expression> fn) { RewriteBin(fn); var dst = Rewrite(instr.Operands[2]); m.BranchInMiddleOfInstruction( m.Not(host.Intrinsic("OV", false, PrimitiveType.Bool, dst)), instr.Address + instr.Length, InstrClass.ConditionalTransfer); var ch = new ProcedureCharacteristics { Terminates = true }; m.SideEffect( host.Intrinsic("__trap_overflow", true, ch, VoidType.Instance), InstrClass.Transfer | InstrClass.Call); }
public void Setup() { this.mr = new MockRepository(); this.sc = new ServiceContainer(); var cfg = mr.Stub <IConfigurationService>(); var env = mr.Stub <OperatingEnvironment>(); cfg.Stub(c => c.GetEnvironment("")).IgnoreArguments().Return(env); env.Stub(e => e.Architectures).Return(new List <IPlatformArchitectureElement>()); cfg.Replay(); env.Replay(); sc.AddService <IConfigurationService>(cfg); this.win32 = new Win32Platform(sc, new X86ArchitectureFlat32()); this.win_x86_64 = new Win_x86_64_Platform(sc, new X86ArchitectureFlat64()); this.sysV_ppc = new SysVPlatform(sc, new PowerPcBe32Architecture { Name = "ppc-be-32" }); this.m = new ProcedureBuilder(); this.printfChr = new ProcedureCharacteristics() { VarargsParserClass = "Reko.Libraries.Libc.PrintfFormatParser,Reko.Libraries.Libc" }; this.x86PrintfSig = new FunctionType( null, StackId(null, 4, CStringType32()), StackId("...", 8, new UnknownType())); this.x86SprintfSig = new FunctionType( null, StackId(null, 4, CStringType32()), StackId(null, 8, CStringType32()), StackId("...", 12, new UnknownType())); this.win_x86_64PrintfSig = new FunctionType( null, RegId(null, win_x86_64, "rcx", CStringType64()), RegId("...", win_x86_64, "rdx", new UnknownType())); this.ppcPrintfSig = new FunctionType( null, RegId(null, sysV_ppc, "r3", CStringType32()), RegId("...", sysV_ppc, "r4", new UnknownType())); this.addrInstr = Address.Ptr32(0x123400); var listener = new FakeDecompilerEventListener(); sc.AddService <DecompilerEventListener>(listener); }
private void RewriteCall( Statement stm, CallInstruction ci, FunctionType sig, ProcedureCharacteristics chr) { ssam.AdjustRegisterAfterCall( stm, ci, this.arch.StackRegister, sig.StackDelta - ci.CallSite.SizeOfReturnAddressOnStack); var ab = new ApplicationBuilder( arch, ssa.Procedure.Frame, ci.CallSite, ci.Callee, sig, false); stm.Instruction = ab.CreateInstruction(); ssaIdTransformer.Transform(stm, ci); }
public SimulatedProc EnsureProc( Module module, string procName, Action<IProcessorEmulator> emulator, ProcedureCharacteristics chars = null) { SimulatedProc proc; if (!module.Procedures.TryGetValue(procName, out proc)) { var extProc = platform.LookupProcedureByName(module.Name, procName); proc = new SimulatedProc(procName, emulator); proc.Signature = extProc.Signature; if (chars != null) proc.Characteristics = chars; proc.uFakedAddress = ++this.uPseudoFn; InterceptedCalls[proc.uFakedAddress] = proc; module.Procedures.Add(procName, proc); } return proc; }
public ExternalProcedure(string name, ProcedureSignature signature, ProcedureCharacteristics chars) : base(name) { this.Signature = signature; this.Characteristics = chars; }