public override StatementList ReadInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable result) { StatementList stmts = new StatementList(); var boogieType = Helpers.GetBoogieType(result); var readFieldExpr = dispatcher.ReadInstanceField(instanceFieldAccess); if (!Settings.SplitFieldsEnabled()) { if (!Helpers.IsBoogieRefType(Helpers.GetBoogieType(result))) // int, bool, real { var expr = Expression.Union2PrimitiveType(boogieType, readFieldExpr); stmts.Add(bg.VariableAssignment(result, expr)); } else { stmts.Add(bg.VariableAssignment(result, readFieldExpr)); } } else { //p_int:= F$ConsoleApplication3.Holds`1.x[$tmp2]; if (Helpers.IsGenericField(instanceFieldAccess.Field) && !boogieType.Equals(Helpers.BoogieType.Ref)) { stmts.Add(bg.VariableAssignment(result, Expression.Union2PrimitiveType(boogieType, readFieldExpr))); } else { stmts.Add(bg.VariableAssignment(result, readFieldExpr)); } } return(stmts); }
public override Expression ReadInstanceField(InstanceFieldAccess instanceFieldAccess) { var fieldAddr = dispatcher.AddressOf(instanceFieldAccess); var readValue = dispatcher.ReadAddr(fieldAddr); return(readValue); }
private void ProcessLoad(PointsToGraph ptg, uint offset, IVariable dst, InstanceFieldAccess access) { if (dst.Type.IsValueType || access.Type.IsValueType) { return; } ptg.RemoveEdges(dst); var nodes = ptg.GetTargets(access.Instance); foreach (var node in nodes) { var hasField = node.Targets.ContainsKey(access.Field); if (!hasField) { var target = this.GetNode(ptg, offset, dst.Type, PTGNodeKind.Unknown); ptg.PointsTo(node, access.Field, target); } var targets = node.Targets[access.Field]; foreach (var target in targets) { ptg.PointsTo(dst, target); } } }
public static bool MayAlias(this PointsToGraph ptg, InstanceFieldAccess access1, InstanceFieldAccess access2) { var targets1 = ptg.GetTargets(access1); var targets2 = ptg.GetTargets(access2); var alias = targets1.Intersect(targets2); return(alias.Any()); }
public static bool MayAlias(this PointsToGraph ptg, InstanceFieldAccess access, IVariable variable) { var targetsAccess = ptg.GetTargets(access); var targetsVariable = ptg.GetTargets(variable); var alias = targetsAccess.Intersect(targetsVariable); return(alias.Any()); }
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression value, InstructionTranslator instTranslator) { if (RequiresAllocation(instanceFieldAccess)) { return(memAddr.WriteInstanceField(instanceFieldAccess, value, instTranslator)); } else { return(memBCT.WriteInstanceField(instanceFieldAccess, value, instTranslator)); } }
public override Expression ReadInstanceField(InstanceFieldAccess instanceFieldAccess) { if (RequiresAllocation(instanceFieldAccess)) { return(memAddr.ReadInstanceField(instanceFieldAccess)); } else { return(memBCT.ReadInstanceField(instanceFieldAccess)); } }
public override Addressable AddressOf(InstanceFieldAccess instanceFieldAccess) { if (RequiresAllocation(instanceFieldAccess) || instanceFieldAccess.Type is IManagedPointerType) { return(memAddr.AddressOf(instanceFieldAccess)); } else { return(memBCT.AddressOf(instanceFieldAccess)); } }
public override Expression ReadInstanceField(InstanceFieldAccess instanceFieldAccess) { if (!Settings.SplitFieldsEnabled()) { return(ReadFieldExpression.From(new InstanceField(instanceFieldAccess))); } else { return(dispatcher.ReadAddr(dispatcher.AddressOf(instanceFieldAccess))); } }
public override StatementList ReadInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable result) { // with split fields false, i guess we should cast to union always Contract.Assert(Settings.SplitFieldsEnabled()); Expression readExpr = ReadInstanceField(instanceFieldAccess); if (Helpers.IsGenericField(instanceFieldAccess.Field)) { if (!Helpers.IsBoogieRefType(result)) { var boogieType = Helpers.GetBoogieType(result); return(bg.VariableAssignment(result, Expression.Union2PrimitiveType(boogieType, readExpr))); } } return(bg.VariableAssignment(result, readExpr)); }
private void ProcessStore(PointsToGraph ptg, InstanceFieldAccess access, IVariable src) { if (access.Type.IsValueType || src.Type.IsValueType) { return; } var nodes = ptg.GetTargets(access.Instance); var targets = ptg.GetTargets(src); foreach (var node in nodes) { foreach (var target in targets) { ptg.PointsTo(node, access.Field, target); } } }
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression expr, InstructionTranslator instTranslator) { StatementList stmts = new StatementList(); var boogieType = expr.Type; if (Helpers.IsGenericField(instanceFieldAccess.Field) && !boogieType.Equals(Helpers.BoogieType.Object)) { stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr)); stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie()))); } else { stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr)); } return(stmts); }
public override StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression expr, InstructionTranslator instTranslator) { StatementList stmts = new StatementList(); String fieldName = FieldTranslator.GetFieldName(instanceFieldAccess.Field); //var addr = AddressOf(instanceFieldAccess); //var writeAddr = WriteAddr(addr, value); if (!Settings.SplitFieldsEnabled()) { if (!Helpers.IsBoogieRefType(expr.Type)) // int, bool, real { stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr)); stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie()))); //sb.AppendLine(String.Format("\t\t$Heap := Write($Heap, {0}, {1}, {2});", instanceFieldAccess.Instance, fieldName, PrimitiveType2Union(Helpers.GetBoogieType(value.Type), value.Name))); } else { stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr)); //sb.AppendLine(String.Format("\t\t$Heap := Write($Heap, {0}, {1}, {2});", instanceFieldAccess.Instance, fieldName, value.Name)); } } else { var boogieType = expr.Type; // var heapAccess = String.Format("{0}[{1}]", fieldName, instanceFieldAccess.Instance); //F$ConsoleApplication3.Foo.p[f_Ref] := $ArrayContents[args][0]; if (Helpers.IsGenericField(instanceFieldAccess.Field) && !boogieType.Equals(Helpers.BoogieType.Ref)) { stmts.Add(Expression.AssumeInverseRelationUnionAndPrimitiveType(expr)); //sb.AppendLine(VariableAssignment(heapAccess, PrimitiveType2Union(boogieType, value.Name))); stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), Expression.PrimitiveType2Union(expr, instTranslator.Boogie()))); } else { stmts.Add(dispatcher.WriteAddr(dispatcher.AddressOf(instanceFieldAccess), expr)); } } return(stmts); }
public override StatementList ReadInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable result) { var readValue = dispatcher.ReadInstanceField(instanceFieldAccess); // dependiendo del type (del result?) indexo en el $memoryInt if (Helpers.IsGenericField(instanceFieldAccess.Field)) { var boogieType = Helpers.GetBoogieType(result); if (!boogieType.Equals(Helpers.BoogieType.Object)) { return(bg.VariableAssignment(result, Expression.Union2PrimitiveType(boogieType, readValue))); } else { return(bg.VariableAssignment(result, readValue)); } } else { return(bg.VariableAssignment(result, readValue)); } }
public abstract StatementList ReadInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable result);
// some field initialization can be missing in constructors // example: /* * class Foo{ * int x; // this initialization is not added by the compiler * int y = y; * } */ // therefore we are adding the initialization for each field at the top of every constructor. public void Transform() { // these variables hold the default value IDictionary <Helpers.BoogieType, LocalVariable> boogieTypeToLocalVariable = new Dictionary <Helpers.BoogieType, LocalVariable>(); // they are the same stored in boogieTypeToLocalVariable IList <LocalVariable> variables = new List <LocalVariable>(); // assignment of constants IList <Instruction> instructions = new List <Instruction>(); CreateLocalVariablesWithDefaultValues(boogieTypeToLocalVariable, variables, instructions); // we need to initialize local variables. foreach (var lv in methodBody.Variables) { if (lv.IsParameter || // in the delegate handling this type of variables are not used // calling get boogie type will crash lv.Type is Microsoft.Cci.Immutable.FunctionPointerType || (lv.Type is IManagedPointerType && Settings.AddressesEnabled())) { continue; } var varBoogieType = Helpers.GetBoogieType(lv.Type); IVariable initialValue = boogieTypeToLocalVariable[varBoogieType]; var storeInstruction = new LoadInstruction(0, lv, initialValue); storeInstruction.Label = String.Empty; instructions.Add(storeInstruction); } if (methodBody.MethodDefinition.IsConstructor) { IEnumerable <IFieldDefinition> fields = null; if (methodBody.MethodDefinition.ContainingTypeDefinition.IsGeneric) { /* * This solves the issue of having a generic class (ie. class A<T>) and mismatches between field names. * If we just use ContaingTypeDefinition.Fields we have have a different IFieldDefinition than the ones found in the method bodies * Here, I want to be sure that we use A<T>.field as a field definition and not A.field * However, this could not be the ultimate solution and there could be a better way to tackle it. */ var instanceOrSpecialized = TypeHelper.GetInstanceOrSpecializedNestedType(methodBody.MethodDefinition.ContainingTypeDefinition); fields = instanceOrSpecialized.Fields; } else { fields = methodBody.MethodDefinition.ContainingTypeDefinition.Fields; } var thisVariable = methodBody.Parameters[0]; foreach (IFieldDefinition field in fields.Where(f => !f.IsStatic)) { var fieldBoogieType = Helpers.GetBoogieType(field.Type); IVariable initialValue = boogieTypeToLocalVariable[fieldBoogieType]; var instanceAccess = new InstanceFieldAccess(thisVariable, field); var storeInstruction = new StoreInstruction(0, instanceAccess, initialValue); storeInstruction.Label = String.Empty; instructions.Add(storeInstruction); } } methodBody.Variables.UnionWith(variables); int idx = 0; foreach (var i in instructions) { methodBody.Instructions.Insert(idx, i); idx++; } }
public override Addressable AddressOf(InstanceFieldAccess instanceFieldAccess) { var expr = Expression.LoadInstanceFieldAddr(instanceFieldAccess.Field, dispatcher.ReadAddr(instanceFieldAccess.Instance)); return(new AddressExpression(instanceFieldAccess.Field.Type, expr)); }
public static ISet <PTGNode> GetTargets(this PointsToGraph ptg, InstanceFieldAccess access) { var result = ptg.GetTargets(access.Instance, access.Field); return(result); }
//public abstract Addressable AddressOf(IReferenceable value); //public abstract Addressable AddressOf(IValue value); public abstract Addressable AddressOf(InstanceFieldAccess instanceFieldAccess);
public override Addressable AddressOf(InstanceFieldAccess instanceFieldAccess) { return(new InstanceField(instanceFieldAccess)); }
public abstract Expression ReadInstanceField(InstanceFieldAccess instanceFieldAccess);
// some field initialization can be missing in constructors // example: /* * class Foo{ * int x; // this initialization is not added by the compiler * int y = y; * } */ // therefore we are adding the initialization for each field at the top of every constructor. public void Transform() { // these variables hold the default value IDictionary <Helpers.BoogieType, LocalVariable> boogieTypeToLocalVariable = new Dictionary <Helpers.BoogieType, LocalVariable>(); // they are the same stored in boogieTypeToLocalVariable IList <LocalVariable> variables = new List <LocalVariable>(); // assignment of constants IList <Instruction> instructions = new List <Instruction>(); CreateLocalVariablesWithDefaultValues(boogieTypeToLocalVariable, variables, instructions); // we need to initialize local variables. foreach (var lv in methodBody.Variables) { if (lv.IsParameter || // in the delegate handling this type of variables are not used // calling get boogie type will crash lv.Type is Microsoft.Cci.Immutable.FunctionPointerType) { continue; } var varBoogieType = Helpers.GetBoogieType(lv); IVariable initialValue = boogieTypeToLocalVariable[varBoogieType]; var storeInstruction = new LoadInstruction(0, lv, initialValue); storeInstruction.Label = String.Empty; instructions.Add(storeInstruction); } var fields = methodBody.MethodDefinition.ContainingTypeDefinition.Fields; if (methodBody.MethodDefinition.IsStaticConstructor) { foreach (IFieldDefinition field in fields.Where(f => f.IsStatic)) { var fieldBoogieType = Helpers.GetBoogieType(field); IVariable initialValue = boogieTypeToLocalVariable[fieldBoogieType]; var staticAccess = new StaticFieldAccess(field); var storeInstruction = new StoreInstruction(0, staticAccess, initialValue); storeInstruction.Label = String.Empty; instructions.Add(storeInstruction); } } else if (methodBody.MethodDefinition.IsConstructor) { var thisVariable = methodBody.Parameters[0]; foreach (IFieldDefinition field in fields.Where(f => !f.IsStatic)) { var fieldBoogieType = Helpers.GetBoogieType(field); IVariable initialValue = boogieTypeToLocalVariable[fieldBoogieType]; var instanceAccess = new InstanceFieldAccess(thisVariable, field); var storeInstruction = new StoreInstruction(0, instanceAccess, initialValue); storeInstruction.Label = String.Empty; instructions.Add(storeInstruction); } } methodBody.Variables.UnionWith(variables); int idx = 0; foreach (var i in instructions) { methodBody.Instructions.Insert(idx, i); idx++; } }
public abstract StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, Expression value, InstructionTranslator instTranslator);
public StatementList WriteInstanceField(InstanceFieldAccess instanceFieldAccess, IVariable value, InstructionTranslator instTranslator) { return(WriteInstanceField(instanceFieldAccess, ReadAddr(value), instTranslator)); }
public void VisitMethod(MethodBody mBody, ControlFlowGraph cfg) { VisitLocals(mBody); // Going through the instructions via cfg nodes instead of directly iterating over the instructions // of the methodBody becuase Phi instructions may not have been inserted in the insts of the methodBody. foreach (var node in cfg.Nodes) { foreach (var instruction in node.Instructions) { // System.Console.WriteLine("{0}", instruction.ToString()); // System.Console.WriteLine("{0}", instruction.GetType().FullName()); // System.Console.WriteLine(); if (instruction is LoadInstruction) { LoadInstruction lInst = instruction as LoadInstruction; IValue rhsOperand = lInst.Operand; if (rhsOperand is StaticFieldAccess) { StaticFieldAccess rhsAcc = rhsOperand as StaticFieldAccess; IFieldReference fld = rhsAcc.Field; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); } // Note: calls to static methods and instance methods appear as a StaticMethodReference else if (rhsOperand is StaticMethodReference) { StaticMethodReference sMethAddr = rhsOperand as StaticMethodReference; IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod; ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition; Stubber.CheckAndAdd(containingTy); IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth); // addrTakenMethods do not contain templates. if (addedMeth != null) { addrTakenMethods.Add(addedMeth); } } //Note: calls to virtual, abstract or interface methods appear as VirtualMethodReference else if (rhsOperand is VirtualMethodReference) { VirtualMethodReference sMethAddr = rhsOperand as VirtualMethodReference; IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod; ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition; ITypeDefinition addedTy = Stubber.CheckAndAdd(containingTy); IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth); if (addedTy != null && addedMeth != null) { // addrTakenMethods do not contain templates. addrTakenMethods.Add(addedMeth); ProcessVirtualInvoke(addedMeth, addedTy, true); } } else if (rhsOperand is Reference) { Reference rhsRef = rhsOperand as Reference; IReferenceable refOf = rhsRef.Value; if (refOf is StaticFieldAccess) { StaticFieldAccess refAcc = refOf as StaticFieldAccess; IFieldDefinition fld = refAcc.Field.ResolvedField; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); addrTakenStatFlds.Add(fld); } else if (refOf is IVariable) { IVariable refVar = refOf as IVariable; if (!refVar.Type.IsValueType || refVar.Type.ResolvedType.IsStruct) { addrTakenLocals.Add(refVar); } } else if (refOf is InstanceFieldAccess) { InstanceFieldAccess refAcc = refOf as InstanceFieldAccess; IFieldDefinition fld = refAcc.Field.ResolvedField; addrTakenInstFlds.Add(fld); } else if (refOf is ArrayElementAccess) { // All arrays will be added into domX as potential address taken. } } } else if (instruction is StoreInstruction) { StoreInstruction sInst = instruction as StoreInstruction; IAssignableValue lhs = sInst.Result; if (lhs is StaticFieldAccess) { StaticFieldAccess lhsAcc = lhs as StaticFieldAccess; IFieldReference fld = lhsAcc.Field; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); } } else if (instruction is CreateObjectInstruction) { CreateObjectInstruction newObjInst = instruction as CreateObjectInstruction; ITypeReference objType = newObjInst.AllocationType; ITypeDefinition objTypeDef = objType.ResolvedType; if (objTypeDef is IGenericTypeInstance) { objTypeDef = objTypeDef.ResolvedType; } ITypeDefinition addedTy = Stubber.CheckAndAdd(objTypeDef); if (addedTy != null && !allocClasses.Contains(addedTy)) { allocClasses.Add(addedTy); } } else if (instruction is CreateArrayInstruction) { CreateArrayInstruction newArrInst = instruction as CreateArrayInstruction; ITypeReference elemType = newArrInst.ElementType; ITypeDefinition elemTypeDef = elemType.ResolvedType; ITypeDefinition addedTy = Stubber.CheckAndAdd(elemTypeDef); if (addedTy != null && !allocClasses.Contains(addedTy)) { allocClasses.Add(addedTy); } } else if (instruction is MethodCallInstruction) { MethodCallInstruction invkInst = instruction as MethodCallInstruction; IMethodReference callTgt = invkInst.Method; ITypeReference containingType = callTgt.ContainingType; ITypeDefinition declType = containingType.ResolvedType; IMethodDefinition callTgtDef = callTgt.ResolvedMethod; ITypeDefinition addedType = Stubber.CheckAndAdd(declType); IMethodDefinition addedMeth = Stubber.CheckAndAdd(callTgtDef); MethodCallOperation callType = invkInst.Operation; if (callType == MethodCallOperation.Virtual && addedType != null && addedMeth != null) { ProcessVirtualInvoke(addedMeth, addedType, false); } } else { // System.Console.WriteLine("{0}", instruction.ToString()); // System.Console.WriteLine("Not currently handled: {0}", instruction.GetType().ToString()); // System.Console.WriteLine(); } } } }