public void RunTest(IEnumerable <Procedure> procs) { importResolver = new Mock <IImportResolver>().Object; var flow = new ProgramDataFlow(program); var scc = new Dictionary <Procedure, SsaState>(); foreach (var proc in procs) { Aliases alias = new Aliases(proc, flow); alias.Transform(); // Transform the procedure to SSA state. When encountering 'call' instructions, // they can be to functions already visited. If so, they have a "ProcedureFlow" // associated with them. If they have not been visited, or are computed destinations // (e.g. vtables) they will have no "ProcedureFlow" associated with them yet, in // which case the the SSA treats the call as a "hell node". var doms = proc.CreateBlockDominatorGraph(); var sst = new SsaTransform( flow, proc, importResolver, doms, program.Platform.CreateImplicitArgumentRegisters()); sst.AddUseInstructions = true; sst.Transform(); var ssa = sst.SsaState; scc.Add(proc, ssa); } this.dataFlow = new DataFlow2(); var regp = new RegisterPreservation(scc, dataFlow); regp.Compute(); }
// connect all of the .wbxsyscall stuff public void ConnectSyscalls(IImportResolver syscalls) { Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.RW); var tmp = new IntPtr[1]; var ptrSize = (ulong)IntPtr.Size; foreach (var s in _importSymbols) { if (s.Size == ptrSize) { var p = syscalls.GetProcAddrOrThrow(s.Name); tmp[0] = p; Marshal.Copy(tmp, 0, Z.US(s.Value), 1); } else { if (s.Size % ptrSize != 0) { // They're supposed to be arrays of pointers, so uhhh yeah? throw new InvalidOperationException($"Symbol {s.Name} has unexpected size"); } var count = (int)(s.Size / ptrSize); for (var i = 0; i < count; i++) { var p = syscalls.GetProcAddrOrThrow($"{s.Name}[{i}]"); tmp[0] = p; Marshal.Copy(tmp, 0, Z.US(s.Value + ((ulong)i * ptrSize)), 1); } } } Protect(); }
public void Setup() { ssaIds = new SsaIdentifierCollection(); mr = new MockRepository(); arch = mr.Stub<IProcessorArchitecture>(); importResolver = mr.Stub<IImportResolver>(); }
public void ConnectImports(string moduleName, IImportResolver module) { // this is called once internally when bootstrapping, and externally // when we need to restore a savestate from another run. so imports might or might not be sealed if (_everythingSealed && _imports != null) { Memory.Protect(_imports.Start, _imports.Size, MemoryBlockBase.Protection.RW); } Dictionary <string, IntPtr> imports; if (ImportsByModule.TryGetValue(moduleName, out imports)) { foreach (var kvp in imports) { var valueArray = new IntPtr[] { module.GetProcAddrOrThrow(kvp.Key) }; Marshal.Copy(valueArray, 0, kvp.Value, 1); } } if (_everythingSealed && _imports != null) { Memory.Protect(_imports.Start, _imports.Size, _imports.Prot); } }
public override ExternalProcedure ResolveImportedProcedure( IImportResolver resolver, Platform platform, AddressContext ctx) { var ep = resolver.ResolveProcedure(ModuleName, ImportName, platform); if (ep != null) { return(ep); } // Can we guess at the signature? var sig = platform.SignatureFromName(ImportName); if (sig != null) { ep = new ExternalProcedure(ImportName, sig); //$BUGBUG: mangled name! } else { ctx.Warn("Unable to resolve imported reference {0}.", this); return(new ExternalProcedure(this.ToString(), null)); } return(ep); }
public void Setup() { arch = new Mock <IProcessorArchitecture>().Object; importResolver = new Mock <IImportResolver>().Object; listener = new FakeDecompilerEventListener(); m = new SsaProcedureBuilder(); }
protected override void RunTest(Program prog, TextWriter fut) { IImportResolver importResolver = null; DataFlowAnalysis dfa = new DataFlowAnalysis(prog, importResolver, new FakeDecompilerEventListener()); dfa.UntangleProcedures(); foreach (Procedure proc in prog.Procedures.Values) { Aliases alias = new Aliases(proc, prog.Architecture); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph()); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, prog.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(prog.Architecture, ssa.Identifiers, proc); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer co = new Coalescer(proc, ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); } }
public Scanner( Program program, IImportResolver importResolver, IServiceProvider services) : base(program, services.RequireService <DecompilerEventListener>()) { this.segmentMap = program.SegmentMap; this.importResolver = importResolver; this.Services = services; this.eventListener = services.RequireService <DecompilerEventListener>(); this.cancelSvc = services.GetService <CancellationTokenSource>(); if (segmentMap == null) { throw new InvalidOperationException("Program must have an segment map."); } if (program.ImageMap == null) { program.ImageMap = segmentMap.CreateImageMap(); } this.imageMap = program.ImageMap; this.procQueue = new PriorityQueue <WorkItem>(); this.blocks = new SortedList <Address, BlockRange>(); this.blockStarts = new Dictionary <Block, Address>(); this.importReferences = program.ImportReferences; this.visitedProcs = new HashSet <Procedure>(); this.cinj = new CommentInjector(program.User.Annotations); this.sr = new ScanResults { KnownProcedures = program.User.Procedures.Keys.ToHashSet(), KnownAddresses = program.ImageSymbols.ToDictionary(de => de.Key, de => de.Value), ICFG = new DiGraph <RtlBlock>(), }; }
public override Expression ResolveImport( IImportResolver resolver, IPlatform platform, AddressContext ctx) { return(resolver.ResolveImport(ModuleName, ImportName, platform)); }
public override Identifier ResolveImportedGlobal(IImportResolver importResolver, IPlatform platform, AddressContext ctx) { ctx.Warn("Ordinal global imports not supported. Please report this message to the Reko maintainers (https://github.com/uxmal/reko)."); var id = importResolver.ResolveGlobal(ModuleName, Ordinal, platform); return(null); }
public DataFlowAnalysis(Program program, IImportResolver importResolver, DecompilerEventListener eventListener) { this.program = program; this.importResolver = importResolver; this.eventListener = eventListener; this.flow = new ProgramDataFlow(program); }
protected override void RunTest(Program program, TextWriter fut) { InitProgram(program); IImportResolver importResolver = null; var eventListener = new FakeDecompilerEventListener(); DataFlowAnalysis dfa = new DataFlowAnalysis( program, importResolver, eventListener); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { SsaTransform sst = new SsaTransform( dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; var icrw = new IndirectCallRewriter( program, ssa, eventListener); icrw.Rewrite(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); } }
protected override void RunTest(Program program, TextWriter fut) { IImportResolver importResolver = null; var listener = new FakeDecompilerEventListener(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, importResolver, listener); var ssts = dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { var sst = ssts.Single(s => s.SsaState.Procedure == proc); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); DeadCode.Eliminate(ssa); ValuePropagator vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, importResolver, listener); vp.Transform(); DeadCode.Eliminate(ssa); Coalescer co = new Coalescer(ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); ssa.Validate(s => { ssa.Dump(true); Assert.Fail(s); }); } }
protected override void RunTest(Program program, TextWriter fut) { IImportResolver importResolver = null; var listener = new FakeDecompilerEventListener(); DataFlowAnalysis dfa = new DataFlowAnalysis(program, importResolver, listener); dfa.UntangleProcedures(); foreach (Procedure proc in program.Procedures.Values) { Aliases alias = new Aliases(proc); alias.Transform(); SsaTransform sst = new SsaTransform(dfa.ProgramDataFlow, proc, importResolver, proc.CreateBlockDominatorGraph(), new HashSet <RegisterStorage>()); SsaState ssa = sst.SsaState; ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa, program.Platform); cce.Transform(); DeadCode.Eliminate(proc, ssa); ValuePropagator vp = new ValuePropagator(program.SegmentMap, ssa, program.CallGraph, importResolver, listener); vp.Transform(); DeadCode.Eliminate(proc, ssa); Coalescer co = new Coalescer(proc, ssa); co.Transform(); ssa.Write(fut); proc.Write(false, fut); fut.WriteLine(); ssa.Validate(s => Assert.Fail(s)); } }
public Scanner( Program program, IImportResolver importResolver, IServiceProvider services) { this.program = program; this.segmentMap = program.SegmentMap; this.importResolver = importResolver; this.eventListener = services.RequireService <DecompilerEventListener>(); this.cancelSvc = services.GetService <CancellationTokenSource>(); if (segmentMap == null) { throw new InvalidOperationException("Program must have an segment map."); } if (program.ImageMap == null) { program.ImageMap = segmentMap.CreateImageMap(); } this.imageMap = program.ImageMap; this.queue = new PriorityQueue <WorkItem>(); this.blocks = new SortedList <Address, BlockRange>(); this.blockStarts = new Dictionary <Block, Address>(); this.pseudoProcs = program.PseudoProcedures; this.importReferences = program.ImportReferences; this.visitedProcs = new HashSet <Procedure>(); }
public SparseValuePropagation(SsaState ssa, Program program, IImportResolver resolver, DecompilerEventListener listener) { this.ssa = ssa; this.listener = listener; this.cmp = new ExpressionValueComparer(); this.ctx = new SparseEvaluationContext(ssa.Procedure.Architecture); this.eval = new Evaluation.ExpressionSimplifier(program.SegmentMap, ctx, listener); }
public override Identifier ResolveImportedGlobal( IImportResolver resolver, IPlatform platform, AddressContext ctx) { var global = resolver.ResolveGlobal(ModuleName, ImportName, platform); return global; }
public void Setup() { ssaIds = new SsaIdentifierCollection(); mr = new MockRepository(); arch = mr.Stub <IProcessorArchitecture>(); importResolver = mr.Stub <IImportResolver>(); listener = new FakeDecompilerEventListener(); }
public void Setup() { mr = new MockRepository(); arch = mr.Stub <IProcessorArchitecture>(); importResolver = mr.Stub <IImportResolver>(); listener = new FakeDecompilerEventListener(); m = new SsaProcedureBuilder(); }
public Scanner(Program program, IImportResolver importResolver, IServiceProvider services) : base(program, importResolver, services) { this.sr = new ScanResults { KnownProcedures = program.User.Procedures.Keys.ToHashSet(), KnownAddresses = program.ImageSymbols.ToDictionary(de => de.Key, de => de.Value), ICFG = new DiGraph <RtlBlock>(), }; }
public SsaEvaluationContext( IProcessorArchitecture arch, SsaIdentifierCollection ssaIds, IImportResolver importResolver) { this.arch = arch; this.ssaIds = ssaIds; this.importResolver = importResolver; }
/// <summary> /// Constructs an SsaTransform, and in the process generates the SsaState for the procedure <paramref>proc</paramref>. /// </summary> /// <param name="proc"></param> /// <param name="gr"></param> public SsaTransform(ProgramDataFlow programFlow, Procedure proc, IImportResolver importResolver, DominatorGraph <Block> gr) { this.programFlow = programFlow; this.proc = proc; this.importResolver = importResolver; this.SsaState = new SsaState(proc, gr); this.AOrig = CreateA(); Transform(); }
public void Setup() { mr = new MockRepository(); fakeArch = new FakeArchitecture(); importResolver = mr.StrictMock<IImportResolver>(); callSigs = new Dictionary<Address, ProcedureSignature>(); arch = fakeArch; var r1 = arch.GetRegister(1); reg1 = new Identifier(r1.Name, PrimitiveType.Word32, r1); }
public object Create(IImportResolver dll) { var ret = Activator.CreateInstance(ImplType); foreach (var f in Hooks) { f(ret, dll); } return(ret); }
public static IntPtr SafeResolve(this IImportResolver dll, string entryPoint) { var ret = dll.Resolve(entryPoint); if (ret == IntPtr.Zero) { throw new NullReferenceException(string.Format("Couldn't resolve entry point \"{0}\"", entryPoint)); } return(ret); }
public Trap(int index) { _index = index; _resolver = BizExvoker.GetExvoker(this, CallingConventionAdapters.Waterbox); if (!SyscallNames.TryGetValue(_index, out var name)) { name = "???"; } _message = $"Trapped on unimplemented syscall {name} (#{_index})"; }
public override ExternalProcedure ResolveImportedProcedure(IImportResolver resolver, IPlatform platform, AddressContext ctx) { var ep = resolver.ResolveProcedure(ModuleName, Ordinal, platform); if (ep != null) { return(ep); } ctx.Warn("Unable to resolve imported reference {0}.", this); return(new ExternalProcedure(this.ToString(), null)); }
public override Expression ResolveImport(IImportResolver importResolver, IPlatform platform, AddressContext ctx) { var imp = importResolver.ResolveImport(ModuleName, Ordinal, platform); if (imp != null) { return(imp); } ctx.Warn("Unable to resolve imported reference {0}.", this); return(null); }
public void Setup() { mr = new MockRepository(); fakeArch = new FakeArchitecture(); importResolver = mr.StrictMock <IImportResolver>(); callSigs = new Dictionary <Address, ProcedureSignature>(); arch = fakeArch; var r1 = arch.GetRegister(1); reg1 = new Identifier(r1.Name, PrimitiveType.Word32, r1); }
/// <summary> /// Constructs an SsaTransform, and in the process generates the SsaState for the procedure <paramref>proc</paramref>. /// </summary> /// <param name="proc"></param> /// <param name="gr"></param> public SsaTransform(ProgramDataFlow programFlow, Procedure proc, IImportResolver importResolver, DominatorGraph <Block> gr, HashSet <RegisterStorage> implicitRegs) { this.programFlow = programFlow; this.proc = proc; this.importResolver = importResolver; this.implicitRegs = implicitRegs; this.SsaState = new SsaState(proc, gr); this.AOrig = CreateA(); Transform(); }
public LinkInterop(NeoGeoPort core, BlockingCollection <LinkRequest> push, BlockingCollection <LinkResult> pull) { _core = core; _push = push; _pull = pull; _exporter = BizExvoker.GetExvoker(this, CallingConventionAdapters.Waterbox); _readcb = _exporter.SafeResolve("CommsReadCallback"); _pollcb = _exporter.SafeResolve("CommsPollCallback"); _writecb = _exporter.SafeResolve("CommsWriteCallback"); ConnectPointers(); }
public object Create(IImportResolver dll, IMonitor monitor) { var ret = Activator.CreateInstance(ImplType); foreach (var f in Hooks) { f(ret, dll); } ConnectMonitor?.Invoke(ret, monitor); return(ret); }
public object Create(IImportResolver dll, IMonitor monitor, ICallingConventionAdapter adapter) { var ret = Activator.CreateInstance(ImplType); ConnectCallingConventionAdapter(ret, adapter); foreach (var f in Hooks) { f(ret, dll, adapter); } ConnectMonitor?.Invoke(ret, monitor); return(ret); }
public void Setup() { mr = new MockRepository(); fakeArch = new FakeArchitecture(); importResolver = mr.StrictMock<IImportResolver>(); callSigs = new Dictionary<Address, ProcedureSignature>(); arch = fakeArch; var r1 = arch.GetRegister(1); reg1 = new Identifier(r1.Name, PrimitiveType.Word32, r1); this.sc = new ServiceContainer(); sc.AddService<DecompilerHost>(new FakeDecompilerHost()); sc.AddService<DecompilerEventListener>(new FakeDecompilerEventListener()); sc.AddService<IFileSystemService>(new FileSystemServiceImpl()); }
public override ExternalProcedure ResolveImportedProcedure( IImportResolver resolver, IPlatform platform, AddressContext ctx) { var ep = resolver.ResolveProcedure(ModuleName, ImportName, platform); if (ep != null) return ep; // Can we guess at the signature? ep = platform.SignatureFromName(ImportName); if (ep != null) return ep; ctx.Warn("Unable to resolve imported reference {0}.", this); return new ExternalProcedure(this.ToString(), null); }
public Scanner( Program program, IImportResolver importResolver, IServiceProvider services) { this.program = program; this.segmentMap = program.SegmentMap; this.importResolver = importResolver; this.Services = services; this.eventListener = services.RequireService<DecompilerEventListener>(); this.cancelSvc = services.GetService<CancellationTokenSource>(); if (segmentMap == null) throw new InvalidOperationException("Program must have an segment map."); if (program.ImageMap == null) { program.ImageMap = segmentMap.CreateImageMap(); } this.imageMap = program.ImageMap; this.queue = new PriorityQueue<WorkItem>(); this.blocks = new SortedList<Address, BlockRange>(); this.blockStarts = new Dictionary<Block, Address>(); this.pseudoProcs = program.PseudoProcedures; this.importReferences = program.ImportReferences; this.visitedProcs = new HashSet<Procedure>(); this.noDecompiledProcs = new Dictionary<Address, Procedure_v1>(); }
public abstract ExternalProcedure ResolveImportedProcedure(IImportResolver importResolver, IPlatform platform, AddressContext ctx);
public TestScanner(Program prog, IImportResolver importResolver, IServiceProvider services) : base(prog, importResolver, services) { }
public override ExternalProcedure ResolveImportedProcedure(IImportResolver resolver, IPlatform platform, AddressContext ctx) { var ep = resolver.ResolveProcedure(ModuleName, Ordinal, platform); if (ep != null) return ep; ctx.Warn("Unable to resolve imported reference {0}.", this); return new ExternalProcedure(this.ToString(), null); }
public abstract Identifier ResolveImportedGlobal(IImportResolver importResolver, IPlatform platform, AddressContext ctx);
public override Identifier ResolveImportedGlobal(IImportResolver importResolver, IPlatform platform, AddressContext ctx) { ctx.Warn("Ordinal global imports not supported. Please report this message to the Reko maintainers (https://github.com/uxmal/reko)."); return null; }
public Scanner( Program program, IDictionary<Address, ProcedureSignature> callSigs, IImportResolver importResolver, DecompilerEventListener eventListener) { this.program = program; this.image = program.Image; this.imageMap = program.ImageMap; this.importResolver = importResolver; this.callSigs = callSigs; this.eventListener = eventListener; if (imageMap == null) throw new InvalidOperationException("Program must have an image map."); this.queue = new PriorityQueue<WorkItem>(); this.blocks = new Map<Address, BlockRange>(); this.blockStarts = new Dictionary<Block, Address>(); this.pseudoProcs = program.PseudoProcedures; this.vectors = program.Vectors; this.importReferences = program.ImportReferences; this.visitedProcs = new HashSet<Procedure>(); }
public TestScanner(Program prog, IDictionary<Address, ProcedureSignature> callSigs, IImportResolver importResolver) : base(prog, callSigs, importResolver, new FakeDecompilerEventListener()) { }
public Scanner( Program program, IDictionary<Address, ProcedureSignature> callSigs, IImportResolver importResolver, IServiceProvider services) { this.program = program; this.image = program.Image; this.imageMap = program.ImageMap; this.importResolver = importResolver; this.callSigs = callSigs; this.eventListener = services.RequireService<DecompilerEventListener>(); this.cancelSvc = services.GetService<CancellationTokenSource>(); if (imageMap == null) throw new InvalidOperationException("Program must have an image map."); this.queue = new PriorityQueue<WorkItem>(); this.blocks = new Map<Address, BlockRange>(); this.blockStarts = new Dictionary<Block, Address>(); this.pseudoProcs = program.PseudoProcedures; this.importReferences = program.ImportReferences; this.visitedProcs = new HashSet<Procedure>(); }
public TestScanner(Program prog, IDictionary<Address, ProcedureSignature> callSigs, IImportResolver importResolver, IServiceProvider services) : base(prog, callSigs, importResolver, services) { }