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