public bool VisitDepositBits(DepositBits d, TypeVariable tv)
{
MeetDataType(d, tv.DataType);
d.Source.Accept(this, d.Source.TypeVariable);
d.InsertedBits.Accept(this, d.InsertedBits.TypeVariable);
return(false);
}
public bool Match(DepositBits dpb)
{
this.dpbUse = dpb;
if (!(dpb.Source is Identifier idDef))
{
return(false);
}
var stms = ctx.GetDefiningStatementClosure(idDef);
if (stms.Count == 0)
{
return(false);
}
var items = stms.Select(GetDpbDetails).ToList();
var first = items[0].idSrc;
if (items.All(i => i.idSrc != null && i.idSrc == first && i.dpbDef.BitPosition == dpbUse.BitPosition))
{
this.idDef = idDef;
this.idSrc = items[0].idSrc;
return(true);
}
else
{
return(false);
}
}
public bool Match(DepositBits dpb)
{
this.dpbUse = dpb;
if (!(dpb.Source is Identifier idDef))
{
return(false);
}
var expDef = ctx.GetDefiningExpression(idDef);
if (expDef == null)
{
return(false);
}
if (!(expDef is DepositBits dpbDef))
{
return(false);
}
if (!(dpbDef.Source is Identifier idSrc))
{
return(false);
}
this.idDef = idDef;
this.dpbDef = dpbDef;
this.idSrc = idSrc;
return(dpbDef.BitPosition == dpbUse.BitPosition);
}
public virtual Expression VisitDepositBits(DepositBits d)
{
var src = d.Source.Accept(this);
var bits = d.InsertedBits.Accept(this);
return(new DepositBits(src, bits, d.BitPosition));
}
public bool Match(DepositBits dpb)
{
this.dpbUse = dpb;
if (!dpb.Source.As(out idDef))
{
return(false);
}
var expDef = ctx.GetDefiningExpression(idDef);
if (expDef == null)
{
return(false);
}
if (!expDef.As(out dpbDef))
{
return(false);
}
if (!dpbDef.Source.As(out idSrc))
{
return(false);
}
return
(dpbDef.BitCount == dpbUse.BitCount &&
dpbDef.BitPosition == dpbUse.BitPosition);
}
public SlicerResult VisitDepositBits(DepositBits d, BackwardSlicerContext ctx)
{
var srSrc = d.Source.Accept(this, ctx);
var brBits = RangeOf(d.InsertedBits);
var srBits = d.InsertedBits.Accept(this, new BackwardSlicerContext(ctx.Type, brBits));
if (brBits == ctx.BitRange)
{
return(new SlicerResult
{
SrcExpr = d.InsertedBits,
LiveExprs = srBits.LiveExprs
});
}
else
{
return(new SlicerResult
{
SrcExpr = new DepositBits(d.Source, d.InsertedBits, d.BitPosition),
LiveExprs = srSrc.LiveExprs.Concat(srBits.LiveExprs)
.GroupBy(e => e.Key)
.ToDictionary(k => k.Key, v => v.Max(vv => vv.Value)),
});
}
}
public virtual Expression VisitDepositBits(DepositBits d)
{
var src = d.Source.Accept(this);
var bits = d.InsertedBits.Accept(this);
if (src == Constant.Invalid || bits == Constant.Invalid)
{
return(Constant.Invalid);
}
d = new DepositBits(src, bits, d.BitPosition);
while (dpbdpbRule.Match(d))
{
Changed = true;
d = dpbdpbRule.Transform();
}
if (dpbConstantRule.Match(d))
{
Changed = true;
return(dpbConstantRule.Transform());
}
if (selfdpbRule.Match(d))
{
Changed = true;
return(selfdpbRule.Transform());
}
return(d);
}
/// <summary>
/// Creates an instruction:
/// a = foo(b)
/// or
/// foo(b)
/// depending on whether the signature returns a value or is of
/// type 'void'
/// </summary>
/// <returns></returns>
public Instruction CreateInstruction()
{
var idOut = BindReturnValue();
var dtOut = sigCallee.ReturnValue != null
? sigCallee.ReturnValue.DataType
: VoidType.Instance;
var actuals = BindArguments(frame, sigCallee);
Expression appl = new Application(
callee,
dtOut,
actuals.ToArray());
if (idOut == null)
{
return(new SideEffect(appl));
}
else
{
if (idOut.DataType.Size > sigCallee.ReturnValue.DataType.Size)
{
appl = new DepositBits(idOut, appl, 0);
}
return(new Assignment(idOut, appl));
}
}
public bool Match(DepositBits dpb)
{
if (dpb.BitPosition != 0)
{
return(false);
}
this.e = dpb.Source as Identifier;
if (e == null)
{
return(false);
}
var c = dpb.InsertedBits as Cast;
if (c != null)
{
idUnused = e;
return(e == c.Expression);
}
if (!(dpb.InsertedBits is Identifier idBits))
{
return(false);
}
if (!(ctx.GetValue(idBits) is Cast cid))
{
return(false);
}
this.idUnused = idBits;
return(e == cid.Expression);
}
public Expression VisitDepositBits(DepositBits d)
{
return(new DepositBits(
d.Source.Accept(this),
d.InsertedBits.Accept(this),
d.BitPosition));
}
public bool VisitDepositBits(DepositBits d)
{
var dead = d.InsertedBits.Accept(this);
dead &= d.Source.Accept(this);
return(dead);
}
public BitRange VisitDepositBits(DepositBits d)
{
// The bits being inserted into, d.Source, are "inert"
var br = d.InsertedBits.Accept(this);
return(new BitRange(br.Lsb + d.BitPosition, br.Msb + d.BitPosition));
}
public override void VisitDepositBits(DepositBits d)
{
// Only use the inserted bits; the source bits are
// not strictly used by a DPB instruction.
bitUseOffset = 0;
cbitsUse = 0;
d.InsertedBits.Accept(this);
}
void IExpressionVisitor.VisitDepositBits(DepositBits d)
{
writer.Write("Dpb(");
d.Source.Accept(this);
writer.Write(", ");
d.InsertedBits.Accept(this);
writer.Write(", {0}, {1})", d.BitPosition, d.BitCount);
}
public void VisitDepositBits(DepositBits d)
{
writer.Write("DPB(");
WriteExpression(d.Source);
writer.Write(", ");
WriteExpression(d.InsertedBits);
writer.Write(", {0})", d.BitPosition);
}
void IExpressionVisitor.VisitDepositBits(DepositBits d)
{
Method("Dpb");
d.Source.Accept(this);
writer.Write(", ");
d.InsertedBits.Accept(this);
writer.Write(", {0})", d.BitPosition);
}
public Result VisitDepositBits(DepositBits dpb)
{
var d = new DepositBits(
dpb.Source.Accept(this).PropagatedExpression,
dpb.InsertedBits.Accept(this).PropagatedExpression,
dpb.BitPosition);
return(SimplifyExpression(d));
}
public DataType VisitDepositBits(DepositBits d)
{
d.Source.Accept(this);
d.InsertedBits.Accept(this);
var dt = handler.DataTypeTrait(d, d.DataType);
ivCur = null;
return(dt);
}
public bool Match(DepositBits dpb)
{
this.dpb = dpb;
cSrc = dpb.Source as Constant;
if (cSrc == null)
return false;
cBits = dpb.InsertedBits as Constant;
if (cBits != null)
return true;
return (cSrc.ToInt32() == 0 && dpb.BitPosition == 0);
}
public DataType VisitDepositBits(DepositBits d)
{
var dtSource = d.Source.Accept(this);
var dtBits = d.InsertedBits.Accept(this);
if (d.TypeVariable.DataType == null)
{
d.TypeVariable.DataType = dtSource;
d.TypeVariable.OriginalDataType = dtSource;
}
return(d.TypeVariable.DataType);
}
/// <summary>
/// Inserts an alias statement.
/// </summary>
/// <param name="v">Variable that has been defined</param>
/// <param name="vAlias">Other variable that is aliased by v</param>
/// <param name="iAt"></param>
// If a wide register is being defined by aliasing of a smaller
// register, the expression needs to take into account the previous
// value of the wide register. For instance, modifying cl aliases
// cx = f(cl, cx)
// thus:
// mov cl,xx
// mov cx,DPB(cx,cl,0,8)
public Assignment CreateAliasInstruction(Identifier varFrom, Identifier varTo) // Identifier v, Identifier vAlias)
{
if (!IsAlias(arch, varFrom, varTo))
{
throw new ApplicationException(string.Format("Unexpected alias pair {0} and {1}", varTo.Name, varFrom.Name));
}
Expression aliasExpr;
int offsetTo = varTo.Storage.OffsetOf(varFrom.Storage);
int offsetFrom = varFrom.Storage.OffsetOf(varTo.Storage);
int cbitsFrom = varFrom.DataType.BitSize;
int cbitsTo = varTo.DataType.BitSize;
if (cbitsFrom < cbitsTo)
{
// We are replacing a part of a wider register with a narrower one.
SequenceStorage seq = varTo.Storage as SequenceStorage;
if (seq != null && (seq.Head == varFrom.Storage || seq.Tail == varFrom.Storage))
{
aliasExpr = new MkSequence(
varTo.DataType,
proc.Frame.EnsureIdentifier(seq.Head),
proc.Frame.EnsureIdentifier(seq.Tail));
}
else
{
aliasExpr = new DepositBits(varTo, varFrom, offsetTo);
}
}
else if (cbitsFrom > cbitsTo)
{
if (offsetFrom == 0)
{
aliasExpr = new Cast(varTo.DataType, varFrom);
}
else
{
aliasExpr = new Slice(varTo.DataType, varFrom, offsetFrom);
}
}
else
{
aliasExpr = varFrom;
}
return(new AliasAssignment(varTo, aliasExpr));
}
public bool Match(DepositBits dpb)
{
this.dpb = dpb;
cSrc = dpb.Source as Constant;
if (cSrc == null)
{
return(false);
}
cBits = dpb.InsertedBits as Constant;
if (cBits != null)
{
return(true);
}
return(cSrc.ToInt32() == 0 && dpb.BitPosition == 0);
}
public bool Match(DepositBits dpb)
{
this.dpbUse = dpb;
if (!dpb.Source.As(out idDef))
return false;
var expDef = ctx.GetDefiningExpression(idDef);
if (expDef == null)
return false;
if (!expDef.As(out dpbDef))
return false;
if (!dpbDef.Source.As(out idSrc))
return false;
return
dpbDef.BitPosition == dpbUse.BitPosition;
}
public virtual Expression VisitDepositBits(DepositBits d)
{
d.Source = d.Source.Accept(this);
d.InsertedBits = d.InsertedBits.Accept(this);
if (dpbConstantRule.Match(d))
{
Changed = true;
return(dpbConstantRule.Transform());
}
if (dpbdpbRule.Match(d))
{
Changed = true;
return(dpbdpbRule.Transform());
}
return(d);
}
public Expression VisitDepositBits(DepositBits d)
{
var source = d.Source.Accept(this);
if (source == Constant.Invalid)
{
return(source);
}
var inserted = d.InsertedBits.Accept(this);
if (inserted == Constant.Invalid)
{
return(inserted);
}
return(new DepositBits(source, inserted, d.BitPosition));
}
public bool Match(DepositBits dpb)
{
if (dpb.BitPosition != 0)
{
return(false);
}
this.e = dpb.Source as Identifier;
if (e == null)
{
return(false);
}
var c = dpb.InsertedBits as Cast;
if (c == null)
{
return(false);
}
return(e == c.Expression);
}
public bool Match(DepositBits dpb)
{
this.dpb = dpb;
if (!(dpb.Source.DataType is PrimitiveType pt) || pt.Domain == Domain.Real)
{
return(false);
}
if (!(dpb.InsertedBits.DataType is PrimitiveType ptIns) || ptIns.Domain == Domain.Real)
{
return(false);
}
cSrc = dpb.Source as Constant;
if (cSrc == null)
{
return(false);
}
cBits = dpb.InsertedBits as Constant;
if (cBits != null)
{
return(true);
}
return(cSrc.ToInt32() == 0 && dpb.BitPosition == 0);
}
public ValueSet VisitDepositBits(DepositBits d)
{
throw new NotImplementedException();
}
public void VisitDepositBits(DepositBits dpb)
{
handler.MemAccessTrait(basePointer, dpb, dpb.DataType.Size, eField, 0);
}
public override void VisitDepositBits(DepositBits d)
{
d.Source.Accept(this);
d.InsertedBits.Accept(this);
EnsureTypeVariable(d);
}
public virtual void VisitDepositBits(DepositBits d)
{
d.Source.Accept(this);
d.InsertedBits.Accept(this);
}
public void VisitDepositBits(DepositBits d)
{
writer.Write("DPB(");
WriteExpression(d.Source);
writer.Write(", ");
WriteExpression(d.InsertedBits);
writer.Write(", {0})", d.BitPosition);
}
public DataType VisitDepositBits(DepositBits d)
{
throw new NotImplementedException();
}
public override void VisitDepositBits(DepositBits d)
{
d.Source.Accept(this);
d.InsertedBits.Accept(this);
EnsureTypeVariable(d);
}
public virtual void VisitDepositBits(DepositBits d)
{
d.Source.Accept(this);
d.InsertedBits.Accept(this);
}
public Expression VisitDepositBits(DepositBits d)
{
throw new NotImplementedException();
}
