public TypeLibrary Load(IPlatform platform, string module, TypeLibrary dstLib)
{
this.platform = platform;
this.tlLoader = new TypeLibraryDeserializer(platform, true, dstLib);
this.moduleName = module;
tlLoader.SetModuleName(module);
for (;;)
{
var tok = Peek();
if (tok.Type == TokenType.EOF)
break;
if (PeekAndDiscard(TokenType.NL))
continue;
var line = ParseLine();
if (line != null)
{
if (line.Item1.HasValue)
{
tlLoader.LoadService(line.Item1.Value, line.Item2);
}
else
{
tlLoader.LoadService(line.Item2.Name, line.Item2);
}
}
}
return dstLib;
}
public void Prld_LoadMetadata_SingleBinary_ShouldNotQuery()
{
var ldr = mr.Stub<ILoader>();
var oracle = mr.StrictMock<IOracleService>();
var arch = mr.Stub<IProcessorArchitecture>();
var platform = mr.Stub<Platform>(this.sc, arch);
var typelibrary = new TypeLibrary();
Given_Binary(ldr, platform);
ldr.Stub(l => l.LoadMetadata(Arg<string>.Is.NotNull, Arg<Platform>.Is.Same(platform))).Return(typelibrary);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
prld.LoadProject(new Project_v2
{
Inputs = {
new DecompilerInput_v2 {
Filename = "foo.exe",
},
new MetadataFile_v2 {
Filename = "foo",
}
}
});
mr.VerifyAll();
}
public SystemService Build(IPlatform platform, TypeLibrary library)
{
SystemService svc = new SystemService();
svc.Name = Name;
svc.SyscallInfo = new SyscallInfo();
svc.SyscallInfo.Vector = SyscallInfo != null
? Convert.ToInt32(SyscallInfo.Vector, 16)
: this.Ordinal;
if (SyscallInfo != null)
{
if (SyscallInfo.RegisterValues != null)
{
svc.SyscallInfo.RegisterValues = new RegValue[SyscallInfo.RegisterValues.Length];
for (int i = 0; i < SyscallInfo.RegisterValues.Length; ++i)
{
svc.SyscallInfo.RegisterValues[i] = new RegValue
{
Register = platform.Architecture.GetRegister(SyscallInfo.RegisterValues[i].Register),
Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16),
};
}
}
}
if (svc.SyscallInfo.RegisterValues == null)
{
svc.SyscallInfo.RegisterValues = new RegValue[0];
}
TypeLibraryDeserializer loader = new TypeLibraryDeserializer(platform, true, library);
var sser = platform.CreateProcedureSerializer(loader, "stdapi");
svc.Signature = sser.Deserialize(Signature, platform.Architecture.CreateFrame());
svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
return svc;
}
public TypeLibrary Clone()
{
var clone = new TypeLibrary();
clone.Types = new Dictionary<string, DataType>(this.Types);
clone.Signatures = new Dictionary<string, ProcedureSignature>(this.Signatures);
clone.Modules = this.Modules.ToDictionary(k => k.Key, v => v.Value.Clone(), StringComparer.InvariantCultureIgnoreCase);
return clone;
}
private void Expect_TypeLibraryLoaderService_LoadLibrary(string expected, TypeLibrary dstLib)
{
tlSvc.Expect(t => t.LoadLibrary(
Arg<IPlatform>.Is.NotNull,
Arg<string>.Is.Equal(expected),
Arg<TypeLibrary>.Is.NotNull))
.Return(dstLib);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var ser = SerializedLibrary.CreateSerializer();
var slib = (SerializedLibrary) ser.Deserialize(stream);
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
var tlib = tldser.Load(slib);
return tlib;
}
private void Expect_TypeLibraryLoaderService_LoadLibrary(ITypeLibraryElement expected, TypeLibrary dstLib)
{
environmentMetadata = dstLib;
tlSvc.Expect(t => t.LoadMetadataIntoLibrary(
Arg<IPlatform>.Is.NotNull,
Arg<ITypeLibraryElement>.Matches(a => a.Name == expected.Name),
Arg<TypeLibrary>.Is.NotNull))
.Return(dstLib);
}
public TypeLibrary BuildLibrary()
{
var lib = new TypeLibrary(types, signaturesByName);
lib.ModuleName = moduleName;
foreach (var de in servicesByName)
{
lib.ServicesByName.Add(de.Key, de.Value);
}
foreach (var de in servicesByOrdinal)
{
lib.ServicesByVector.Add(de.Key, de.Value);
}
return(lib);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var lexer = new CLexer(rdr);
var state = new ParserState();
var parser = new CParser(state, lexer);
var symbolTable = new SymbolTable(platform);
var declarations = parser.Parse();
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
foreach (var decl in declarations)
{
ProcessDeclaration(decl, platform, tldser, symbolTable);
}
return dstLib;
}
private SymbolTable CreateSymbolTable(
IPlatform platform, TypeLibrary typeLib)
{
var dtSer = new DataTypeSerializer();
var primitiveTypes = PrimitiveType.AllTypes
.ToDictionary(
d => d.Key,
d => (PrimitiveType_v1)d.Value.Accept(dtSer));
var namedTypes = new Dictionary <string, SerializedType>();
var typedefs = typeLib.Types;
foreach (var typedef in typedefs)
{
namedTypes[typedef.Key] = typedef.Value.Accept(dtSer);
}
return(new SymbolTable(platform, primitiveTypes, namedTypes));
}
public TypeLibrary Load(IPlatform platform, string module, TypeLibrary dstLib)
{
this.platform = platform;
this.tlLoader = new TypeLibraryDeserializer(platform, true, dstLib);
this.moduleName = module;
tlLoader.SetModuleName(module);
for (;;)
{
var tok = Peek();
if (tok.Type == TokenType.EOF)
break;
if (PeekAndDiscard(TokenType.NL))
continue;
ParseLine();
}
return dstLib;
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(stream);
var parser = platform.CreateCParser(rdr);
var symbolTable = CreateSymbolTable(platform, dstLib);
var declarations = parser.Parse();
foreach (var decl in declarations)
{
symbolTable.AddDeclaration(decl);
}
var slib = new SerializedLibrary
{
Types = symbolTable.Types.ToArray(),
Procedures = symbolTable.Procedures.ToList(),
};
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
var tlib = tldser.Load(slib);
return(tlib);
}
public void SudLoadMetadata()
{
var sProject = new Project_v2 {
Inputs =
{
new MetadataFile_v2
{
Filename = "c:\\tmp\\foo.def"
}
}
};
var loader = mr.Stub<ILoader>();
var typelib = new TypeLibrary();
loader.Stub(l => l.LoadMetadata("", null)).IgnoreArguments().Return(typelib);
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader);
var project = ploader.LoadProject(sProject);
Assert.AreEqual(1, project.MetadataFiles.Count);
Assert.AreEqual("c:\\tmp\\foo.def", project.MetadataFiles[0].Filename);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
this.platform = platform;
var loader = new TypeLibraryDeserializer(platform, true, dstLib);
this.moduleName = DefaultModuleName(filename);
loader.SetModuleName(moduleName);
for (;;)
{
var tok = Get();
switch (tok.Type)
{
case TokenType.EOF: return dstLib;
case TokenType.EXPORTS: ParseExports(loader); break;
case TokenType.LIBRARY: ParseLibrary(loader); break;
default: throw new NotImplementedException(
string.Format("Unknown token {0} ({1}) on line {2}.",
tok.Type,
tok.Text,
tok.LineNumber));
}
}
}
public void Prld_LoadMetadata_NoPlatform_ShouldQuery()
{
var ldr = mr.Stub<ILoader>();
var oracle = mr.StrictMock<IOracleService>();
var arch = mr.Stub<IProcessorArchitecture>();
var platform = mockFactory.CreatePlatform();
var typeLib = new TypeLibrary();
ldr.Stub(l => l.LoadMetadata(Arg<string>.Is.NotNull, Arg<IPlatform>.Is.Equal(platform), Arg<TypeLibrary>.Is.NotNull)).Return(typeLib);
oracle.Expect(o => o.QueryPlatform(Arg<string>.Is.NotNull)).Return(platform);
sc.AddService<IOracleService>(oracle);
mr.ReplayAll();
var prld = new ProjectLoader(sc, ldr);
prld.LoadProject(new Project_v2
{
Inputs = {
new MetadataFile_v2 {
Filename = "foo",
}
}
});
mr.VerifyAll();
}
/// <summary> /// Loads metadata from the file specified in the constructor. /// </summary> /// <param name="platform"></param> /// <param name="dstLib"></param> /// <returns></returns> public abstract TypeLibrary Load(IPlatform platform, TypeLibrary dstLib);
public void SudLoadMetadata()
{
var sProject = new Project_v2 {
Inputs =
{
new MetadataFile_v2
{
Filename = "c:\\tmp\\foo.def"
}
}
};
var loader = mr.Stub<ILoader>();
var typelib = new TypeLibrary();
loader.Stub(l => l.LoadMetadata("", null, null)).IgnoreArguments().Return(typelib);
var oracle = mr.Stub<IOracleService>();
oracle.Stub(o => o.QueryPlatform(Arg<string>.Is.NotNull)).Return(mockFactory.CreatePlatform());
sc.AddService<IOracleService>(oracle);
mr.ReplayAll();
var ploader = new ProjectLoader(sc, loader);
var project = ploader.LoadProject("c:\\bar\\bar.dcproj", sProject);
Assert.AreEqual(1, project.MetadataFiles.Count);
Assert.AreEqual("c:\\tmp\\foo.def", project.MetadataFiles[0].Filename);
}
private void ApplyCharacteristicsToServices(CharacteristicsLibrary[] characteristicsLibs, TypeLibrary metadata)
{
foreach (var ch in characteristicsLibs.SelectMany(cl => cl.Entries))
{
foreach (var m in metadata.Modules.Values)
{
SystemService svc;
if (m.ServicesByName.TryGetValue(ch.Key, out svc))
{
svc.Characteristics = ch.Value;
}
}
}
}
private void Expect_TypeLibraryLoaderService_LoadLibrary(string expected, IDictionary<string, DataType> types)
{
var tl = new TypeLibrary(
types,
new Dictionary<string, FunctionType>(),
new Dictionary<string, DataType>());
Expect_TypeLibraryLoaderService_LoadLibrary(
new TypeLibraryElement
{
Name = expected,
},
tl);
}
public void Tlldr_signature()
{
Given_ArchitectureStub();
var r3 = new RegisterStorage("r3", 3, 0, PrimitiveType.Word32);
Given_ProcedureSignature(new FunctionType(
new Identifier("", PrimitiveType.Int32, r3),
new[] {
new Identifier("", PrimitiveType.Real32, r3)}
));
mr.ReplayAll();
var typelib = new TypeLibrary();
var tlldr = new TypeLibraryDeserializer(platform, true, typelib);
var fn = tlldr.VisitSignature(new SerializedSignature
{
Arguments = new[]
{
new Argument_v1 {
Name = "reg1",
Type = new PrimitiveType_v1 { Domain =Domain.Real, ByteSize = 4 },
Kind = new Register_v1 { Name = "r3" }
}
},
ReturnValue = new Argument_v1
{
Type = new PrimitiveType_v1 { Domain = Domain.Integer, ByteSize = 4 },
Kind = new Register_v1 { Name = "r3" }
}
});
Assert.AreEqual("(fn int32 (real32))", fn.ToString());
}
public MockFactory(MockRepository mr)
{
this.mr = mr;
this.platformMetadata = new TypeLibrary();
this.programs = new List<Program>();
}
public void CreateLoadMetadataStub(
string metafileName, IPlatform platform, TypeLibrary loaderMetadata
)
{
loader.Stub(l => l.LoadMetadata(
Arg<string>.Is.Equal(metafileName),
Arg<IPlatform>.Is.Equal(platform),
Arg<TypeLibrary>.Is.NotNull
)).Do(new Func<string, IPlatform, TypeLibrary, TypeLibrary>((f, p, tl) =>
{
foreach (var module in loaderMetadata.Modules)
tl.Modules.Add(module);
foreach(var sig in loaderMetadata.Signatures)
tl.Signatures.Add(sig);
foreach (var type in loaderMetadata.Types)
tl.Types.Add(type);
return tl;
}
));
loader.Replay();
}
public Project()
{
Programs = new ObservableRangeCollection <Program>();
MetadataFiles = new ObservableRangeCollection <MetadataFile>();
LoadedMetadata = new TypeLibrary();
}
public TypeLibraryEventArgs(TypeLibrary typelib)
{
this.TypeLibrary = typelib;
}
public virtual TypeLibrary Load(IPlatform platform, string moduleName, TypeLibrary dstLib)
{
return(Load(platform, dstLib));
}
public Project()
{
Programs = new ObservableRangeCollection<Program>();
MetadataFiles = new ObservableRangeCollection<MetadataFile>();
LoadedMetadata = new TypeLibrary();
}
public abstract TypeLibrary Load(IPlatform platform, TypeLibrary dstLib);
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
return Load(platform, DefaultModuleName(filename), dstLib);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
return(dstLib);
}
public void Given_PlatformTypes(Dictionary<string, DataType> types)
{
this.platformMetadata = new TypeLibrary(
types, new Dictionary<string, ProcedureSignature>()
);
}
public void Tlldr_typedef_forwarded_union()
{
Given_ArchitectureStub();
mr.ReplayAll();
var typelib = new TypeLibrary();
var tlldr = new TypeLibraryDeserializer(platform, true, typelib);
new SerializedTypedef
{
Name = "variant_t",
DataType = new UnionType_v1
{
Name = "variant_union",
}
}.Accept(tlldr);
new UnionType_v1
{
Name = "variant_union",
Alternatives = new[]
{
new SerializedUnionAlternative {
Name = "foo",
Type = new PrimitiveType_v1 { Domain = Domain.Integer, ByteSize=4 },
},
new SerializedUnionAlternative {
Name = "bar",
Type = new PrimitiveType_v1 { Domain = Domain.Real, ByteSize=4 }
}
}
}.Accept(tlldr);
var str = (UnionType)typelib.Types["variant_t"];
Assert.AreEqual("(union \"variant_union\" (ui32 foo) (real32 bar))", str.ToString());
}
public void Given_UserDefinedMetafile(
string moduleName, Dictionary<string, DataType> types,
Dictionary<string, ProcedureSignature> signatures,
ModuleDescriptor module)
{
if (types == null)
types = new Dictionary<string, DataType>();
if (signatures == null)
signatures = new Dictionary<string, ProcedureSignature>();
var loaderMetadata = new TypeLibrary(types, signatures);
if (module != null)
loaderMetadata.Modules.Add(moduleName, module);
var loader = CreateLoader();
var metafileName = moduleName+".xml";
CreateLoadMetadataStub(metafileName, platform, loaderMetadata);
foreach(var program in programs)
{
program.LoadMetadataFile(loader, metafileName);
}
}
private void EmitSignature(TypeLibrary lib, string fnName, System.IO.TextWriter tw)
{
lib.Lookup(fnName).Emit(fnName, ProcedureSignature.EmitFlags.ArgumentKind|ProcedureSignature.EmitFlags.LowLevelInfo, tw);
}
public FakePlatform(IServiceProvider services, IProcessorArchitecture arch)
: base(services, arch, "fake")
{
Metadata = new TypeLibrary();
}
public void Tlldr_typedef_forwarded_struct()
{
Given_ArchitectureStub();
mr.ReplayAll();
var typelib = new TypeLibrary();
var tlldr = new TypeLibraryDeserializer(platform, true, typelib);
new SerializedTypedef
{
Name = "_locale_tstruct",
DataType = new SerializedStructType
{
Name = "localeinfo_struct",
}
}.Accept(tlldr);
new SerializedStructType
{
Name = "localeinfo_struct",
Fields = new StructField_v1[]
{
new StructField_v1 {
Name = "foo",
Offset =0,
Type = new PrimitiveType_v1 { Domain = Domain.Integer, ByteSize=4 }
}
}
}.Accept(tlldr);
var str = (StructureType) typelib.Types["_locale_tstruct"];
Assert.AreEqual("(struct \"localeinfo_struct\" (0 ui32 foo))", str.ToString());
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
return dstLib;
}
private Dictionary<int, SystemService> LoadLibraryDef(string lib_name, int version, TypeLibrary libDst)
{
var tlSvc = Services.RequireService<ITypeLibraryLoaderService>();
var fsSvc = Services.RequireService<IFileSystemService>();
var sser = new M68kProcedureSerializer(
(M68kArchitecture)Architecture,
new TypeLibraryDeserializer(this, true, libDst),
DefaultCallingConvention);
using (var rdr = new StreamReader(fsSvc.CreateFileStream(tlSvc.InstalledFileLocation( lib_name + ".funcs"), FileMode.Open, FileAccess.Read)))
{
var fpp = new FuncsFileParser((M68kArchitecture)this.Architecture, rdr);
fpp.Parse();
return fpp.FunctionsByLibBaseOffset.Values
.Select(amiSvc => new SystemService
{
Name = amiSvc.Name,
SyscallInfo = new SyscallInfo
{
Vector = amiSvc.Offset,
},
Signature = sser.Deserialize(amiSvc.Signature, Architecture.CreateFrame()), //$BUGBUG: catch dupes?
Characteristics = new ProcedureCharacteristics { }
})
.ToDictionary(de => de.SyscallInfo.Vector, de => de);
};
}
