/// <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");
}
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;
}
