public bool Match(SegmentedAccess segMem)
{
this.segMem = segMem;
this.seg = segMem.BasePointer as Identifier;
if (seg == null)
return false;
this.segPtr = null;
var off = segMem.EffectiveAddress;
this.idOff = off as Identifier;
if (idOff != null)
{
segPtr = SlicedSegPointer(seg, idOff);
}
else
{
var binOff = off as BinaryExpression;
if (binOff == null)
return false;
idOff = binOff.Left as Identifier;
if (idOff != null)
{
segPtr = SlicedSegPointer(seg, idOff);
}
}
return segPtr != null;
}
public void EqbSegmentedAccess()
{
Identifier ds = new Identifier("ds", PrimitiveType.SegmentSelector, null);
Identifier bx = new Identifier("bx", PrimitiveType.Word16, null);
SegmentedAccess mps = new SegmentedAccess(MemoryIdentifier.GlobalMemory, ds, bx, PrimitiveType.Word32);
mps.Accept(eqb);
Assert.AreEqual("T_3", mps.TypeVariable.Name);
}
public void CEB_BuildMemberAccessFetch()
{
var ds = new Identifier("ds", PrimitiveType.SegmentSelector, null);
var bx = new Identifier("bx", PrimitiveType.Word16, null);
var sa = new SegmentedAccess(null, ds, bx, PrimitiveType.Word16);
var tvDs = CreateTv(ds, Ptr16(Segment()), ds.DataType);
var tvBx = CreateTv(bx, MemPtr(Segment(), PrimitiveType.Word16), MemPtr(new TypeVariable(43), PrimitiveType.Word16));
var ceb = new ComplexExpressionBuilder(
new Pointer(PrimitiveType.Word16, 2),
tvBx.Class.DataType, tvBx.OriginalDataType, ds, bx, null, 0);
ceb.Dereferenced = true;
Assert.AreEqual("ds->*bx", ceb.BuildComplex().ToString());
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
Expression basePtr = access.BasePointer.Accept(this);
Expression ea = access.EffectiveAddress.Accept(this);
DataType type = access.DataType;
Constant c = ea as Constant;
if (c != null)
{
return new FieldAccess(type, new Dereference(type, basePtr), string.Format("{0}{1:X4}", type.Prefix, c.ToInt16()));
}
BinaryExpression b = ea as BinaryExpression;
if (b != null && b.Operator == Operator.IAdd)
{
c = b.Right as Constant;
if (c != null)
{
return new FieldAccess(type, new MemberPointerSelector(type, basePtr, b.Left),
string.Format("{0}{1:X4}", type.Prefix, c.ToInt16()));
}
}
return new MemberPointerSelector(null, basePtr, ea);
}
public Expression GetValue(SegmentedAccess access)
{
int stackOffset;
if (GetStackOffset(access.EffectiveAddress, out stackOffset))
{
Expression value;
if (stackState.TryGetValue(stackOffset, out value))
return value;
}
return Constant.Invalid;
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
access.EffectiveAddress = access.EffectiveAddress.Accept(this);
if (aem.Match(access.EffectiveAddress))
{
return aem.Transform(access.BasePointer, access.DataType);
}
else if (access.EffectiveAddress is Identifier)
{
access.EffectiveAddress = AddZeroToEffectiveAddress(access.EffectiveAddress);
return access;
}
else
{
return access;
}
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
base.VisitSegmentedAccess(access);
flags |= SideEffectFlags.Load;
}
public Expression GetValue(SegmentedAccess access, SegmentMap segmentMap)
{
return(Constant.Invalid);
}
public Expression GetValue(SegmentedAccess access)
{
return(GetValueEa(access));
}
public Expression GetValue(SegmentedAccess access, SegmentMap segmentMap)
{
return(access);
}
void IExpressionVisitor.VisitSegmentedAccess(SegmentedAccess access)
{
throw new NotImplementedException();
}
public override LinearInductionVariable?VisitSegmentedAccess(SegmentedAccess access)
{
return(null);
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
var tmer = new TypedMemoryExpressionRewriter(prog);
return(tmer.Rewrite(access));
}
public bool VisitSegmentedAccess(SegmentedAccess segmem) => segmem.BasePointer.Accept(this) || segmem.EffectiveAddress.Accept(this);
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
var e = base.VisitSegmentedAccess(access);
if (!(e is SegmentedAccess accessNew))
{
return(e);
}
if (!(accessNew.BasePointer is Identifier idSeg))
{
return(e);
}
if (sac.AssociatedIdentifier(idSeg) == null)
{
return(e);
}
var sidSeg = ssa.Identifiers[idSeg];
if (accessNew.EffectiveAddress is Identifier idEa)
{
var sidEa = ssa.Identifiers[idEa];
var sids = new[] { sidSeg, sidEa };
e = FuseIdentifiers(sids);
if (e != null)
{
return(new MemoryAccess(accessNew.MemoryId, e, accessNew.DataType));
}
}
else if (accessNew.EffectiveAddress is BinaryExpression binEa)
{
if (binEa.Left is Identifier idLeft)
{
var sidLeft = ssa.Identifiers[idLeft];
e = FuseIdentifiers(sidSeg, sidLeft);
if (e != null)
{
return(new MemoryAccess(
accessNew.MemoryId,
new BinaryExpression(
binEa.Operator,
e.DataType,
e,
binEa.Right),
accessNew.DataType));
}
}
if (binEa.Right is Identifier idRight)
{
var sidRight = ssa.Identifiers[idRight];
e = FuseIdentifiers(sidSeg, sidRight);
if (e != null)
{
return(new MemoryAccess(
accessNew.MemoryId,
new BinaryExpression(
binEa.Operator,
e.DataType,
binEa.Left,
e),
accessNew.DataType));
}
}
}
return(accessNew);
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
Identifier pointer = access.BasePointer as Identifier;
if (pointer == null)
return;
BinaryExpression bin = access.EffectiveAddress as BinaryExpression;
if (bin != null)
{
Identifier mp = bin.Left as Identifier;
if (bin.Operator == BinaryOperator.IAdd && mp != null)
{
Associate(pointer, mp);
}
return;
}
Constant c = access.EffectiveAddress as Constant;
if (c != null)
{
Associate(pointer, c);
return;
}
}
public void VisitSegmentedAccess(SegmentedAccess access)
{
handler.MemAccessTrait(basePointer, access, access.DataType.Size, eField, 0);
}
public void VisitSegmentedAccess(SegmentedAccess access)
{
handler.MemAccessTrait(basePointer, access, access.DataType.Size, eField, 0);
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
bitUseOffset = 0;
cbitsUse = 0;
base.VisitSegmentedAccess(access);
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
base.VisitSegmentedAccess(access);
flags |= SideEffectFlags.Load;
}
public Expression GetValue(SegmentedAccess access)
{
return access;
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
var oldBase = this.basePtr;
this.basePtr = null;
var basePtr = Rewrite(access.BasePointer, false);
Constant cEa;
Expression result;
if (access.EffectiveAddress.As(out cEa))
{
uint uOffset = cEa.ToUInt32();
result = RewriteComplexExpression(basePtr, Constant.UInt32(uOffset), 0, true);
}
else
{
this.basePtr = basePtr;
result = Rewrite(access.EffectiveAddress, true);
}
this.basePtr = oldBase;
return result;
}
public virtual void VisitSegmentedAccess(SegmentedAccess access)
{
access.MemoryId.Accept(this);
access.BasePointer.Accept(this);
access.EffectiveAddress.Accept(this);
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
var tmer = new TypedMemoryExpressionRewriter(prog);
return tmer.Rewrite(access);
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
access.EffectiveAddress = access.EffectiveAddress.Accept(this);
if (aem.Match(access.EffectiveAddress))
{
return aem.Transform(access.BasePointer, access.DataType);
}
BinaryExpression bin;
if (access.EffectiveAddress.As(out bin) && bin.Operator == Operator.IAdd)
return access;
if (access.EffectiveAddress is Constant)
return access;
access.EffectiveAddress = AddZeroToEffectiveAddress(access.EffectiveAddress);
return access;
}
public Statement Store(SegmentedAccess s, Expression exp)
{
return Emit(new Store(s, exp));
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
access.BasePointer.Accept(this);
access.EffectiveAddress.Accept(this);
EnsureTypeVariable(access);
}
public bool VisitSegmentedAccess(SegmentedAccess access)
{
access.BasePointer.Accept(this);
access.EffectiveAddress.Accept(this);
return(false);
}
public SlicerResult VisitSegmentedAccess(SegmentedAccess access, BackwardSlicerContext ctx)
{
var sr = access.EffectiveAddress.Accept(this, ctx);
return(sr);
}
public override Expression VisitSegmentedAccess(SegmentedAccess access)
{
if (this.renameFrameAccess && IsFrameAccess(proc, access.EffectiveAddress))
{
var idFrame = EnsureStackVariable(proc, access.EffectiveAddress, access.DataType);
var idNew = NewUse(idFrame, stmCur);
return idNew;
}
return base.VisitSegmentedAccess(access);
}
public Expression GetValue(SegmentedAccess access)
{
throw new NotImplementedException();
}
public void VisitSegmentedAccess(SegmentedAccess access)
{
access.MemoryId.Accept(this);
writer.Write("[");
WriteExpression(access.BasePointer);
writer.Write(":");
WriteExpression(access.EffectiveAddress);
writer.Write(":");
Debug.Assert(access.DataType != null);
writer.Write(access.DataType.ToString());
writer.Write("]");
}
public Statement Store(SegmentedAccess s, Expression exp)
{
return(Emit(new Store(s, exp)));
}
public override void VisitSegmentedAccess(SegmentedAccess access)
{
access.BasePointer.Accept(this);
access.EffectiveAddress.Accept(this);
EnsureTypeVariable(access);
}
public Expression GetValue(SegmentedAccess access)
{
throw new NotImplementedException();
}
public virtual void VisitSegmentedAccess(SegmentedAccess access)
{
access.MemoryId.Accept(this);
access.BasePointer.Accept(this);
access.EffectiveAddress.Accept(this);
}
public void VisitSegmentedAccess(SegmentedAccess access)
{
throw new NotImplementedException();
}
