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;
}
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 StructureMerger(ICollection<StructureType> structures, ICollection<EquivalenceClass> eqClasses)
{
this.structures = structures;
this.eqClasses = eqClasses;
foreach (EquivalenceClass eq in eqClasses)
{
if (eqMin == null)
eqMin = eq;
else if (eq.Number < eqMin.Number)
eqMin = eq;
}
}
public void Merge1()
{
TypeVariable tv1 = new TypeVariable(1);
TypeVariable tv2 = new TypeVariable(2);
StructureType s1 = new StructureType { Fields = { { 4, PrimitiveType.Pointer32 } } };
StructureType s2 = new StructureType { Fields = { { 4, PrimitiveType.Pointer32 } } };
EquivalenceClass c1 = new EquivalenceClass(tv1);
EquivalenceClass c2 = new EquivalenceClass(tv2);
c1.DataType = s1;
c2.DataType = s2;
StructureMerger sm = new StructureMerger(new StructureType[] { s1, s2 }, new EquivalenceClass[] { c1, c2 } );
sm.Merge();
Assert.AreEqual("(struct (4 ptr32 ptr0004))", c1.DataType.ToString());
}
public void Tmer_PointerToSingleItem()
{
var ptr = new Identifier("ptr", PrimitiveType.Word32, null);
var tv = store.EnsureExpressionTypeVariable(factory, ptr);
tv.OriginalDataType = new Pointer(point, 4);
var eq = new EquivalenceClass(tv);
eq.DataType = point;
tv.DataType = new Pointer(eq, 4);
TypedExpressionRewriter tmer = new TypedExpressionRewriter(program);
var access = Wrap(new MemoryAccess(ptr, PrimitiveType.Word32));
TypeVariable tvAccess = access.TypeVariable;
tvAccess.DataType = PrimitiveType.Word32;
Expression e = access.Accept(tmer);
Assert.AreEqual("ptr->dw0000", e.ToString());
}
public void Tmer_PointerToSecondItemOfPoint()
{
Identifier ptr = new Identifier("ptr", PrimitiveType.Word32, null);
store.EnsureExpressionTypeVariable(factory, ptr);
EquivalenceClass eqPtr = new EquivalenceClass(ptr.TypeVariable);
eqPtr.DataType = point;
ptr.TypeVariable.OriginalDataType = new Pointer(point, 4);
ptr.TypeVariable.DataType = new Pointer(eqPtr, 4);
var c = Wrap(Constant.Word32(4));
var bin = Wrap(new BinaryExpression(BinaryOperator.IAdd, PrimitiveType.Word32, ptr, c));
var mem = Wrap(new MemoryAccess(bin, PrimitiveType.Word32));
var tmer = new TypedExpressionRewriter(program);
Expression e = mem.Accept(tmer);
Assert.AreEqual("ptr->dw0004", e.ToString());
}
private void Globals(params StructureField[] fields)
{
var arch = new Mocks.FakeArchitecture();
this.prog = new Program(
image,
image.CreateImageMap(),
arch,
new DefaultPlatform(null, arch));
var globalStruct = new StructureType();
globalStruct.Fields.AddRange(fields);
prog.Globals.TypeVariable = new TypeVariable("globals_t", 1) { DataType = globalStruct };
var eq = new EquivalenceClass(prog.Globals.TypeVariable);
eq.DataType = globalStruct;
var ptr = new Pointer(eq, 4);
prog.Globals.TypeVariable.DataType = ptr;
}
public static bool ReplaceAll(TypeFactory factory, TypeStore store)
{
EquivalenceClass [] eqs = new EquivalenceClass[store.UsedEquivalenceClasses.Count];
store.UsedEquivalenceClasses.CopyTo(eqs, 0);
bool changed = false;
for (int i = 0; i < eqs.Length; ++i)
{
if (eqs[i].DataType != null)
{
NestedComplexTypeExtractor nctr = new NestedComplexTypeExtractor(factory, store);
eqs[i].DataType = eqs[i].DataType.Accept(nctr);
changed |= nctr.Changed;
}
}
return changed;
}
public void HasCoincidentUnion()
{
var eq = new EquivalenceClass(
new TypeVariable(42),
new UnionType(null, null,
PrimitiveType.SegPtr32, PrimitiveType.Word16));
var s = new StructureType(null, 0)
{
Fields =
{
{ 0, eq },
{ 0, PrimitiveType.SegmentSelector }
}
};
TypeTransformer trans = new TypeTransformer(factory, null, null);
Assert.IsTrue(trans.HasCoincidentFields(s));
}
public void NotMatch()
{
TypeVariable t1 = new TypeVariable(1);
TypeVariable t2 = new TypeVariable(2);
EquivalenceClass c1 = new EquivalenceClass(t1);
EquivalenceClass c2 = new EquivalenceClass(t2);
c1.DataType = new StructureType{ Fields = { { 4, PrimitiveType.Word16 } } };
c2.DataType = new StructureType { Fields = { { 20, PrimitiveType.Word32 } } };
t1.Class = c1;
t2.Class = c2;
UnionType u = new UnionType(null, null);
u.Alternatives.Add(new Pointer(c1, 4));
u.Alternatives.Add(new Pointer(PrimitiveType.Word16, 4));
UnionPointersStructuresMatcher upsm = new UnionPointersStructuresMatcher();
Assert.IsFalse(upsm.Match(u));
}
public void Setup()
{
store = new TypeStore();
factory = new TypeFactory();
globals = new Identifier("globals", PrimitiveType.Word32, null);
StructureType point = new StructureType("Point", 0)
{
Fields = {
{ 0, PrimitiveType.Word32, null },
{ 4, PrimitiveType.Word32, null }
}
};
TypeVariable tvPoint = store.CreateTypeVariable(factory);
EquivalenceClass eq = new EquivalenceClass(tvPoint)
{
DataType = point
};
tvPoint.DataType = eq;
ptrPoint = new Pointer(eq, 4);
UnionType u = new UnionType("RealInt", null)
{
Alternatives = {
new UnionAlternative("w", PrimitiveType.Word32, 0),
new UnionAlternative("r", PrimitiveType.Real32, 1),
}
};
TypeVariable tvUnion = store.CreateTypeVariable(factory);
eq = new EquivalenceClass(tvUnion)
{
DataType = u
};
tvUnion.DataType = eq;
ptrUnion = new Pointer(eq, 4);
ptrInt = new Pointer(PrimitiveType.Int32, 4);
ptrWord = new Pointer(PrimitiveType.Word32, 4);
m = new ExpressionEmitter();
}
public void Setup()
{
mr = new MockRepository();
arch = mr.Stub<IProcessorArchitecture>();
arch.Stub(a => a.CreateImageReader(null, 0u)).IgnoreArguments().Do(new Func<LoadedImage, ulong, ImageReader>((i, o) => i.CreateLeReader(o)));
arch.Replay();
globalStruct = new StructureType
{
};
globals_t = new TypeVariable("globals_t", 1) { DataType = globalStruct };
globals = new Identifier("globals", PrimitiveType.Pointer32, null);
eqLink = new EquivalenceClass(new TypeVariable(2));
StructureType str = new StructureType
{
Fields = {
{ 0, new Pointer(eqLink, 4)},
{ 4, PrimitiveType.Int32 }
}
};
eqLink.DataType = str;
}
public void VisitEquivalenceClass(EquivalenceClass eq)
{
throw new NotImplementedException();
}
public void VisitEquivalenceClass(EquivalenceClass eq)
{
throw new NotImplementedException();
}
public void GdwStructure()
{
Memory(0x1000)
.WriteLeUInt16(4)
.WriteLeUInt16(unchecked((ushort) -104));
var eqStr = new EquivalenceClass(new TypeVariable(2));
var str = new StructureType
{
Name = "Eq_2",
Fields = {
{ 0, PrimitiveType.Int16 },
{ 2, PrimitiveType.Int16 },
}
};
eqStr.DataType = str;
Globals(
Field(0x1000, eqStr));
RunTest(
@"Eq_2 g_t1000 =
{
4,
-104,
};
");
}
public override DataType VisitEquivalenceClass(EquivalenceClass eq)
{
if (!classesVisited.Contains(eq))
{
classesVisited.Add(eq);
if (eq.DataType != null)
{
eq.DataType = eq.DataType.Accept(this);
}
}
DataType dt = eq.DataType;
PrimitiveType pr = dt as PrimitiveType;
if (pr != null)
{
changed = true;
return pr;
}
if (dt is VoidType)
{
changed = true;
return dt;
}
if (dt is CodeType)
{
changed = true;
return dt;
}
Pointer ptr = dt as Pointer;
if (ptr != null)
{
changed = true;
DataType pointee = eq;
return factory.CreatePointer(pointee, ptr.Size);
}
MemberPointer mp = dt as MemberPointer;
if (mp != null)
{
changed = true;
return factory.CreateMemberPointer(mp.BasePointer, eq, mp.Size);
}
ArrayType array = dt as ArrayType;
if (array != null)
{
changed = true;
return factory.CreateArrayType(array.ElementType, array.Length);
}
EquivalenceClass eq2 = dt as EquivalenceClass;
if (eq2 != null)
{
changed = true;
return eq2;
}
return eq;
}
protected void setUp()
{
//test a combination from 3 elements
structure = new TestCasesStructure();
Element elem1 = new Element(structure);
EquivalenceClass eq11 = new EquivalenceClass(elem1);
EquivalenceClass eq12 = new EquivalenceClass(elem1);
EquivalenceClass eq13 = new EquivalenceClass(elem1);
Element elem2 = new Element(structure);
EquivalenceClass eq21 = new EquivalenceClass(elem2);
EquivalenceClass eq22 = new EquivalenceClass(elem2);
EquivalenceClass eq23 = new EquivalenceClass(elem2);
Element elem3 = new Element(structure);
EquivalenceClass eq31 = new EquivalenceClass(elem3);
EquivalenceClass eq32 = new EquivalenceClass(elem3);
EquivalenceClass eq33 = new EquivalenceClass(elem3);
dep = new Dependency(structure);
dep2 = new Dependency(structure);
dep3 = new Dependency(structure);
foreach (Element element in structure.Elements)
{
dep.AddElement(element);
foreach (EquivalenceClass equivalenceClass in element.EquivalenceClasses)
{
dep.AddEquivalenceClass(equivalenceClass);
}
}
Combination combi4;
Combination combi3;
Combination combi1;
Combination combi2;
combi1 = new Combination(dep);
combi2 = new Combination(dep2);
combi3 = new Combination(dep);
combi4 = new Combination(dep3);
combi1.AddEquivalenceClass(eq11);
combi1.AddEquivalenceClass(eq22);
combi1.AddEquivalenceClass(eq33);
combi2.AddEquivalenceClass(eq21);
combi2.AddEquivalenceClass(eq11);
combi2.AddEquivalenceClass(eq32);
combi3.AddEquivalenceClass(eq13);
combi3.AddEquivalenceClass(eq23);
combi3.AddCombination(combi4);
test1 = new TestCase(structure);
test2 = new TestCase(structure);
test3 = new TestCase(structure);
test4 = new TestCase(structure);
test5 = new TestCase(structure);
test1.AddCombination(combi1);
test1.AddCombination(combi4);
test2.AddCombination(combi3);
test2.AddCombination(combi4);
test3.AddCombination(combi2);
test3.AddCombination(combi1);
test4.AddCombination(combi3);
test5.AddCombination(combi2);
test5.AddCombination(combi4);
}
private static IList <EquivalenceClass> BuildMergePattern(Combination p_combination, EquivalenceClass p_equivalenceClass)
{
List <EquivalenceClass> mergePattern = new List <EquivalenceClass>();
mergePattern.Add(p_equivalenceClass);
Element parentElement = p_equivalenceClass.ParentElement;
//add all equivalence classes from the combination (that are does not have the same parent element)
foreach (EquivalenceClass eClass in p_combination.EquivalenceClasses)
{
if (eClass.ParentElement != parentElement &&
!mergePattern.Contains(eClass))
{
mergePattern.Add(eClass);
}
}
//look also in the children combinations recursively
foreach (Combination childCombination in p_combination.Combinations)
{
IList <EquivalenceClass> partOfMergePattern = BuildMergePattern(childCombination, p_equivalenceClass);
//add those equivalence classes to the pattern
foreach (EquivalenceClass equivalenceClass in partOfMergePattern)
{
if (!mergePattern.Contains(equivalenceClass))
{
mergePattern.Add(equivalenceClass);
}
}
}
return(mergePattern);
}
public void TypeReference()
{
tyreffo = new TypeReferenceFormatter(new TextFormatter(sw), true);
EquivalenceClass b = new EquivalenceClass(new TypeVariable(1));
b.DataType = new StructureType("b", 0) { Fields = { { 4, PrimitiveType.Word32 } } };
tyfo.Write(new Pointer(b, 2), "pb");
Assert.AreEqual("b * pb", sw.ToString());
}
public DataType VisitEquivalenceClass(EquivalenceClass eq)
{
return(eq);
}
public void CfScopeResolution()
{
var eq = new EquivalenceClass(new TypeVariable("Eq_2", 2));
var sr = new ScopeResolution(eq);
var e = new FieldAccess(PrimitiveType.Int32, sr, new StructureField(4, PrimitiveType.Int32, "i0004"));
e.Accept(cf);
Assert.AreEqual("Eq_2::i0004", sw.ToString());
}
public SerializedType VisitEquivalenceClass(EquivalenceClass eq)
{
throw new NotImplementedException();
}
public void CompatiblePtrToArray()
{
var eq = new EquivalenceClass(new TypeVariable(3));
var a = new ArrayType(eq, 0);
var p1 = new Pointer(eq, 4);
var p2 = new Pointer(a, 4);
Assert.IsTrue(un.AreCompatible(p1, p2));
}
public Expression VisitEquivalenceClass(EquivalenceClass eq)
{
throw new NotImplementedException();
}
public void CptTree()
{
var eqTreeNode = new EquivalenceClass(new TypeVariable(2));
var str = new StructureType
{
Fields = {
{ 0, PrimitiveType.UInt32 },
{ 4, new Pointer(eqTreeNode, 4) }, // Left
{ 8, new Pointer(eqTreeNode, 4) }, // Right
}
};
eqTreeNode.DataType = str;
Memory(0x10000)
.WriteLeUInt32(0) // 00: Padding
.WriteLeUInt32(0) // 04: Padding
.WriteLeUInt32(0x746F6F52) // 08: Ascii 'Root'
.WriteLeUInt32(0x00010014) // 0C: Ptr to Left node
.WriteLeUInt32(0x00010020) // 10: Right node
.WriteLeUInt32(0x7466654C) // 14: Ascii 'Left'
.WriteLeUInt32(0x00000000) // 18: no left node
.WriteLeUInt32(0x00000000) // 1C: no right node
.WriteLeUInt32(0x65746952) // 20: Ascii 'Rite'
.WriteLeUInt32(0x00000000) // 24: no left node
.WriteLeUInt32(0x00000000); // 28: no right node
Root(0x10008, eqTreeNode);
var cpt = new ConstantPointerTraversal(arch, globalStruct, image);
cpt.Traverse();
Assert.AreEqual(2, cpt.Discoveries.Count);
Assert.AreEqual("10014: t10014: Eq_2", cpt.Discoveries[0].ToString());
Assert.AreEqual("10020: t10020: Eq_2", cpt.Discoveries[1].ToString());
Assert.AreEqual("10020: t10020: Eq_2", cpt.Discoveries[1].ToString());
}
public void GdwVisitLinkedList()
{
Memory(0x1000)
.WriteLeUInt32(1)
.WriteLeUInt32(0x1008)
.WriteLeUInt32(2)
.WriteLeUInt32(0x0000)
.WriteLeUInt32(0x1000);
var eqLink = new EquivalenceClass(new TypeVariable(2));
var link = new StructureType
{
Name = "Eq_2",
Fields = {
{ 0, PrimitiveType.Int32 },
{ 4, new Pointer(eqLink, 4) }
}
};
eqLink.DataType = link;
Globals(
Field(0x1000, eqLink),
Field(0x1008, eqLink),
Field(0x1010, new Pointer(eqLink, 4)));
RunTest(
@"Eq_2 g_t1000 =
{
1,
&g_t1008,
};
Eq_2 g_t1008 =
{
2,
null,
};
Eq_2* g_ptr1010 = &g_t1000;
");
}
public IEnumerable <WorkItem> VisitEquivalenceClass(EquivalenceClass eq)
{
return(eq.DataType.Accept(this));
}
