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