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