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 Instruction MakeAssignment(Expression dst, Expression src)
{
var tvDst = dst.TypeVariable;
var tvSrc = src.TypeVariable;
src = src.Accept(this);
DataType dtSrc = DataTypeOf(src);
dst = dst.Accept(this);
DataType dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs <UnionType>();
UnionType uSrc = dtSrc.ResolveAs <UnionType>();
if (uDst != null)
{
var ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex();
}
else if (uSrc != null)
{
var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
src = ceb.BuildComplex();
}
else
{
throw new NotImplementedException(string.Format("{0} [{1}] = {2} [{3}] (in assignment {4} = {5}) not supported.", tvDst, dtDst, tvSrc, dtSrc, dst, src));
}
}
return(new Core.Absyn.AbsynAssignment(dst, src));
}
private Expression RewriteGlobalFieldAccess(
DataType dt,
int offset)
{
var f = GlobalVars !.Fields.LowerBound(offset);
if (f == null || !IsInsideField(offset, f))
{
f = new StructureField(offset, dt);
GlobalVars.Fields.Add(f);
}
if (dereferenced || f.Offset != offset)
{
var ceb = new ComplexExpressionBuilder(
program, null, globals, null, offset);
return(ceb.BuildComplex(dereferenced));
}
//$REVIEW: We can't use ComplexExpresionBuilder to rewrite pointers to
// global variable. It's too aggressive now
// (e.g. &globals->var.ptr00.ptr00 instead of &globals->var)
var name = program.NamingPolicy.GlobalName(f);
var globalVar = Identifier.Global(name, f.DataType);
return(CreateAddrOf(globalVar, dt));
}
public Expression VisitIdentifier(Identifier id)
{
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
dtResult,
id.TypeVariable.DataType,
id.TypeVariable.OriginalDataType,
basePointer, id, null, 0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
public Expression VisitApplication(Application appl)
{
//$BUGBUG: should rewerite the fn and the args too.
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
dtResult,
appl.TypeVariable.DataType,
appl.TypeVariable.OriginalDataType,
basePointer, appl, null, 0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
public Expression RewriteComplexExpression(Expression complex, Expression index, int offset, bool dereferenced)
{
var cOther = index as Constant;
if (cOther != null)
{
offset += (int)cOther.ToUInt32();
index = null;
}
var ceb = new ComplexExpressionBuilder(null, basePtr, complex, index, offset);
return(ceb.BuildComplex(dereferenced));
}
public Expression VisitSegmentedAccess(SegmentedAccess access)
{
var r = new TypedMemoryExpressionRewriter(prog);
var e = r.Rewrite(access);
var ceb = new ComplexExpressionBuilder(
dtResult,
e.DataType,
e.DataType,
basePointer,
e, null, 0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
public Expression VisitMemoryAccess(MemoryAccess access)
{
TypedMemoryExpressionRewriter r = new TypedMemoryExpressionRewriter(prog);
Expression e = r.Rewrite(access);
ComplexExpressionBuilder ceb = new ComplexExpressionBuilder(
dtResult,
e.DataType,
e.DataType,
null,
e, null, 0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
public Expression RewriteComplexExpression(Expression complex, Expression?index, int offset, bool dereferenced)
{
if (index is Constant cOther)
{
//$REVIEW: changing this to:
// offset += cOther.ToInt32() causes a regression.
// This needs further investigation.
offset += (int)cOther.ToUInt32();
index = null;
}
var ceb = new ComplexExpressionBuilder(program, basePtr, complex, index, offset);
return(ceb.BuildComplex(dereferenced));
}
private Instruction MakeAssignment(Expression dst, Expression src)
{
src = src.Accept(this);
var tvDst = dst.TypeVariable;
dst = dst.Accept(this);
var dtSrc = DataTypeOf(src);
var dtDst = DataTypeOf(dst);
if (!TypesAreCompatible(dtSrc, dtDst))
{
UnionType uDst = dtDst.ResolveAs <UnionType>();
UnionType uSrc = dtSrc.ResolveAs <UnionType>();
if (uDst != null)
{
// ceb = new ComplexExpressionBuilder(dtDst, dtDst, dtSrc, null, dst, null, 0);
tvDst.DataType = dtDst;
tvDst.OriginalDataType = dtSrc;
dst.TypeVariable = tvDst;
var ceb = new ComplexExpressionBuilder(dtSrc, null, dst, null, 0);
dst = ceb.BuildComplex(false);
}
else if (uSrc != null)
{
//throw new NotImplementedException();
//var ceb = new ComplexExpressionBuilder(dtSrc, dtSrc, dtDst, null, src, null, 0);
//src = ceb.BuildComplex(false);
src = new Cast(dtDst, src);
}
else
{
Debug.Print("{2} [{0}] = {3} [{1}] not supported.", dtDst, dtSrc, dst, src);
src = new Cast(dtDst, src);
}
}
var idDst = dst as Identifier;
if (idDst != null)
{
return(new Assignment(idDst, src));
}
else
{
return(new Store(dst, src));
}
}
public Expression VisitArrayAccess(ArrayAccess acc)
{
var ter = new TypedExpressionRewriter(prog);
var arr = acc.Array.Accept(ter);
var idx = acc.Index.Accept(ter);
var ceb = new ComplexExpressionBuilder(
acc.TypeVariable.DataType,
acc.Array.TypeVariable.DataType,
acc.Array.TypeVariable.OriginalDataType,
basePointer,
arr,
idx,
0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
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));
}
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));
}
private Expression RewriteGlobalFieldAccess(
DataType dt,
int offset)
{
var f = GlobalVars.Fields.LowerBound(offset);
if (f == null || !IsInsideField(offset, f))
{
f = new StructureField(offset, dt);
GlobalVars.Fields.Add(f);
}
var ptrStr = new Pointer(GlobalVars, platform.PointerType.BitSize);
var fa = new FieldAccess(f.DataType, new Dereference(ptrStr, globals), f);
if (f.Offset != offset)
{
var ceb = new ComplexExpressionBuilder(
null, null, fa, null, offset - f.Offset);
return(ceb.BuildComplex(false));
}
return(fa);
}
public Expression RewriteArrayAccess(TypeVariable typeVariable, Expression arr, Expression idx)
{
var ter = new TypedExpressionRewriter(prog);
basePointer = null;
dtResult = new Pointer(typeVariable.DataType, platform.PointerType.Size);
var dtElement = Dereference(arr.TypeVariable.DataType);
var dtElementOrig = Dereference(arr.TypeVariable.OriginalDataType);
arr = arr.Accept(ter);
idx = idx.Accept(ter);
idx = RescaleIndex(idx, dtElement);
var ceb = new ComplexExpressionBuilder(
dtResult,
dtElement,
dtElementOrig,
basePointer,
new ArrayAccess(dtElement, arr, idx),
null,
0);
ceb.Dereferenced = true;
return(ceb.BuildComplex());
}
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());
}
