private void ParseExports(TypeLibraryDeserializer deserializer)
{
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 ep = ParseSignature(entryName, deserializer);
var svc = new SystemService
{
ModuleName = moduleName,
Name = ep != null ? ep.Name : entryName,
Signature = ep != null ? ep.Signature : null,
};
Debug.Print("Loaded {0} @ {1}", entryName, ordinal);
if (ordinal != -1)
{
svc.SyscallInfo = new SyscallInfo { Vector = ordinal };
deserializer.LoadService(ordinal, svc);
}
deserializer.LoadService(entryName, svc);
}
}
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 ProcessDeclaration(Decl declaration, IPlatform platform, TypeLibraryDeserializer tldser, SymbolTable symbolTable)
{
var types = symbolTable.AddDeclaration(declaration);
var type = types[0];
int? vectorOffset = GetVectorOffset(declaration);
if (vectorOffset.HasValue)
{
var ntde = new NamedDataTypeExtractor(platform, declaration.decl_specs, symbolTable);
foreach (var declarator in declaration.init_declarator_list)
{
var nt = ntde.GetNameAndType(declarator.Declarator);
var ssig = (SerializedSignature)nt.DataType;
if (ssig.ReturnValue != null)
{
ssig.ReturnValue.Kind = ntde.GetArgumentKindFromAttributes(
"returns", declaration.attribute_list);
}
var sser = platform.CreateProcedureSerializer(tldser, platform.DefaultCallingConvention);
var sig = sser.Deserialize(ssig, platform.Architecture.CreateFrame());
SystemServices.Add(
vectorOffset.Value,
new SystemService
{
Name = nt.Name,
SyscallInfo = new SyscallInfo
{
Vector = vectorOffset.Value,
},
Signature = sig,
});
}
}
}
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 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;
}
public void Tlldr_Empty()
{
Given_ArchitectureStub();
mr.ReplayAll();
var tlLdr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
TypeLibrary lib = tlLdr.Load(new SerializedLibrary());
}
private DataType Given_Serialized_Signature(SerializedSignature sSignature)
{
var tldeser = new TypeLibraryDeserializer(
program.Platform,
true,
new TypeLibrary());
return(sSignature.Accept(tldeser));
}
/// <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 ExternalProcedure SignatureFromName(string fnName, TypeLibraryDeserializer loader, IPlatform platform)
{
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), platform.Architecture);
string name = fnName.Substring(1, lastAt - 1);
if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
return CdeclSignature(name, platform.Architecture);
else
return StdcallSignature(name, argBytes, platform.Architecture);
}
else if (fnName[0] == '@')
{
// Win32 prefixes fastcall functions with '@'.
int lastAt = fnName.LastIndexOf('@');
if (lastAt <= 0)
return CdeclSignature(fnName.Substring(1), platform.Architecture);
string name = fnName.Substring(1, lastAt - 1);
if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
return CdeclSignature(name, platform.Architecture);
else
return FastcallSignature(name, argBytes, platform.Architecture);
}
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);
return null;
}
var sproc = field.Type as SerializedSignature;
if (sproc != null)
{
var sser = platform.CreateProcedureSerializer(loader, sproc.Convention);
var sig = sser.Deserialize(sproc, platform.Architecture.CreateFrame()); //$BUGBUG: catch dupes?
return new ExternalProcedure(field.Name, sig)
{
EnclosingType = sproc.EnclosingType
};
}
}
return null;
}
private ExternalProcedure ParseSignature(string entryName, TypeLibraryDeserializer loader)
{
var sProc = SignatureGuesser.SignatureFromName(entryName, platform);
if (sProc == null)
{
return(null);
}
return(loader.LoadExternalProcedure(sProc));
}
public TypeImporter(IPlatform platform, TypeLibraryDeserializer tldser, Dictionary <string, Constant> constants, TypeLibrary typelib)
{
this.tldser = tldser;
this.typelib = typelib;
this.constants = constants;
this.ceval = new ConstantEvaluator(new Dictionary <string, Exp>(), constants);
this.namedTypes = new Dictionary <string, SerializedType>(StringComparer.InvariantCultureIgnoreCase);
this.sizes = new Dictionary <string, int>(StringComparer.InvariantCultureIgnoreCase);
this.sizer = new TypeSizer(platform, namedTypes);
}
public WineSpecFileLoader(IServiceProvider services, ImageLocation imageUri, byte[] bytes)
: base(services, imageUri, bytes)
{
var rdr = new StreamReader(new MemoryStream(bytes));
this.lexer = new Lexer(rdr);
this.tlLoader = null !;
this.platform = null !;
this.moduleName = null !;
}
private void ParseLibrary(TypeLibraryDeserializer lib)
{
if (Peek().Type == TokenType.Id)
{
moduleName = Get().Text.ToUpper();
}
if (PeekAndDiscard(TokenType.BASE))
{
throw new NotImplementedException();
}
}
public WineSpecFileLoader(IServiceProvider services, string filename, byte[] bytes)
: base(services, filename, bytes)
{
this.filename = filename;
var rdr = new StreamReader(new MemoryStream(bytes));
this.lexer = new Lexer(rdr);
this.tlLoader = null !;
this.platform = null !;
this.moduleName = null !;
}
public void Tlldr_Empty()
{
Given_ArchitectureStub();
var tlLdr = new TypeLibraryDeserializer(platform.Object, true, new TypeLibrary());
TypeLibrary lib = tlLdr.Load(new SerializedLibrary());
Assert.AreEqual(0, lib.Types.Count);
Assert.AreEqual(0, lib.Signatures.Count);
Assert.AreEqual(1, lib.Modules.Count, "The blank module is there");
}
public void Tlldr_Empty()
{
Given_ArchitectureStub();
mr.ReplayAll();
var tlLdr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
TypeLibrary lib = tlLdr.Load(new SerializedLibrary());
Assert.AreEqual(0, lib.Types.Count);
Assert.AreEqual(0, lib.Signatures.Count);
Assert.AreEqual(1, lib.Modules.Count, "The blank module is there");
}
public void Dfa2_UserDefinedStackArgs()
{
var arch = new X86ArchitectureFlat32();
var pb = new ProgramBuilder(arch);
var test = pb.Add(
new Procedure_v1
{
CSignature = "void test(int a, int b)"
},
m => {
var sp = m.Register(m.Architecture.StackRegister);
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var fp = m.Frame.FramePointer;
m.Assign(r1, m.LoadDw(m.IAdd(fp, 4)));
m.Assign(r2, m.LoadDw(m.IAdd(fp, 8)));
m.Assign(r1, m.IAdd(r1, r2));
m.Store(m.Word32(0x010008), r1);
m.Return();
});
var program = pb.BuildProgram();
var platform = new FakePlatform(null, arch);
platform.Test_CreateImplicitArgumentRegisters = () =>
new HashSet <RegisterStorage>();
platform.Test_CreateProcedureSerializer = (t, d) =>
{
var typeLoader = new TypeLibraryDeserializer(platform, false, new TypeLibrary());
return(new X86ProcedureSerializer((IntelArchitecture)program.Architecture, typeLoader, ""));
};
var importResolver = MockRepository.GenerateStub <IImportResolver>();
importResolver.Replay();
program.Platform = platform;
var dfa = new DataFlowAnalysis(program, importResolver, new FakeDecompilerEventListener());
dfa.AnalyzeProgram2();
var sExp = @"// test
// Return size: 4
void test(int32 a, int32 b)
test_entry:
// succ: l1
l1:
word32 r1_7 = a + b
Mem8[0x00010008:word32] = r1_7
return
// succ: test_exit
test_exit:
";
AssertProgram(sExp, pb.Program);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var parser = platform.CreateCParser(rdr);
var symbolTable = new SymbolTable(platform, 4);
var declarations = parser.Parse();
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
foreach (var decl in declarations)
{
ProcessDeclaration(decl, platform, tldser, symbolTable);
}
return(dstLib);
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var lexer = new PascalLexer(rdr, false); // It seems MPW pascal doesn't allow nesting comments.
var parser = new PascalParser(lexer);
var symbolTable = new SymbolTable(platform);
var declarations = parser.Parse();
var tldser = new TypeLibraryDeserializer(platform, true, dstLib);
var constants = EvaluateConstants(declarations);
var typeImporter = new TypeImporter(platform, tldser, constants, dstLib);
typeImporter.LoadTypes(declarations);
LoadServices(declarations, typeImporter, constants, platform, dstLib);
return(dstLib);
}
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;
}
public override TypeLibrary Load(IPlatform platform, TypeLibrary dstLib)
{
var rdr = new StreamReader(new MemoryStream(bytes));
var lexer = new CLexer(rdr, CLexer.StdKeywords);
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);
}
public void Tlldr_typedef_int()
{
Given_ArchitectureStub();
mr.ReplayAll();
var tlLdr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
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 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 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 (SyscallInfo.StackValues != null)
{
svc.SyscallInfo.StackValues = SyscallInfo.StackValues.Select(sv =>
new StackValue
{
Offset = Convert.ToInt32(sv.Offset, 16),
Value = Convert.ToInt32(sv.Value, 16)
}).ToArray();
}
}
if (svc.SyscallInfo.RegisterValues == null)
{
svc.SyscallInfo.RegisterValues = new RegValue[0];
}
var loader = new TypeLibraryDeserializer(platform, true, library);
var sser = new ProcedureSerializer(platform, loader, "stdapi");
svc.Signature = sser.Deserialize(Signature, platform.Architecture.CreateFrame());
svc.Characteristics = Characteristics != null ? Characteristics : DefaultProcedureCharacteristics.Instance;
return(svc);
}
private void ParseExports(TypeLibraryDeserializer deserializer)
{
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))
{
var num = Get();
switch (num.Type)
{
case TokenType.Number: ordinal = Convert.ToInt32(num.Text); break;
case TokenType.HexNumber: ordinal = Convert.ToInt32(num.Text, 16); break;
default: throw new FormatException("Expected a number after '@'.");
}
PeekAndDiscard(TokenType.NONAME);
}
PeekAndDiscard(TokenType.PRIVATE);
PeekAndDiscard(TokenType.DATA);
var ep = ParseSignature(entryName, deserializer);
var svc = new SystemService
{
ModuleName = moduleName,
Name = ep != null ? ep.Name : entryName,
Signature = ep?.Signature,
};
trace.Verbose("Loaded {0} @ {1}", entryName, ordinal);
if (ordinal != -1)
{
svc.SyscallInfo = new SyscallInfo {
Vector = ordinal
};
deserializer.LoadService(ordinal, svc);
}
deserializer.LoadService(entryName, svc);
}
}
public void SlLookupType()
{
var slib = new SerializedLibrary
{
Types = new SerializedType[]
{
new SerializedTypedef {
Name="int",
DataType=new PrimitiveType_v1 { Domain = Reko.Core.Types.Domain.SignedInt, ByteSize = 4 }
}
}
};
var arch = new X86ArchitectureFlat32();
var platform = new SysVPlatform(null, arch);
var tldser = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
var lib = tldser.Load(slib);
Assert.AreEqual(PrimitiveType.Int32, lib.LookupType("int"));
}
public void Tlldr_signature()
{
Given_ArchitectureStub();
arch.Stub(a => a.GetRegister("r3")).Return(new RegisterStorage("r3", 3, 0, PrimitiveType.Word32));
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.SignedInt, ByteSize = 4
},
Kind = new Register_v1 {
Name = "r3"
}
}
});
Assert.AreEqual("(fn int32 (real32))", fn.ToString());
mr.VerifyAll();
}
public void Tlldr_typedef_int()
{
Given_ArchitectureStub();
var tlLdr = new TypeLibraryDeserializer(platform.Object, true, new TypeLibrary());
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"));
}
private void ProcessDeclaration(Declaration decl, IPlatform platform, TypeLibraryDeserializer tldser, SymbolTable symbolTable)
{
var declaration = decl as CallableDeclaration;
if (declaration == null)
{
return;
}
//int?
//var types = symbolTable.AddDeclaration(declaration);
//var type = types[0];
//int? vectorOffset = GetVectorOffset(declaration);
//if (vectorOffset.HasValue)
//{
// var ntde = new NamedDataTypeExtractor(platform, declaration.decl_specs, symbolTable);
// foreach (var declarator in declaration.init_declarator_list)
// {
// var nt = ntde.GetNameAndType(declarator.Declarator);
// var ssig = (SerializedSignature)nt.DataType;
// if (ssig.ReturnValue != null)
// {
// ssig.ReturnValue.Kind = ntde.GetArgumentKindFromAttributes(
// "returns", declaration.attribute_list);
// }
// var sser = new ProcedureSerializer(platform, tldser, platform.DefaultCallingConvention);
// var sig = sser.Deserialize(ssig, platform.Architecture.CreateFrame());
// SystemServices.Add(
// vectorOffset.Value,
// new SystemService
// {
// Name = nt.Name,
// SyscallInfo = new SyscallInfo
// {
// Vector = vectorOffset.Value,
// },
// Signature = sig,
// });
// }
//}
}
private SystemService ReadImpdef(LeImageReader rdr, TypeLibraryDeserializer loader)
{
if (!rdr.TryReadByte(out byte useOrdinal))
{
return(null);
}
var internalName = ReadString(rdr);
if (internalName == null)
{
return(null);
}
var moduleName = ReadString(rdr);
if (moduleName == null)
{
return(null);
}
if (useOrdinal != 0)
{
if (!rdr.TryReadLeInt16(out var ordinal))
{
return(null);
}
var svc = new SystemService
{
ModuleName = moduleName,
Name = internalName,
SyscallInfo = new SyscallInfo
{
Vector = ordinal
}
};
loader.LoadService(ordinal, svc);
return(svc);
}
else
{
throw new NotImplementedException("non-ordinals");
}
}
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 void SlLookupType()
{
var slib = new SerializedLibrary
{
Types = new SerializedType[]
{
new SerializedTypedef {
Name = "int",
DataType = new PrimitiveType_v1 {
Domain = Reko.Core.Types.Domain.SignedInt, ByteSize = 4
}
}
}
};
var arch = new X86ArchitectureFlat32();
var platform = new SysVPlatform(null, arch);
var tldser = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
var lib = tldser.Load(slib);
Assert.AreEqual(PrimitiveType.Int32, lib.LookupType("int"));
}
private void Given_Program(Address address, byte[] bytes)
{
var mem = new MemoryArea(address, bytes);
var imageMap = new ImageMap(
mem.BaseAddress,
new ImageSegment("proggie", mem, AccessMode.ReadExecute));
var arch = new X86ArchitectureFlat32();
var platform = new FakePlatform(null, arch);
this.program = new Program
{
Architecture = arch,
ImageMap = imageMap,
Platform = platform
};
platform.Test_CreateProcedureSerializer = (t, d) =>
{
var typeLoader = new TypeLibraryDeserializer(platform, false, new TypeLibrary());
return(new X86ProcedureSerializer((IntelArchitecture)program.Architecture, typeLoader, ""));
};
}
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 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 Win32_SignatureFromName_stdcall()
{
Given_TypeLibraryLoaderService();
Given_Configuration_With_Win32_Element();
var fnName = "_foo@4";
When_Creating_Win32_Platform();
var sProc = win32.SignatureFromName(fnName);
var loader = new TypeLibraryDeserializer(
win32,
false,
new TypeLibrary());
var ep = loader.LoadExternalProcedure(sProc);
var sigExp =
@"define foo
// stackDelta: 8; fpuStackDelta: 0; fpuMaxParam: -1
";
Assert.AreEqual(sigExp, ep.Signature.ToString("foo", FunctionType.EmitFlags.AllDetails));
}
private void ParseExports(TypeLibraryDeserializer deserializer)
{
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 ep = ParseSignature(entryName, deserializer);
var svc = new SystemService
{
ModuleName = moduleName,
Name = ep != null ? ep.Name : entryName,
Signature = ep?.Signature,
};
trace.Verbose("Loaded {0} @ {1}", entryName, ordinal);
if (ordinal != -1)
{
svc.SyscallInfo = new SyscallInfo {
Vector = ordinal
};
deserializer.LoadService(ordinal, svc);
}
deserializer.LoadService(entryName, svc);
}
}
public void Tlldr_typedef_empty_enum()
{
Given_ArchitectureStub();
var tlLdr = new TypeLibraryDeserializer(platform.Object, true, new TypeLibrary());
var slib = new SerializedLibrary
{
Types = new SerializedType[]
{
new SerializedTypedef
{
Name = "empty_enum",
DataType = new SerializedEnumType
{
Name = "empty",
Size = 4,
}
}
}
};
var lib = tlLdr.Load(slib);
Assert.AreEqual("(enum empty,())", lib.LookupType("empty_enum").ToString());
}
public void Tlldr_LoadGlobalByOrdinal()
{
var typelib = new TypeLibrary();
var tlldr = new TypeLibraryDeserializer(platform, true, typelib);
tlldr.Load(new SerializedLibrary
{
ModuleName = "stdlib",
Globals = new List <GlobalVariable_v1>
{
new GlobalVariable_v1
{
Name = "errno",
Ordinal = 42,
Type = PrimitiveType_v1.Int32(),
}
}
});
var stdlib = typelib.Modules["stdlib"];
var globalByName = stdlib.GlobalsByName["errno"];
var globalByOrdinal = stdlib.GlobalsByOrdinal[42];
Assert.AreSame(globalByName, globalByOrdinal);
}
private Dictionary <Address, ExternalProcedure> LoadPlatformProcedures(Platform platform)
{
if (platform.MemoryMap != null && platform.MemoryMap.Segments != null)
{
platform.EnsureTypeLibraries(platform.Name);
var tser = new TypeLibraryDeserializer(platform, true, platform.Metadata);
var sser = new ProcedureSerializer(platform, tser, platform.DefaultCallingConvention);
return(platform.MemoryMap.Segments.SelectMany(s => s.Procedures)
.OfType <Procedure_v1>()
.Where(p => p.Name != null)
.Select(p =>
(addr: platform.Architecture.TryParseAddress(p.Address, out var addr) ? addr : null,
ext: new ExternalProcedure(
p.Name !,
sser.Deserialize(p.Signature, platform.Architecture.CreateFrame())
?? new Types.FunctionType())))
.Where(p => p.addr != null)
.ToDictionary(p => p.addr !, p => p.ext));
}
else
{
return(new Dictionary <Address, ExternalProcedure>());
}
}
private void ParseLibrary(TypeLibraryDeserializer lib)
{
if (Peek().Type == TokenType.Id)
{
moduleName = Get().Text.ToUpper();
}
if (PeekAndDiscard(TokenType.BASE))
{
throw new NotImplementedException();
}
}
private void Given_TypeImporter()
{
var tldser = new TypeLibraryDeserializer(platform.Object, false, typelib);
this.typeimporter = new TypeImporter(platform.Object, tldser, new Dictionary <string, Constant>(), typelib);
}
public void Dfa2_UserDefinedStackArgs()
{
var arch = new X86ArchitectureFlat32();
var pb = new ProgramBuilder(arch);
var test = pb.Add(
new Procedure_v1
{
CSignature = "void test(int a, int b)"
},
m => {
var sp = m.Register(m.Architecture.StackRegister);
var r1 = m.Reg32("r1", 1);
var r2 = m.Reg32("r2", 2);
var fp = m.Frame.FramePointer;
m.Assign(r1, m.LoadDw(m.IAdd(fp, 4)));
m.Assign(r2, m.LoadDw(m.IAdd(fp, 8)));
m.Assign(r1, m.IAdd(r1, r2));
m.Store(m.Word32(0x010008), r1);
m.Return();
});
var program = pb.BuildProgram();
var platform = new FakePlatform(null, arch);
platform.Test_CreateProcedureSerializer = (t, d) =>
{
var typeLoader = new TypeLibraryDeserializer(platform, false, new TypeLibrary());
return new X86ProcedureSerializer((IntelArchitecture)program.Architecture, typeLoader, "");
};
program.Platform = platform;
var dfa = new DataFlowAnalysis(program, new FakeDecompilerEventListener());
dfa.AnalyzeProgram2();
var sExp = @"// test
// Return size: 4
void test(int32 a, int32 b)
test_entry:
// succ: l1
l1:
word32 r1_4 = a + b
Mem5[0x00010008:word32] = r1_4
return
// succ: test_exit
test_exit:
";
AssertProgram(sExp, pb.Program);
}
public void Tlldr_BothOrdinalAndName()
{
Given_ArchitectureStub();
mr.ReplayAll();
var tlLDr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
var slib = new SerializedLibrary {
Procedures = {
new SerializedService {
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.Modules[""].ServicesByVector.Count);
Assert.IsNotNull(lib.Modules[""].ServicesByVector[2]);
}
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 static Tuple <string, DataType, SerializedType> InferTypeFromName(string fnName, TypeLibraryDeserializer loader, IPlatform platform)
{
if (fnName[0] == '?')
{
// Microsoft-mangled signatures begin with '?'
var pmnp = new MsMangledNameParser(fnName);
Tuple <string, SerializedType, SerializedType> field = null;
try
{
field = pmnp.Parse();
}
catch (Exception ex)
{
Debug.Print("*** Error parsing {0}. {1}", fnName, ex.Message);
return(null);
}
var sproc = field.Item2 as SerializedSignature;
if (sproc != null)
{
var sser = platform.CreateProcedureSerializer(loader, sproc.Convention);
var sig = sser.Deserialize(sproc, platform.Architecture.CreateFrame()); //$BUGBUG: catch dupes?
return(new Tuple <string, DataType, SerializedType>(
field.Item1,
sig,
field.Item3));
}
else
{
var dt = (field.Item2 == null) ?
new UnknownType() :
field.Item2.Accept(loader);
return(Tuple.Create(field.Item1, dt, field.Item3));
}
}
return(null);
}
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 void Tlldr_void_fn()
{
Given_ArchitectureStub();
mr.ReplayAll();
var tlLdr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
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"));
}
private void Given_Program(Address address, byte[] bytes)
{
var mem = new MemoryArea(address, bytes);
var segmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment("proggie", mem, AccessMode.ReadExecute));
var arch = new X86ArchitectureFlat32();
var platform = new FakePlatform(null, arch);
this.program = new Program
{
Architecture = arch,
SegmentMap = segmentMap,
Platform = platform
};
platform.Test_CreateProcedureSerializer = (t, d) =>
{
var typeLoader = new TypeLibraryDeserializer(platform, false, new TypeLibrary());
return new X86ProcedureSerializer((IntelArchitecture)program.Architecture, typeLoader, "");
};
}
private DataType Given_Serialized_Signature(SerializedSignature sSignature)
{
var tldeser = new TypeLibraryDeserializer(
program.Platform,
true,
new TypeLibrary());
return sSignature.Accept(tldeser);
}
public ProcedureSerializer CreateProcedureSerializer()
{
var typeLoader = new TypeLibraryDeserializer(Platform, true, Metadata.Clone());
return Platform.CreateProcedureSerializer(typeLoader, Platform.DefaultCallingConvention);
}
private ExternalProcedure ParseSignature(string entryName, TypeLibraryDeserializer loader)
{
return SignatureGuesser.SignatureFromName(entryName, loader, platform);
}
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 override ExternalProcedure SignatureFromName(string fnName)
{
StructField_v1 field = null;
try
{
var gcc = new GccMangledNameParser(fnName, this.PointerType.Size);
field = gcc.Parse();
}
catch (Exception ex)
{
Debug.Print("*** Error parsing {0}. {1}", fnName, ex.Message);
return null;
}
if (field == null)
return null;
var sproc = field.Type as SerializedSignature;
if (sproc != null)
{
var loader = new TypeLibraryDeserializer(this, false, Metadata);
var sser = this.CreateProcedureSerializer(loader, sproc.Convention);
var sig = sser.Deserialize(sproc, this.Architecture.CreateFrame()); //$BUGBUG: catch dupes?
return new ExternalProcedure(field.Name, sig)
{
EnclosingType = sproc.EnclosingType
};
}
return null;
}
/// <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 ExternalProcedure SignatureFromName(string fnName, TypeLibraryDeserializer loader, IPlatform platform)
{
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), platform.Architecture));
}
string name = fnName.Substring(1, lastAt - 1);
if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
{
return(CdeclSignature(name, platform.Architecture));
}
else
{
return(StdcallSignature(name, argBytes, platform.Architecture));
}
}
else if (fnName[0] == '@')
{
// Win32 prefixes fastcall functions with '@'.
int lastAt = fnName.LastIndexOf('@');
if (lastAt <= 0)
{
return(CdeclSignature(fnName.Substring(1), platform.Architecture));
}
string name = fnName.Substring(1, lastAt - 1);
if (!Int32.TryParse(fnName.Substring(lastAt + 1), out argBytes))
{
return(CdeclSignature(name, platform.Architecture));
}
else
{
return(FastcallSignature(name, argBytes, platform.Architecture));
}
}
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);
return(null);
}
var sproc = field.Type as SerializedSignature;
if (sproc != null)
{
var sser = platform.CreateProcedureSerializer(loader, sproc.Convention);
var sig = sser.Deserialize(sproc, platform.Architecture.CreateFrame()); //$BUGBUG: catch dupes?
return(new ExternalProcedure(field.Name, sig)
{
EnclosingType = sproc.EnclosingType
});
}
}
return(null);
}
public void Tlldr_typedef_ptr_int()
{
Given_ArchitectureStub();
Given_Arch_PointerDataType(PrimitiveType.Pointer32);
mr.ReplayAll();
var tlLdr = new TypeLibraryDeserializer(platform, true, new TypeLibrary());
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());
}
private ExternalProcedure ParseSignature(string entryName, TypeLibraryDeserializer loader)
{
return(SignatureGuesser.SignatureFromName(entryName, loader, platform));
}