public SystemService Build(IProcessorArchitecture arch) { SystemService svc = new SystemService(); svc.Name = Name; svc.SyscallInfo = new SyscallInfo(); svc.SyscallInfo.Vector = Convert.ToInt32(SyscallInfo.Vector, 16); 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 = arch.GetRegister(SyscallInfo.RegisterValues[i].Register), Value = Convert.ToInt32(SyscallInfo.RegisterValues[i].Value, 16), }; } } else { svc.SyscallInfo.RegisterValues = new RegValue[0]; } TypeLibraryLoader loader = new TypeLibraryLoader(arch, true); ProcedureSerializer sser = arch.CreateProcedureSerializer(loader, "stdapi"); svc.Signature = sser.Deserialize(Signature, arch.CreateFrame()); svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance; return svc; }
public static TypeLibrary Load(Platform platform, SerializedLibrary slib) { var tlldr = new TypeLibraryLoader(platform, true); var tlib = tlldr.Load(slib); return(tlib); }
private void ParseExports(TypeLibraryLoader lib) { while (Peek().Type == TokenType.Id) { string entryName = Expect(TokenType.Id); string internalName = null; if (PeekAndDiscard(TokenType.Eq)) { internalName = Expect(TokenType.Id); } int ordinal = -1; if (PeekAndDiscard(TokenType.At)) { ordinal = Convert.ToInt32(Expect(TokenType.Number)); PeekAndDiscard(TokenType.NONAME); } PeekAndDiscard(TokenType.PRIVATE); PeekAndDiscard(TokenType.DATA); var svc = new SystemService { Name = entryName, Signature = ParseSignature(entryName, lib), }; Debug.Print("Loaded {0} @ {1}", entryName, ordinal); if (ordinal != -1) { svc.SyscallInfo = new SyscallInfo { Vector = ordinal }; lib.LoadService(ordinal, svc); } lib.LoadService(entryName, svc); } }
public static TypeLibrary Load(IProcessorArchitecture arch, SerializedLibrary slib) { var tlldr = new TypeLibraryLoader(arch, true); var tlib = tlldr.Load(slib); return(tlib); }
public void Tlldr_Empty() { Given_ArchitectureStub(); mr.ReplayAll(); var tlLdr = new TypeLibraryLoader(arch, true); TypeLibrary lib = tlLdr.Load(new SerializedLibrary()); }
/// <summary> /// Guesses the signature of a procedure based on its name. /// </summary> /// <param name="fnName"></param> /// <param name="loader"></param> /// <param name="arch"></param> /// <returns></returns> public static ProcedureSignature SignatureFromName(string fnName, TypeLibraryLoader loader, IProcessorArchitecture arch) { int argBytes; if (fnName[0] == '_') { // Win32 prefixes cdecl and stdcall functions with '_'. Stdcalls will have @<nn> // where <nn> is the number of bytes pushed on the stack. If 0 bytes are pushed // the result is indistinguishable from the corresponding cdecl call, which is OK. int lastAt = fnName.LastIndexOf('@'); if (lastAt < 0) return CdeclSignature(fnName.Substring(1), arch); string name = fnName.Substring(1, lastAt - 1); if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes)) return CdeclSignature(name, arch); else return StdcallSignature(name, argBytes, arch); } else if (fnName[0] == '@') { // Win32 prefixes fastcall functions with '@'. int lastAt = fnName.LastIndexOf('@'); if (lastAt <= 0) return CdeclSignature(fnName.Substring(1), arch); string name = fnName.Substring(1, lastAt - 1); if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes)) return CdeclSignature(name, arch); else return FastcallSignature(name, argBytes, arch); } else if (fnName[0] == '?') { // Microsoft-mangled signatures begin with '?' var pmnp = new MsMangledNameParser(fnName); StructField_v1 field = null; try { field = pmnp.Parse(); } catch (Exception ex) { Debug.Print("*** Error parsing {0}. {1}", fnName, ex.Message); pmnp.ToString(); return null; } var sproc = field.Type as SerializedSignature; if (sproc != null) { var sser = arch.CreateProcedureSerializer(loader, "__cdecl"); return sser.Deserialize(sproc, arch.CreateFrame()); //$BUGBUG: catch dupes? } } return null; }
public void Tlldr_typedef_int() { Given_ArchitectureStub(); mr.ReplayAll(); var tlLdr = new TypeLibraryLoader(arch, true); var slib = new SerializedLibrary { Types = new SerializedType[] { new SerializedTypedef { Name="int", DataType=new PrimitiveType_v1 { Domain = Domain.SignedInt, ByteSize=4 }} } }; var lib = tlLdr.Load(slib); Assert.AreSame(PrimitiveType.Int32, lib.LookupType("int")); }
public override TypeLibrary Load() { var loader = new TypeLibraryLoader(arch, true); loader.SetModuleName(DefaultModuleName(filename)); for (; ; ) { var tok = Get(); switch (tok.Type) { case TokenType.EOF: return loader.BuildLibrary(); 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 Tlldr_bothordinalandname() { Given_ArchitectureStub(); mr.ReplayAll(); var tlLDr = new TypeLibraryLoader(platform, true); var slib = new SerializedLibrary { Procedures = { new Procedure_v1 { Name="foo", Ordinal=2, Signature = new SerializedSignature { ReturnValue = new Argument_v1 { Type = new VoidType_v1() } } } } }; var lib = tlLDr.Load(slib); mr.VerifyAll(); Assert.AreEqual(1, lib.ServicesByVector.Count); Assert.IsNotNull(lib.ServicesByVector[2]); }
private ProcedureSignature ParseSignature(string entryName, TypeLibraryLoader loader) { return SignatureGuesser.SignatureFromName(entryName, loader, platform); }
public TypeLibrary Load(Platform platform, string module) { this.platform = platform; this.tlLoader = new TypeLibraryLoader(platform, true); tlLoader.SetModuleName(module); for (;;) { var tok = Peek(); if (tok.Type == TokenType.EOF) break; if (PeekAndDiscard(TokenType.NL)) continue; ParseLine(); } return tlLoader.BuildLibrary(); }
private void ParseLibrary(TypeLibraryLoader lib) { if (Peek().Type == TokenType.Id) { lib.SetModuleName(Get().Text); } if (PeekAndDiscard(TokenType.BASE)) { throw new NotImplementedException(); } }
public static TypeLibrary Load(IProcessorArchitecture arch, SerializedLibrary slib) { var tlldr = new TypeLibraryLoader(arch, true); var tlib = tlldr.Load(slib); return tlib; }
public ProcedureSerializer CreateProcedureSerializer() { var typeLoader = new TypeLibraryLoader(this, true); return CreateProcedureSerializer(typeLoader, DefaultCallingConvention); }
public void Tlldr_void_fn() { Given_ArchitectureStub(); mr.ReplayAll(); var tlLdr = new TypeLibraryLoader(arch, true); var slib = new SerializedLibrary { Procedures = { new Procedure_v1 { Name="foo", Signature = new SerializedSignature { Convention="__cdecl", ReturnValue = new Argument_v1 { Type = new VoidType_v1() }, } } } }; var lib = tlLdr.Load(slib); mr.VerifyAll(); Assert.AreEqual( "void foo()", lib.Lookup("foo").ToString("foo")); }
public static TypeLibrary Load(Platform platform, SerializedLibrary slib) { var tlldr = new TypeLibraryLoader(platform, true); var tlib = tlldr.Load(slib); return tlib; }
private void CreateTypeLibraryLoader(string filename, string contents) { this.platform = new Win32Platform(null, new X86ArchitectureFlat32()); tlldr = new TypeLibraryLoader(null, filename, Encoding.ASCII.GetBytes(contents)); }
public void Tlldr_typedef_ptr_int() { Given_ArchitectureStub(); Given_Arch_PointerDataType(PrimitiveType.Pointer32); mr.ReplayAll(); var tlLdr = new TypeLibraryLoader(arch, true); var slib = new SerializedLibrary { Types = new SerializedType[] { new SerializedTypedef { Name="pint", DataType= new PointerType_v1 { DataType = new PrimitiveType_v1 { Domain = Domain.SignedInt, ByteSize=4 } } } } }; var lib = tlLdr.Load(slib); Assert.AreEqual("(ptr int32)", lib.LookupType("pint").ToString()); }
public ProcedureSerializer CreateProcedureSerializer() { var typeLoader = new TypeLibraryLoader(this, true); return(CreateProcedureSerializer(typeLoader, DefaultCallingConvention)); }