public void CompatibleMemberPointers()
{
MemberPointer mp1 = new MemberPointer(new TypeVariable(1), PrimitiveType.Word16, 0);
MemberPointer mp2 = new MemberPointer(new TypeVariable(1), PrimitiveType.Word16, 0);
Assert.IsTrue(un.AreCompatible(mp1, mp2));
}
public Expression VisitMemberPointer(MemberPointer memptr)
{
// The constant is a member pointer.
Pointer p = (Pointer)memptr.BasePointer;
EquivalenceClass eq = (EquivalenceClass)p.Pointee;
StructureType baseType = (StructureType)eq.DataType;
Expression baseExpr = this.basePtr != null
? new Dereference(this.basePtr.DataType, this.basePtr)
: (Expression) new ScopeResolution(baseType);
var dt = memptr.Pointee.ResolveAs <DataType>() !;
var f = EnsureFieldAtOffset(baseType, dt, c !.ToInt32());
Expression ex = new FieldAccess(memptr.Pointee, baseExpr, f);
if (dereferenced)
{
ex.DataType = memptr.Pointee;
}
else
{
if (f.DataType is ArrayType array)
{
ex.DataType = new MemberPointer(p, array.ElementType, platform.PointerType.BitSize);
}
else
{
ex = new UnaryExpression(Operator.AddrOf, memptr, ex);
}
}
return(ex);
}
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.BitSize));
}
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);
}
public void UnifyWordMembptr()
{
MemberPointer mp = new MemberPointer(new StructureType("foo", 4), PrimitiveType.Int32, 2);
DataType dt = un.Unify(mp, PrimitiveType.Word16);
Assert.AreEqual("(memptr (struct \"foo\" 0004) int32)", dt.ToString());
}
protected override void OnCopy(MemberPointer obj)
{
EventPointer ep = obj as EventPointer;
if (ep != null)
{
if (ep._parameterValues != null)
{
_parameterValues = new object[ep._parameterValues.Length];
for (int i = 0; i < _parameterValues.Length; i++)
{
ICloneable ic = ep._parameterValues[i] as ICloneable;
if (ic != null)
{
_parameterValues[i] = ic.Clone();
}
else
{
_parameterValues[i] = ep._parameterValues[i];
}
}
}
ICloneable eic = ep.Info as ICloneable;
if (eic != null)
{
_eif = (EventInfo)eic.Clone();
}
else
{
_eif = ep.Info;
}
}
}
public Formatter VisitMemberPointer(MemberPointer memptr)
{
Pointer p = memptr.BasePointer as Pointer;
DataType baseType;
if (p != null)
{
baseType = p.Pointee;
}
else
{
baseType = memptr.BasePointer;
}
string oldName = name;
name = null;
memptr.Pointee.Accept(this);
if (mode == Mode.Writing)
{
writer.Write(" ");
writer.WriteType(baseType.Name, baseType);
writer.Write("::*");
}
name = oldName;
if (mode == Mode.Writing)
{
WriteName(false);
}
return(writer);
}
public bool ReplaceAll()
{
changed = false;
classesVisited = new HashSet <EquivalenceClass>();
// Replace the DataType of all the equivalence classes
foreach (TypeVariable tv in store.TypeVariables)
{
EquivalenceClass eq = tv.Class;
if (!classesVisited.Contains(eq))
{
classesVisited.Add(eq);
var dt = Replace(eq.DataType);
eq.DataType = dt;
}
}
// Replace the DataType of all the TypeVariables
foreach (TypeVariable tv in store.TypeVariables)
{
tv.DataType = Replace(tv.DataType);
}
foreach (EquivalenceClass eq in classesVisited)
{
if (eq != program.Globals.TypeVariable.Class &&
(eq.DataType is PrimitiveType ||
eq.DataType is VoidType ||
eq.DataType is EquivalenceClass ||
eq.DataType is CodeType))
{
eq.DataType = null;
changed = true;
continue;
}
Pointer ptr = eq.DataType as Pointer;
if (ptr != null)
{
eq.DataType = ptr.Pointee;
changed = true;
continue;
}
MemberPointer mp = eq.DataType as MemberPointer;
if (mp != null)
{
eq.DataType = mp.Pointee;
changed = true;
}
ArrayType array = eq.DataType as ArrayType;
if (array != null)
{
eq.DataType = array.ElementType;
changed = true;
}
}
return(changed);
}
public void TyfoMembptr()
{
var s = new StructureType("s", 0);
MemberPointer mp = new MemberPointer(new Pointer(s, 32), PrimitiveType.Int32, 2);
tyreffo.WriteDeclaration(mp, "mp");
Assert.AreEqual("int32 s::* mp", sw.ToString());
}
protected override void OnCopy(MemberPointer obj)
{
base.OnCopy(obj);
InterfaceEventPointer mp = obj as InterfaceEventPointer;
if (mp != null)
{
_interfaceType = mp.InterfaceType;
}
}
protected override void OnCopy(MemberPointer obj)
{
base.OnCopy(obj);
InterfacePropertyPointer pp = obj as InterfacePropertyPointer;
if (pp != null)
{
_interfaceType = pp._interfaceType;
_pif = pp._pif;
}
}
public void Unify_MemberPointer_Word32()
{
var t1 = PrimitiveType.Word32;
var t2 = new MemberPointer(
new Pointer(new StructureType {
IsSegment = true
}, 16),
PrimitiveType.Int32,
4);
Assert.IsTrue(un.AreCompatible(t1, t2));
Assert.AreEqual("(memptr (ptr16 (segment)) int32)", un.Unify(t1, t2).ToString());
}
public void Unify_MemberPointer()
{
var t1 = PrimitiveType.Create(Domain.Offset, 2);
var t2 = new MemberPointer(
new Pointer(new StructureType {
IsSegment = true
}, 2),
PrimitiveType.Word16,
2);
Assert.IsTrue(un.AreCompatible(t1, t2));
Assert.AreEqual("(memptr (ptr (segment)) word16)", un.Unify(t1, t2).ToString());
}
public DataType VisitMemberPointer(MemberPointer mptr)
{
mptr.BasePointer = mptr.BasePointer.Accept(this);
mptr.Pointee = mptr.Pointee.Accept(this);
if (mptr.Pointee is ArrayType array)
{
Changed = true;
return(factory.CreateMemberPointer(
mptr.BasePointer,
array.ElementType,
mptr.BitSize));
}
return(mptr);
}
protected override void OnCopy(MemberPointer obj)
{
MethodPointer mp = obj as MethodPointer;
if (mp != null)
{
this.SetMethodInfo(mp.MethodDef);
_id = mp.MethodID;
_returnType = mp._returnType;
_paramTypes = mp._paramTypes;
_prj = mp._prj;
_parameterJS = mp._parameterJS;
TypeParameters = mp.TypeParameters;
}
}
public void UnifyWordMemptr()
{
TypeVariable tv = new TypeVariable(1);
TypeVariable tv2 = new TypeVariable(2);
TypeVariable tv3 = new TypeVariable(3);
MemberPointer mp2 = new MemberPointer(tv, tv2, 0);
MemberPointer mp3 = new MemberPointer(tv, tv3, 0);
UnionType ut = new UnionType(null, null);
un.UnifyIntoUnion(ut, mp2);
un.UnifyIntoUnion(ut, mp3);
un.UnifyIntoUnion(ut, PrimitiveType.Word16);
Assert.AreEqual("(union ((memptr T_1 T_2) u0) ((memptr T_1 T_3) u1))", ut.ToString());
}
public Expression VisitMemberPointer(MemberPointer memptr)
{
if (enclosingPtr != null)
{
return(expComplex);
}
var pointee = memptr.Pointee;
var origMemptr = dtComplexOrig.ResolveAs <MemberPointer>();
if (origMemptr != null)
{
pointee = origMemptr.Pointee;
}
return(RewritePointer(memptr, memptr.Pointee, pointee));
}
public override void VisitConstant(Constant c)
{
if (!c.IsValid)
{
return;
}
DataType dt = c.TypeVariable.DataType;
int offset = StructureField.ToOffset(c);
Pointer ptr = dt as Pointer;
if (ptr != null)
{
// C is a constant pointer.
if (offset == 0)
{
return; // null pointer is null (//$REVIEW: except for some platforms + archs)
}
var pointee = ptr.Pointee;
var segPointee = pointee.ResolveAs <StructureType>();
if (segPointee != null && segPointee.IsSegment)
{
//$TODO: these are getting merged earlier, perhaps this is the right place to do those merges?
return;
}
var strGlobals = Globals.TypeVariable.Class.ResolveAs <StructureType>();
if (strGlobals.Fields.AtOffset(offset) == null)
{
if (!IsInsideArray(strGlobals, offset, pointee))
{
strGlobals.Fields.Add(offset, pointee);
}
}
return;
}
MemberPointer mptr = dt as MemberPointer;
if (mptr != null)
{
// C is a constant offset into a segment.
var seg = ((Pointer)mptr.BasePointer).Pointee.ResolveAs <StructureType>();
if (seg != null && //$DEBUG
seg.Fields.AtOffset(offset) == null)
{
seg.Fields.Add(offset, mptr.Pointee);
}
// VisitConstantMemberPointer(offset, mptr);
}
}
public DataType VisitMemberPointer(MemberPointer mptr)
{
mptr.BasePointer = mptr.BasePointer.Accept(this);
mptr.Pointee = mptr.Pointee.Accept(this);
var array = mptr.Pointee as ArrayType;
if (array != null)
{
Changed = true;
return(factory.CreateMemberPointer(
mptr.BasePointer,
array.ElementType,
mptr.Size));
}
return(mptr);
}
void MemberPointer(MemberPointer m)
{
if (m.Pointee is Pointer ptPointee)
{
Pointer(ptPointee);
}
if (m.Pointee is MemberPointer mpPointee)
{
MemberPointer(mpPointee);
}
Formatter.Write(' ');
var baseType = StripPointerOperator(m.BasePointer);
Formatter.Write(baseType.Name);
Formatter.Write("::*");
TypeQualifierList(m);
}
private bool IsOneLineDeclaration(DataType dataType)
{
var dt = dataType.ResolveAs <DataType>();
return(dt switch
{
PrimitiveType pt => !IsLargeBlob(pt),
Pointer _ => true,
MemberPointer _ => true,
StringType _ => true,
VoidType _ => true,
EquivalenceClass eq => eq.DataType is null || IsOneLineDeclaration(eq.DataType),
TypeReference tr => tr.Referent is null || IsOneLineDeclaration(tr.Referent),
CodeType _ => true,
FunctionType _ => true,
_ => false,
});
/// <summary>
/// If a constant pointer into a structure is found, make sure there is a variable there.
/// </summary>
/// <param name="offset"></param>
/// <param name="mptr"></param>
private void VisitConstantMemberPointer(int offset, MemberPointer mptr)
{
TypeVariable?tvField = GetTypeVariableForField(mptr.Pointee);
if (tvField == null)
{
return;
}
TypeVariable tvBase = (TypeVariable)mptr.BasePointer;
Pointer ptr = CreatePointerToField(offset, tvField);
tvBase.OriginalDataType =
unifier.Unify(tvBase.OriginalDataType, ptr) !;
ptr = CreatePointerToField(offset, tvField);
tvBase.Class.DataType =
unifier.Unify(tvBase.Class.DataType, ptr) !;
}
void MemberPointer(MemberPointer m)
{
var ptPointee = m.Pointee as Pointer;
if (ptPointee != null)
{
Pointer(ptPointee);
}
var mpPointee = m.Pointee as MemberPointer;
if (mpPointee != null)
{
MemberPointer(mpPointee);
}
fmt.Write(' ');
var baseType = StripPointerOperator(m.BasePointer);
fmt.Write(baseType.Name);
fmt.Write("::*");
TypeQualifierList(m);
}
public CodeFormatter VisitMemberPointer(MemberPointer memptr)
{
throw new NotImplementedException();
}
public bool IsCompatibleWithMemberPointer(MemberPointer mpA, DataType b)
{
MemberPointer mpB = b as MemberPointer;
if (mpB != null)
return
AreCompatible(mpA.BasePointer, mpB.BasePointer) &&
AreCompatible(mpA.Pointee, mpB.Pointee);
PrimitiveType pb = b as PrimitiveType;
if (pb != null)
{
if (pb == PrimitiveType.Word16 || pb.Domain == Domain.Pointer || pb.Domain == Domain.Selector)
return true;
}
return false;
}
public DataType UnifyMemberPointer(MemberPointer mpA, DataType b)
{
PrimitiveType pb = b as PrimitiveType;
if (pb != null)
{
if (pb == PrimitiveType.Word16 || pb == PrimitiveType.Word32 || pb.Domain == Domain.Selector)
{
//$REVIEW: line above should be if (mpA.Size = b.Size .... as in UnifyPointer.
return mpA.Clone();
}
}
return MakeUnion(mpA, b);
}
public void UnifyWordMemptr()
{
TypeVariable tv = new TypeVariable(1);
TypeVariable tv2 = new TypeVariable(2);
TypeVariable tv3 = new TypeVariable(3);
MemberPointer mp2 = new MemberPointer(tv, tv2, 0);
MemberPointer mp3 = new MemberPointer(tv, tv3, 0);
UnionType ut = new UnionType(null, null);
un.UnifyIntoUnion(ut, mp2);
un.UnifyIntoUnion(ut, mp3);
un.UnifyIntoUnion(ut, PrimitiveType.Word16);
Assert.AreEqual("(union ((memptr T_1 T_2) u0) ((memptr T_1 T_3) u1))", ut.ToString());
}
void MemberPointer(MemberPointer m)
{
var ptPointee = m.Pointee as Pointer;
if (ptPointee != null)
Pointer(ptPointee);
var mpPointee = m.Pointee as MemberPointer;
if (mpPointee != null)
MemberPointer(mpPointee);
fmt.Write(' ');
var baseType = StripPointerOperator(m.BasePointer);
fmt.Write(baseType.Name);
fmt.Write("::*");
TypeQualifierList(m);
}
public void Unify_MemberPointer()
{
var t1 = PrimitiveType.Create(Domain.Offset, 2);
var t2 = new MemberPointer(
new Pointer(new StructureType { IsSegment = true }, 2),
PrimitiveType.Word16,
2);
Assert.IsTrue(un.AreCompatible(t1, t2));
Assert.AreEqual("(memptr (ptr (segment)) word16)", un.Unify(t1, t2).ToString());
}
public void CompatibleMemberPointers()
{
MemberPointer mp1 = new MemberPointer(new TypeVariable(1), PrimitiveType.Word16, 0);
MemberPointer mp2 = new MemberPointer(new TypeVariable(1), PrimitiveType.Word16, 0);
Assert.IsTrue(un.AreCompatible(mp1, mp2));
}
public IEnumerable <WorkItem> VisitMemberPointer(MemberPointer memptr)
{
throw new NotImplementedException();
}
public SerializedType VisitMemberPointer(MemberPointer memptr)
{
throw new NotImplementedException();
}
public void VisitMemberPointer(MemberPointer memptr)
{
throw new NotImplementedException();
}
public void UnifyWordMembptr()
{
MemberPointer mp = new MemberPointer(new StructureType("foo", 4), PrimitiveType.Int32, 2);
DataType dt = un.Unify(mp, PrimitiveType.Word16);
Assert.AreEqual("(memptr (struct \"foo\" 0004) int32)", dt.ToString());
}
public int VisitMemberPointer(MemberPointer memptr)
{
throw new NotImplementedException();
}
public bool VisitMemberPointer(MemberPointer memptr)
{
return
(Find(memptr.BasePointer) ||
Find(memptr.Pointee));
}
public override Expression CloneExpression()
{
return(new MemberPointerSelector(DataType, BasePointer.CloneExpression(), MemberPointer.CloneExpression()));
}
public DataType VisitMemberPointer(MemberPointer memptr)
{
memptr.BasePointer = memptr.BasePointer.Accept(this);
memptr.Pointee = memptr.Pointee.Accept(this);
return(memptr);
}
public string VisitMemberPointer(MemberPointer memptr)
{
return("ptr");
}
public void TyfoMembptr()
{
var s = new StructureType("s", 0);
MemberPointer mp = new MemberPointer(new Pointer(s, 4), PrimitiveType.Int32, 2);
tyreffo.WriteDeclaration(mp, "mp");
Assert.AreEqual("int32 s::* mp", sw.ToString());
}
