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