public void Build(Program program)
{
// Special case for the global variables. In essence,
// a memory map of all the globals.
var tvGlobals = store.EnsureExpressionTypeVariable(factory, program.Globals, "globals_t");
tvGlobals.OriginalDataType = program.Globals.DataType;
EnsureSegmentTypeVariables(program.SegmentMap.Segments.Values);
int cProc = program.Procedures.Count;
int i = 0;
foreach (Procedure proc in program.Procedures.Values)
{
if (listener.IsCanceled())
{
return;
}
listener.ShowProgress("Gathering primitive datatypes from instructions.", i++, cProc);
this.signature = proc.Signature;
EnsureSignatureTypeVariables(this.signature);
foreach (Statement stm in proc.Statements)
{
stmCur = stm;
stm.Instruction.Accept(this);
}
}
}
public void Setup()
{
mem = new MemoryArea(Address.Ptr32(0x00100000), new byte[1024]);
var arch = new FakeArchitecture();
this.program = new Program
{
Architecture = arch,
SegmentMap = new SegmentMap(
mem.BaseAddress,
new ImageSegment(".text", mem, AccessMode.ReadWriteExecute)),
Platform = new DefaultPlatform(null, arch),
};
store = program.TypeStore;
factory = program.TypeFactory;
globals = program.Globals;
store.EnsureExpressionTypeVariable(factory, globals);
StructureType s = new StructureType(null, 0);
s.Fields.Add(0x00100000, PrimitiveType.Word32, null);
TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals);
EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals);
eqGlobals.DataType = s;
globals.TypeVariable.DataType = new Pointer(eqGlobals, 4);
globals.DataType = globals.TypeVariable.DataType;
}
private Expression CreateTv(Expression e)
{
store.EnsureExpressionTypeVariable(factory, e);
e.TypeVariable.DataType = e.DataType;
e.TypeVariable.OriginalDataType = e.DataType;
return(e);
}
public void Setup()
{
var image = new LoadedImage(Address.Ptr32(0x00100000), new byte[1024]);
var arch = new FakeArchitecture();
var program = new Program
{
Image = image,
Architecture = arch,
ImageMap = image.CreateImageMap(),
Platform = new DefaultPlatform(null, arch),
};
store = program.TypeStore;
factory = program.TypeFactory;
globals = program.Globals;
store.EnsureExpressionTypeVariable(factory, globals);
StructureType s = new StructureType(null, 0);
s.Fields.Add(0x00100000, PrimitiveType.Word32, null);
TypeVariable tvGlobals = store.EnsureExpressionTypeVariable(factory, globals);
EquivalenceClass eqGlobals = new EquivalenceClass(tvGlobals);
eqGlobals.DataType = s;
globals.TypeVariable.DataType = new Pointer(eqGlobals, 4);
globals.DataType = globals.TypeVariable.DataType;
tcr = new TypedConstantRewriter(program);
}
public void Tcr_RewriteWord32()
{
Constant c = Constant.Word32(0x0131230);
store.EnsureExpressionTypeVariable(factory, c);
c.TypeVariable.DataType = PrimitiveType.Word32;
c.TypeVariable.OriginalDataType = PrimitiveType.Word32;
Expression e = tcr.Rewrite(c, false);
Assert.AreEqual("0x00131230", e.ToString());
}
private TypeVariable CreateTv(Expression e, DataType dt, DataType dtOrig)
{
TypeVariable tv = store.EnsureExpressionTypeVariable(factory, e);
tv.DataType = dt;
tv.OriginalDataType = dtOrig;
e.TypeVariable = tv;
if (dt.IsComplex)
{
tv.Class = new EquivalenceClass(tv);
tv.Class.DataType = dt;
}
return(tv);
}
private Expression EnsureTypeVariable(Expression e, DataType dt)
{
var tv = store.EnsureExpressionTypeVariable(factory, 0, e);
tv.DataType = dt;
return(e);
}
public void ExdIndirectCall()
{
var p = Id("p", PrimitiveType.Word32);
var sig = FunctionType.Action(new[] { Id("r", PrimitiveType.Real32) });
store.EnsureExpressionTypeVariable(factory, p);
p.TypeVariable.OriginalDataType = PointerTo(sig);
p.TypeVariable.DataType = PointerTo(sig);
RunTest(
Test(
m.Fn(
p,
VoidType.Instance,
m.Mem(PrimitiveType.Word32, m.Word32(0x0300400))),
VoidType.Instance));
}
private void Given_Segment(ushort selector, string name)
{
var seg = new ImageSegment(name, new MemoryArea(Address.SegPtr(selector, 0), new byte[100]), AccessMode.ReadWriteExecute);
seg.Identifier = new Identifier(name, PrimitiveType.SegmentSelector, RegisterStorage.None);
program.SegmentMap.AddSegment(seg);
var tv = store.EnsureExpressionTypeVariable(factory, seg.Identifier);
var dt = new StructureType
{
IsSegment = true,
};
tv.Class.DataType = dt;
tv.DataType = new Pointer(tv.Class, 2);
tv.OriginalDataType = PrimitiveType.SegmentSelector;
}
public void Build(Program program)
{
// Special case for the global variables. In essence,
// a memory map of all the globals.
var tvGlobals = store.EnsureExpressionTypeVariable(factory, program.Globals, "globals_t");
tvGlobals.OriginalDataType = program.Globals.DataType;
EnsureSegmentTypeVariables(program.SegmentMap.Segments.Values);
foreach (Procedure proc in program.Procedures.Values)
{
this.signature = proc.Signature;
EnsureSignatureTypeVariables(this.signature);
foreach (Statement stm in proc.Statements)
{
stm.Instruction.Accept(this);
}
}
}
public void Build(Program prog)
{
// Special case for the global variables. In essence,
// a memory map of all the globals.
store.EnsureExpressionTypeVariable(factory, prog.Globals, "globals_t");
foreach (Procedure proc in prog.Procedures.Values)
{
ProcedureSignature signature = proc.Signature;
if (signature != null && signature.ReturnValue != null)
{
signature.ReturnValue.Accept(this);
}
foreach (Statement stm in proc.Statements)
{
stm.Instruction.Accept(this);
}
}
}
private void RunTest(Expression e, string outputFileName)
{
var globals = new Identifier("globals", PrimitiveType.Ptr32, RegisterStorage.None);
store.EnsureExpressionTypeVariable(factory, globals, "globals_t");
var eq = new EquivalenceClassBuilder(factory, store, new FakeDecompilerEventListener());
e.Accept(eq);
e.Accept(exa);
Verify(outputFileName);
}
public void Setup()
{
this.m = new ExpressionEmitter();
this.store = new TypeStore();
this.factory = new TypeFactory();
this.arch = new FakeArchitecture();
this.program = new Program {
Architecture = arch, Platform = new DefaultPlatform(null, arch)
};
this.exa = new ExpressionTypeAscender(program, store, factory);
this.exd = new ExpressionTypeDescender(program, store, factory);
store.EnsureExpressionTypeVariable(factory, program.Globals, "globals_t");
}
public void Setup()
{
program = new Program();
program.Architecture = new FakeArchitecture();
program.Platform = new DefaultPlatform(null, program.Architecture);
factory = program.TypeFactory;
store = program.TypeStore;
handler = new TestTraitHandler(store);
eqb = new EquivalenceClassBuilder(factory, store);
store.EnsureExpressionTypeVariable(factory, program.Globals);
atrco = new AddressTraitCollector(factory, store, handler, program);
m = new ProcedureBuilder();
}
private void RunTest(Expression e)
{
var globals = new Identifier("globals", PrimitiveType.Pointer32, RegisterStorage.None);
store.EnsureExpressionTypeVariable(factory, globals, "globals_t");
var eq = new EquivalenceClassBuilder(factory, store);
e.Accept(eq);
e.Accept(exa);
var outputFileName = string.Format("Typing/{0}.txt", new StackTrace().GetFrame(1).GetMethod().Name);
Verify(outputFileName);
}
public void ExdReferenceToUnknown()
{
var p = Id("p", PrimitiveType.Word32);
store.EnsureExpressionTypeVariable(factory, p);
p.TypeVariable.OriginalDataType = PointerTo(
new TypeReference("UNKNOWN_TYPE", new UnknownType()));
p.TypeVariable.DataType = PointerTo(
new TypeReference("UNKNOWN_TYPE", new UnknownType()));
RunTest(
m.Load(
PrimitiveType.Word32,
m.IAdd(p, m.Word32(4))),
PrimitiveType.Word32);
var ptr = p.TypeVariable.OriginalDataType as Pointer;
Assert.IsNotNull(ptr, "Should be pointer");
var tRef = ptr.Pointee as TypeReference;
Assert.IsNotNull(tRef, "Should be type reference");
Assert.AreEqual("(struct (4 T_5 t0004))", tRef.Referent.ToString());
}
public void DtbSegmentedDirectAddress()
{
ProcedureBuilder m = new ProcedureBuilder();
var arch = new Reko.Arch.X86.X86ArchitectureReal();
var prog = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(null, arch)
};
store.EnsureExpressionTypeVariable(factory, prog.Globals);
Identifier ds = m.Local16("ds");
Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Int16(0x0200));
TraitCollector coll = new TraitCollector(factory, store, dtb, prog);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(coll);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedDirectAddress.txt");
}
public void DtbSegmentedDirectAddress()
{
ProcedureBuilder m = new ProcedureBuilder();
var sc = new ServiceContainer();
var arch = new Reko.Arch.X86.X86ArchitectureReal(sc, "x86-real-16", new Dictionary <string, object>());
var program = new Program
{
Architecture = arch,
Platform = new DefaultPlatform(sc, arch)
};
store.EnsureExpressionTypeVariable(factory, 0, program.Globals);
Identifier ds = m.Local16("ds");
Expression e = m.SegMem(PrimitiveType.Byte, ds, m.Word16(0x0200));
TraitCollector coll = new TraitCollector(factory, store, dtb, program);
e = e.Accept(aen);
e.Accept(eqb);
e.Accept(coll);
dtb.BuildEquivalenceClassDataTypes();
Verify("Typing/DtbSegmentedDirectAddress.txt");
}
