public void Impres_ProcedureByName()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo",
TypeLibrary = new TypeLibrary
{
ServicesByName =
{
{
"bar@4",
new SystemService
{
Name = "bar", Signature= new ProcedureSignature()
}
}
}
}
}
}
};
var impres = new ImportResolver(proj);
var ep = impres.ResolveProcedure("foo", "bar@4", new DefaultPlatform(services, arch));
Assert.AreEqual("bar", ep.Name);
}
protected Program RewriteFile(string relativePath, Address addrBase)
{
sc = new ServiceContainer();
var config = new FakeDecompilerConfiguration();
var eventListener = new FakeDecompilerEventListener();
sc.AddService<IConfigurationService>(config);
sc.AddService<DecompilerHost>(new FakeDecompilerHost());
sc.AddService<DecompilerEventListener>(eventListener);
sc.AddService<IFileSystemService>(new FileSystemServiceImpl());
ILoader ldr = new Loader(sc);
var program = ldr.AssembleExecutable(
FileUnitTester.MapTestPath(relativePath),
new X86TextAssembler(sc, new X86ArchitectureReal()),
addrBase);
program.Platform = new DefaultPlatform(sc, program.Architecture);
var ep = new ImageSymbol(program.SegmentMap.BaseAddress);
var project = new Project { Programs = { program } };
var scan = new Scanner(
program,
new ImportResolver(project, program, eventListener),
sc);
scan.EnqueueImageSymbol(ep, true);
scan.ScanImage();
var importResolver = new ImportResolver(project, program, eventListener);
var dfa = new DataFlowAnalysis(program, importResolver, eventListener);
dfa.AnalyzeProgram();
return program;
}
private void RunTest(string sExp, Action<ProcedureBuilder> builder)
{
var pb = new ProcedureBuilder(this.pb.Program.Architecture);
builder(pb);
var proc = pb.Procedure;
var dg = new DominatorGraph<Block>(proc.ControlGraph, proc.EntryBlock);
var project = new Project
{
Programs = { this.pb.Program }
};
var importResolver = new ImportResolver(
project,
this.pb.Program,
new FakeDecompilerEventListener());
var arch = new FakeArchitecture();
var platform = new FakePlatform(null, arch);
// Register r1 is assumed to always be implicit when calling
// another procedure.
var implicitRegs = new HashSet<RegisterStorage>
{
arch.GetRegister(1)
};
Debug.Print("GetRegister(1) {0}", arch.GetRegister(1));
this.pb.Program.Platform = platform;
this.pb.Program.Platform = new FakePlatform(null, new FakeArchitecture());
this.pb.Program.SegmentMap = new SegmentMap(
Address.Ptr32(0x0000),
new ImageSegment(
".text",
Address.Ptr32(0),
0x40000,
AccessMode.ReadWriteExecute));
// Perform the initial transformation
var ssa = new SsaTransform(programFlow, proc, importResolver, dg, implicitRegs);
// Propagate values and simplify the results.
// We hope the the sequence
// esp = fp - 4
// mov [esp-4],eax
// will become
// esp_2 = fp - 4
// mov [fp - 8],eax
var vp = new ValuePropagator(this.pb.Program.Architecture, ssa.SsaState);
vp.Transform();
ssa.RenameFrameAccesses = true;
ssa.AddUseInstructions = true;
ssa.Transform();
var writer = new StringWriter();
proc.Write(false, writer);
var sActual = writer.ToString();
if (sActual != sExp)
Debug.Print(sActual);
Assert.AreEqual(sExp, sActual);
}
public void Impres_ProcedureByName()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo"
}
},
Programs =
{
program
}
};
var module = new ModuleDescriptor("foo")
{
ServicesByName =
{
{
"bar@4",
new SystemService
{
Name = "bar",
Signature = new FunctionType()
}
}
}
};
program.EnvironmentMetadata.Modules.Add("foo", module);
var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener());
var ep = impres.ResolveProcedure("foo", "bar@4", platform);
Assert.AreEqual("bar", ep.Name);
}
protected void RunHexTest(string hexFile, string outputFile)
{
var svc = new ServiceContainer();
var cfg = new FakeDecompilerConfiguration();
var eventListener = new FakeDecompilerEventListener();
svc.AddService<IConfigurationService>(cfg);
svc.AddService<DecompilerEventListener>(eventListener);
svc.AddService<DecompilerHost>(new FakeDecompilerHost());
ILoader ldr = new Loader(svc);
var imgLoader = new DchexLoader(FileUnitTester.MapTestPath( hexFile), svc, null);
var program = imgLoader.Load(null);
var project = new Project { Programs = { program } };
var ep = new ImageSymbol(program.ImageMap.BaseAddress);
var importResolver = new ImportResolver(project, program, eventListener);
var scan = new Scanner(program, importResolver, svc);
scan.EnqueueImageSymbol(ep, true);
scan.ScanImage();
var dfa = new DataFlowAnalysis(program, null, eventListener);
dfa.AnalyzeProgram();
RunTest(program, outputFile);
}
public void Impres_ProcedureByOrdinal()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo"
}
},
Programs =
{
program
}
};
var module = new ModuleDescriptor("foo")
{
ServicesByVector =
{
{
9,
new SystemService
{
Name = "bar",
Signature = new ProcedureSignature()
}
}
}
};
mockFactory.Given_UserDefinedMetafile("foo", null, null, module);
var impres = new ImportResolver(proj);
var ep = impres.ResolveProcedure("foo", 9, platform);
Assert.AreEqual("bar", ep.Name);
}
public void Impres_ProcedureByName_NoModule()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo"
}
},
Programs =
{
program
}
};
var sigs = new Dictionary<string, ProcedureSignature>();
sigs.Add(
"bar",
new ProcedureSignature(
new Identifier(
"res",
PrimitiveType.Word16,
new RegisterStorage("ax", 0, 0, PrimitiveType.Word16)
),
new Identifier(
"a",
PrimitiveType.Word16,
new RegisterStorage("cx", 0, 0, PrimitiveType.Word16)
),
new Identifier(
"b",
PrimitiveType.Word16,
new RegisterStorage("dx", 0, 0, PrimitiveType.Word16)
)
)
);
mockFactory.Given_UserDefinedMetafile("foo", null, sigs, null);
var impres = new ImportResolver(proj);
var ep = impres.ResolveProcedure("foo", "bar", platform);
Assert.AreEqual("bar", ep.Name);
var sigExp =
@"Register word16 ()(Register word16 a, Register word16 b)
// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1
";
Assert.AreEqual(sigExp, ep.Signature.ToString());
}
///<summary>
/// Determines the signature of the procedures,
/// the locations and types of all the values in the program.
///</summary>
public virtual void AnalyzeDataFlow()
{
var eventListener = services.RequireService<DecompilerEventListener>();
foreach (var program in project.Programs)
{
eventListener.ShowStatus("Performing interprocedural analysis.");
var ir = new ImportResolver(project, program, eventListener);
var dfa = new DataFlowAnalysis(program, ir, eventListener);
dfa.UntangleProcedures();
dfa.BuildExpressionTrees();
host.WriteIntermediateCode(program, writer => { EmitProgram(program, dfa, writer); });
}
eventListener.ShowStatus("Interprocedural analysis complete.");
}
public void Impres_GlobalByName()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo"
}
},
Programs =
{
program
}
};
var module = new ModuleDescriptor("foo")
{
GlobalsByName =
{
{
"bar",
new StructureType
{
Fields =
{
{ 0, new Pointer(PrimitiveType.Char, 4), "name" },
{ 4, PrimitiveType.Int32, "age" }
}
}
}
}
};
program.EnvironmentMetadata.Modules.Add(module.ModuleName, module);
var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener());
var dt = impres.ResolveGlobal("foo", "bar", platform);
Assert.AreEqual("bar", dt.ToString());
}
public void Impres_ProcedureByName_NoModule()
{
var proj = new Project
{
MetadataFiles =
{
new MetadataFile
{
ModuleName = "foo"
}
},
Programs =
{
program
}
};
var barSig = new FunctionType(
new Identifier(
"res",
PrimitiveType.Word16,
new RegisterStorage("ax", 0, 0, PrimitiveType.Word16)
),
new[] {
new Identifier(
"a",
PrimitiveType.Word16,
new RegisterStorage("cx", 0, 0, PrimitiveType.Word16)
),
new Identifier(
"b",
PrimitiveType.Word16,
new RegisterStorage("dx", 0, 0, PrimitiveType.Word16)
)
}
);
program.EnvironmentMetadata.Modules.Add("foo", new ModuleDescriptor("foo")
{
ServicesByName =
{
{ "bar", new SystemService {
Name = "bar",
Signature = barSig }
}
}
});
var impres = new ImportResolver(proj, program, new FakeDecompilerEventListener());
var ep = impres.ResolveProcedure("foo", "bar", platform);
Assert.AreEqual("bar", ep.Name);
var sigExp =
@"Register word16 bar(Register word16 a, Register word16 b)
// stackDelta: 0; fpuStackDelta: 0; fpuMaxParam: -1
";
Assert.AreEqual(sigExp, ep.Signature.ToString("bar", FunctionType.EmitFlags.AllDetails));
}
