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