/// <summary> /// Checks whether there is a definition from the beginning to the use node /// </summary> /// <param name="fdef"></param> /// <param name="otherDefinedOffsets"></param> /// <returns></returns> private bool HasDefinitionFromRootToUseNode(DUCoverStore dcs, FieldDefUseStore fuse, HashSet <int> otherDefinedOffsets) { DEFUSE_FEASIBILITY_TYPE feasibilityVal; if (this.feasibilityDicCache.TryGetValue(fuse, out feasibilityVal)) { if (feasibilityVal == DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE) { return(false); } else { return(true); } } InstructionGraph ig = dcs.GetInstructionGraph(fuse.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); InstructionVertex iv = ig.GetVertex(fuse.Offset); var result = dft.HasDefClearPathFromBeginning(iv, otherDefinedOffsets); if (result) { this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_FEASIBLE; } else { this.feasibilityDicCache[fuse] = DEFUSE_FEASIBILITY_TYPE.USE_INFEASIBLE; } return(!result); }
/// <summary> /// Removes if there are any infeasible definitions /// </summary> private void RemoveInfeasibleDefs(DUCoverStore dcs) { //There are either zero or one definitions if (this.defDic.Count <= 1) { return; } SafeSet <FieldDefUseStore> infeasibleDefs = new SafeSet <FieldDefUseStore>(); foreach (var fdef in this.defDic.Keys) { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); if (otherFDefOffsets.Count == 0) { continue; } if (HasRedefinition(dcs, fdef, otherFDefOffsets)) { infeasibleDefs.Add(fdef); } } this.defDic.RemoveRange(infeasibleDefs); }
public static DUCoverStore GetInstance() { if (ade == null) { ade = new DUCoverStore(); } return ade; }
public override string ToString() { var dcs = DUCoverStore.GetInstance(); var dicKey = this.DefMethod.FullName + this.DefOffset + "(" + dcs.GetLineNumberOfOffset(this.DefMethod, this.DefOffset) + ")" + "##" + this.UseMethod.FullName + this.UseOffset + "(" + dcs.GetLineNumberOfOffset(this.UseMethod, this.UseOffset) + ")"; return(dicKey); }
public static DUCoverStore GetInstance() { if (ade == null) { ade = new DUCoverStore(); } return(ade); }
/// <summary> /// Populates all pair-wise combinations of defs and uses identified through static analysis /// </summary> public void PopulateDUCoverTable() { DUCoverStore dcs = DUCoverStore.GetInstance(); SafeSet <FieldDefUseStore> allDefs = new SafeSet <FieldDefUseStore>(); allDefs.AddRange(this.DefDic.Keys); allDefs.AddRange(this.DefOrUseSet); SafeSet <FieldDefUseStore> allUses = new SafeSet <FieldDefUseStore>(); allUses.AddRange(this.UseDic.Keys); allUses.AddRange(this.DefOrUseSet); int numInfeasible = 0; //Compute pair-wise combinations foreach (var defEntry in allDefs) { foreach (var useEntry in allUses) { //Ignore the trivial entries that involve just a combination of setter and getter methods if (defEntry.Method.ShortName.StartsWith("set_") && useEntry.Method.ShortName.StartsWith("get_")) { continue; } if (!this.IsFeasibleDUCoverEntry(dcs, defEntry, useEntry)) { numInfeasible++; continue; } DUCoverStoreEntry dcse = new DUCoverStoreEntry(this.fd, defEntry.Method, defEntry.Offset, useEntry.Method, useEntry.Offset); if (defEntry.UnknownSideEffectMethod != null) { dcse.Def_UnknownSideEffectMethod = defEntry.UnknownSideEffectMethod; dcse.DefUnsure = true; } if (useEntry.UnknownSideEffectMethod != null) { dcse.Use_UnknownSideEffectMethod = useEntry.UnknownSideEffectMethod; dcse.UseUnsure = true; } if (!this.duCoverageTable.ContainsKey(dcse)) { this.duCoverageTable[dcse] = 0; } } } //Clear all the cached entries. this.feasibilityDicCache.Clear(); logger.Debug("Detected infeasible du-pairs for field " + this.fd.FullName + "(" + numInfeasible + ")"); }
/// <summary> /// Generates PUTs for all uncovered pairs /// </summary> private static void GeneratePUTsForUncoveredPairs() { DUCoverStore dcs = DUCoverStore.GetInstance(); foreach (var dce in dcs.DeclEntityDic.Values) { dce.GeneratePUTsForNonCoveredDUPairs(); } }
/// <summary> /// Populates entire DUCover tables /// </summary> /// <param name="dcs"></param> public static void PopulateAllDUCoverTables() { DUCoverStore dcs = DUCoverStore.GetInstance(); foreach (var dce in dcs.DeclEntityDic.Values) { dce.PopulateDUCoverTable(); } }
/// <summary> /// Computes du coverage /// </summary> private static void ComputeDUCoverage(out int totalDUPairs, out int coveredDUPairs, out int totalDefs, out int coveredDefs, out int totalUses, out int coveredUses) { DUCoverStore dcs = DUCoverStore.GetInstance(); totalDUPairs = coveredDUPairs = 0; totalDefs = coveredDefs = 0; totalUses = coveredUses = 0; foreach (var dce in dcs.DeclEntityDic.Values) { int tempTotal, tempCovered, temptotalDefs, tempcoveredDefs, temptotalUses, tempcoveredUses; dce.ComputeDUCoverage(out tempTotal, out tempCovered, out temptotalDefs, out tempcoveredDefs, out temptotalUses, out tempcoveredUses); totalDUPairs += tempTotal; coveredDUPairs += tempCovered; totalDefs += temptotalDefs; coveredDefs += tempcoveredDefs; totalUses += temptotalUses; coveredUses += tempcoveredUses; } }
/// <summary> /// Checks whether a definition and use are in different methods /// </summary> /// <param name="dcse"></param> /// <returns></returns> private bool IsFeasibleDUCoverEntry(DUCoverStore dcs, FieldDefUseStore fdef, FieldDefUseStore fuse) { //if (fdef.Method.FullName.Contains("AddVertex") && fuse.Method.FullName.Contains("AddVertex") && fdef.Field.FullName.Contains("m_VertexOutEdges") // && fdef.Offset == 13 && fuse.Offset == 2) //{ // int i = 0; //} //check whether the def and use are in the same method if (fdef.Method.Equals(fuse.Method)) { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); InstructionGraph ig = dcs.GetInstructionGraph(fdef.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); var source = ig.GetVertex(fdef.Offset); var target = ig.GetVertex(fuse.Offset); return(dft.HasDefClearPathBetweenNodes(source, target, otherFDefOffsets)); } else { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasRedefinition(dcs, fdef, otherFDefOffsets)) { return(false); } } otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fuse.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasDefinitionFromRootToUseNode(dcs, fuse, otherFDefOffsets)) { return(false); } } return(true); } }
/// <summary> /// Includes functionality for handling terminating actions /// </summary> public static void Terminate() { //Computes ducoverage int totalDUPairs, coveredDUPairs, totalDefs, coveredDefs, totalUses, coveredUses; ComputeDUCoverage(out totalDUPairs, out coveredDUPairs, out totalDefs, out coveredDefs, out totalUses, out coveredUses); logger.Info("Total number of DUPairs: " + totalDUPairs); logger.Info("Covered DUPairs: " + coveredDUPairs); logger.Info("Def-Use Coverage: " + ((double)coveredDUPairs / (double)totalDUPairs)); logger.Info("Total number of Defs: " + totalDefs); logger.Info("Covered Defs: " + coveredDefs); logger.Info("All-Defs Coverage: " + ((double)coveredDefs / (double)totalDefs)); logger.Info("Total number of Uses: " + totalUses); logger.Info("Covered Uses: " + coveredUses); logger.Info("All-Uses Coverage: " + ((double)coveredUses / (double)totalUses)); //logger.Info("Generating PUTs"); //GeneratePUTsForUncoveredPairs(); DUCoverStore ade = DUCoverStore.GetInstance(); MyFileWriter.DumpAllDeclEntity(ade, totalDUPairs, coveredDUPairs, totalDefs, coveredDefs, totalUses, coveredUses); }
public ThreadTracer(int threadId) : base(threadId) { this.dcs = DUCoverStore.GetInstance(); logger.Info("DUCover Tracer initialized"); }
/// <summary> /// Removes if there are any infeasible definitions /// </summary> private void RemoveInfeasibleDefs(DUCoverStore dcs) { //There are either zero or one definitions if (this.defDic.Count <= 1) return; SafeSet<FieldDefUseStore> infeasibleDefs = new SafeSet<FieldDefUseStore>(); foreach (var fdef in this.defDic.Keys) { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); if (otherFDefOffsets.Count == 0) continue; if (HasRedefinition(dcs, fdef, otherFDefOffsets)) infeasibleDefs.Add(fdef); } this.defDic.RemoveRange(infeasibleDefs); }
/// <summary> /// Checks whether a definition and use are in different methods /// </summary> /// <param name="dcse"></param> /// <returns></returns> private bool IsFeasibleDUCoverEntry(DUCoverStore dcs, FieldDefUseStore fdef, FieldDefUseStore fuse) { //if (fdef.Method.FullName.Contains("AddVertex") && fuse.Method.FullName.Contains("AddVertex") && fdef.Field.FullName.Contains("m_VertexOutEdges") // && fdef.Offset == 13 && fuse.Offset == 2) //{ // int i = 0; //} //check whether the def and use are in the same method if (fdef.Method.Equals(fuse.Method)) { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); InstructionGraph ig = dcs.GetInstructionGraph(fdef.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); var source = ig.GetVertex(fdef.Offset); var target = ig.GetVertex(fuse.Offset); return dft.HasDefClearPathBetweenNodes(source, target, otherFDefOffsets); } else { var otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fdef.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasRedefinition(dcs, fdef, otherFDefOffsets)) return false; } otherFDefOffsets = this.GetOtherDefOffsetsInMethod(fuse.Method, fdef); if (otherFDefOffsets.Count > 0) { if (this.HasDefinitionFromRootToUseNode(dcs, fuse, otherFDefOffsets)) return false; } return true; } }
/// <summary> /// Checks whether the fdef has a redefinition from the current not to the end of the method /// </summary> /// <param name="fdef"></param> /// <param name="otherDefinedOffsets"></param> /// <returns></returns> private bool HasRedefinition(DUCoverStore dcs, FieldDefUseStore fdef, HashSet<int> otherDefinedOffsets) { DEFUSE_FEASIBILITY_TYPE feasibilityVal; if (this.feasibilityDicCache.TryGetValue(fdef, out feasibilityVal)) { if (feasibilityVal == DEFUSE_FEASIBILITY_TYPE.DEF_FEASIBLE) return false; else return true; } InstructionGraph ig = dcs.GetInstructionGraph(fdef.Method); DepthFirstTraversal dft = new DepthFirstTraversal(ig); InstructionVertex iv = ig.GetVertex(fdef.Offset); var result = dft.HasDefClearPathToEnd(iv, otherDefinedOffsets); if (result) this.feasibilityDicCache[fdef] = DEFUSE_FEASIBILITY_TYPE.DEF_FEASIBLE; else this.feasibilityDicCache[fdef] = DEFUSE_FEASIBILITY_TYPE.DEF_INFEASIBLE; return !result; }
public static void DumpAllDeclEntity(DUCoverStore ade, int totalDUPairs, int coveredDUPairs, int totalDefs, int coveredDefs, int totalUses, int coveredUses) { //Dump the dynamic field store that includes information of which method modify which fields try { var filename = DUCoverConstants.DeclEntityFile; using (StreamWriter sw = new StreamWriter(filename)) { sw.WriteLine("Total number of DUPairs: " + totalDUPairs); sw.WriteLine("\tCovered DUPairs: " + coveredDUPairs); sw.WriteLine("\tDef-Use Coverage: " + ((double)coveredDUPairs / (double)totalDUPairs)); sw.WriteLine("Total number of Defs: " + totalDefs); sw.WriteLine("\tCovered Defs: " + coveredDefs); sw.WriteLine("\tAll-Defs Coverage: " + ((double)coveredDefs / (double)totalDefs)); sw.WriteLine("Total number of Uses: " + totalUses); sw.WriteLine("\tCovered Uses: " + coveredUses); sw.WriteLine("\tAll-Uses Coverage: " + ((double)coveredUses / (double)totalUses)); foreach (var de in ade.DeclEntityDic.Values) { sw.WriteLine("ClassName: " + de.ToString()); sw.WriteLine("Total DU pairs: " + de.TotalDUPairs); sw.WriteLine("Covered DU pairs: " + de.CoveredDUPairs); sw.WriteLine("Total defs: " + de.TotalDefs); sw.WriteLine("Covered defs: " + de.CoveredDefs); sw.WriteLine("Total uses: " + de.TotalUses); sw.WriteLine("Covered uses: " + de.CoveredUses); sw.WriteLine(); foreach(var dfe in de.FieldEntities.Values) { sw.WriteLine("\tField: " + dfe.ToString()); sw.WriteLine("\tTotal DU pairs: " + dfe.TotalDUPairs); sw.WriteLine("\tCovered DU pairs: " + dfe.CoveredDUPairs); sw.WriteLine("\tTotal defs: " + dfe.TotalDefs); sw.WriteLine("\tCovered defs: " + dfe.CoveredDefs); sw.WriteLine("\tTotal uses: " + dfe.TotalUses); sw.WriteLine("\tCovered uses: " + dfe.CoveredUses); sw.WriteLine("\tAll Def Entries"); foreach (var defkey in dfe.DefDic.Keys) { sw.WriteLine("\t\t" + defkey.ToString() + " " + dfe.DefDic[defkey]); } sw.WriteLine("\t All Use Entries"); foreach (var usekey in dfe.UseDic.Keys) { sw.WriteLine("\t\t" + usekey.ToString() + " " + dfe.UseDic[usekey]); } sw.WriteLine("\t All DefOrUse (currently unknown) entries"); foreach (var deforusekey in dfe.DefOrUseSet) { sw.WriteLine("\t\t" + deforusekey.ToString()); } sw.WriteLine("\t All Def-Use Entries"); var dudic = dfe.DUCoverageTable; foreach (var defusekey in dudic.Keys) { sw.WriteLine("\t\t" + defusekey + " : " + dudic[defusekey]); } } sw.WriteLine("===================================================="); } } } catch (Exception ex) { logger.ErrorException("Failed to write contents of all declared entities", ex); } }
public DeclClassEntity(TypeEx td) { this.td = td; this.host = DUCoverStore.GetInstance().Host; }