public void VisitConstant(Constant c)
{
// Globals has a field at offset C that is a tvField: [[g->c]] = ptr(tvField)
int v = StructureField.ToOffset(c) ?? 0;
HandleConstantOffset(c, v);
}
private Expression TransformComplexSum(BinaryExpression binExp, DataType dtLeft, DataType dtRight)
{
if (dtRight.IsComplex)
{
throw new TypeInferenceException(
"Both left and right sides of a binary expression can't be complex types.{0}{1}: {2}:[{3}] {4}:[{5}].",
Environment.NewLine, binExp,
binExp.Left.TypeVariable, dtLeft,
binExp.Right.TypeVariable, dtRight);
}
Constant c = binExp.Right as Constant;
if (c != null)
{
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
binExp.TypeVariable.DataType,
dtLeft,
binExp.Left.TypeVariable.OriginalDataType,
null,
binExp.Left,
null,
StructureField.ToOffset(c));
return(ceb.BuildComplex());
}
return(binExp);
}
public void CreateFieldWithLargeOffset()
{
ushort s = 0xC004;
int off = StructureField.ToOffset(Constant.Word16(s));
Assert.AreEqual(0xC004, off);
}
/// <summary>
/// Handle an expression of type 'id + offset', where id is a LinearInductionVariable.
/// </summary>
/// <param name="id"></param>
/// <param name="iv"></param>
/// <param name="offset"></param>
public void VisitInductionVariable(Identifier id, LinearInductionVariable iv, Constant?cOffset)
{
int delta = iv.Delta !.ToInt32();
int offset = StructureField.ToOffset(cOffset) ?? 0;
var tvBase = basePointer ?? program.Globals;
var stride = Math.Abs(delta);
int init;
if (delta < 0)
{
// induction variable is decremented, so the actual array begins at ivFinal - delta.
if (iv.Final != null)
{
init = iv.Final.ToInt32() - delta;
if (iv.IsSigned)
{
handler.MemAccessArrayTrait(null, tvBase, cOffset !.DataType.Size, init + offset, stride, iv.IterationCount, eField !);
}
else
{
handler.MemAccessArrayTrait(null, tvBase, id.DataType.Size, init + offset, stride, iv.IterationCount, eField !);
}
}
}
else
{
if (iv.Initial != null)
{
init = iv.Initial.ToInt32();
if (iv.IsSigned)
{
handler.MemAccessArrayTrait(null, tvBase, cOffset !.DataType.Size, init + offset, stride, iv.IterationCount, eField !);
}
else
{
handler.MemAccessArrayTrait(null, tvBase, id.DataType.Size, init + offset, stride, iv.IterationCount, eField !);
}
}
}
if (iv.IsSigned)
{
if (cOffset != null)
{
handler.MemSizeTrait(basePointer, cOffset, Math.Abs(delta));
EmitAccessTrait(basePointer, cOffset, cOffset.DataType.Size, 0);
}
}
else
{
handler.MemSizeTrait(basePointer, id, Math.Abs(delta));
EmitAccessTrait(basePointer, id, id.DataType.Size, offset);
}
}
public override void VisitConstant(Constant c)
{
if (!c.IsValid || c is BigConstant)
{
return;
}
DataType dt = c.TypeVariable !.DataType;
int? offset = StructureField.ToOffset(c);
if (offset == null)
{
return;
}
switch (dt)
{
case Pointer ptr:
// C is a constant pointer.
if (offset.Value == 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.Value) == null)
{
if (!IsInsideArray(strGlobals, offset.Value, pointee) &&
!IsInsideStruct(strGlobals, offset.Value))
{
strGlobals.Fields.Add(offset.Value, pointee);
}
}
return;
case MemberPointer mptr:
// C is a constant offset into a segment.
var seg = ((Pointer)mptr.BasePointer).Pointee.ResolveAs <StructureType>();
if (seg != null && //$DEBUG
seg.Fields.AtOffset(offset.Value) == null)
{
seg.Fields.Add(offset.Value, mptr.Pointee);
}
// VisitConstantMemberPointer(offset, mptr);
return;
}
}
public Expression VisitMkSequence(MkSequence seq)
{
var ter = new TypedExpressionRewriter(prog);
//$TODO: identical to TypedExpressionRewriter except for the ceb.Dereferenced statements. How to combine?
var head = seq.Head.Accept(ter);
var tail = seq.Tail.Accept(ter);
Constant c = tail as Constant;
var ptHead = head.TypeVariable.DataType as PrimitiveType;
if (head.TypeVariable.DataType is Pointer || (ptHead != null && ptHead.Domain == Domain.Selector))
{
if (c != null)
{
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
seq.TypeVariable.DataType,
head.DataType,
head.TypeVariable.OriginalDataType,
null,
head,
null,
StructureField.ToOffset(c));
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
else
{
var ceb = new ComplexExpressionBuilder(
seq.TypeVariable.DataType,
seq.TypeVariable.DataType,
seq.TypeVariable.OriginalDataType,
head,
tail,
null,
0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
}
else
{
}
return(new MkSequence(seq.DataType, head, tail));
}
public override void VisitConstant(Constant c)
{
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.Fields.AtOffset(offset) == null)
{
seg.Fields.Add(offset, mptr.Pointee);
}
// VisitConstantMemberPointer(offset, mptr);
}
}
private Expression VisitConstant(Constant c, bool dereferenced)
{
if (basePointer != null)
{
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
dtResult,
basePointer.TypeVariable.DataType,
basePointer.TypeVariable.OriginalDataType,
null,
basePointer,
null,
StructureField.ToOffset(c));
ceb.Dereferenced = dereferenced;
return(ceb.BuildComplex());
}
else
{
return(tcr.Rewrite(c, dereferenced));
}
}
public override Expression VisitMkSequence(MkSequence seq)
{
var head = seq.Head.Accept(this);
var tail = seq.Tail.Accept(this);
Constant c = seq.Tail as Constant;
var ptHead = head.TypeVariable.DataType as PrimitiveType;
if (head.TypeVariable.DataType is Pointer || (ptHead != null && ptHead.Domain == Domain.Selector))
{
if (c != null)
{
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
seq.TypeVariable.DataType,
head.TypeVariable.DataType,
head.TypeVariable.OriginalDataType,
null,
head,
null,
StructureField.ToOffset(c));
return(ceb.BuildComplex());
}
else
{
var ceb = new ComplexExpressionBuilder(
seq.TypeVariable.DataType,
seq.TypeVariable.DataType,
seq.TypeVariable.OriginalDataType,
head,
new MemberPointerSelector(seq.DataType, head, tail),
null,
0);
return(ceb.BuildComplex());
}
}
else
{
}
return(new MkSequence(seq.DataType, head, tail));
}
public void CreateField()
{
int off = StructureField.ToOffset(Constant.Word16(4));
Assert.AreEqual(4, off);
}
public Expression VisitBinaryExpression(BinaryExpression binExp)
{
Expression left = binExp.Left;
Expression right = binExp.Right;
TypeVariable tvLeft = left.TypeVariable;
TypeVariable tvRight = right.TypeVariable;
if (!tvLeft.DataType.IsComplex)
{
if (!tvRight.DataType.IsComplex)
{
throw new NotImplementedException(string.Format("Neither subexpression is complex in {0}: [[{1}]] and [[{2}]]",
binExp,
tvLeft.DataType,
tvRight.DataType));
}
return(VisitBinaryExpression(binExp.Commute()));
}
else if (tvRight.DataType.IsComplex)
{
throw new TypeInferenceException("Both subexpressions are complex in {0}. Left type: {1}, right type {2}",
binExp, tvLeft.DataType, tvRight.DataType);
}
var ter = new TypedExpressionRewriter(prog);
ComplexExpressionBuilder ceb;
Constant cLeft = left as Constant;
if (cLeft != null)
{
binExp.Right = binExp.Right.Accept(ter);
if (basePointer == null)
{
basePointer = globals;
}
ceb = new ComplexExpressionBuilder(
dtResult,
basePointer.TypeVariable.DataType,
basePointer.TypeVariable.OriginalDataType,
null,
basePointer,
binExp.Right,
StructureField.ToOffset(cLeft));
}
else
{
var binLeft = binExp.Left.Accept(ter);
var binRight = binExp.Right.Accept(ter);
var cRight = binRight as Constant;
ceb = new ComplexExpressionBuilder(
binExp.DataType,
tvLeft.DataType,
tvLeft.OriginalDataType,
basePointer,
binLeft,
cRight != null ? null : binRight,
StructureField.ToOffset(binRight as Constant));
}
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}