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