private bool TryMakeLoop(IntervalConstruct interval, DominatorTree dominatorTree)
{
V_0 = DFSTBuilder.BuildTree(interval);
if (V_0.get_BackEdges().get_Count() == 0)
{
return(false);
}
V_2 = this.BuildLoop(V_0, out V_1);
V_4 = this.DetermineLoopType(V_1, V_2, interval, dominatorTree, out V_3);
if (V_1.get_Count() > 0)
{
V_5 = new LoopLogicalConstruct(interval.get_Entry() as ILogicalConstruct, V_1, V_4, V_3, this.typeSystem);
this.CleanUpEdges(V_5);
this.UpdateDominatorTree(dominatorTree, V_5);
return(true);
}
V_6 = V_0.get_BackEdges().GetEnumerator();
try
{
while (V_6.MoveNext())
{
V_7 = V_6.get_Current();
this.MarkAsGotoEdge(V_7.get_Start().get_Construct() as ILogicalConstruct, V_7.get_End().get_Construct() as ILogicalConstruct);
}
}
finally
{
((IDisposable)V_6).Dispose();
}
return(false);
}
private void CleanUpEdges(LoopLogicalConstruct loopConstruct)
{
V_0 = DFSTBuilder.BuildTree(loopConstruct.get_Parent()).get_ConstructToNodeMap().get_Item(loopConstruct);
if (V_0.get_BackEdgeSuccessors().get_Count() == 0)
{
return;
}
V_1 = V_0.get_BackEdgeSuccessors().GetEnumerator();
try
{
while (V_1.MoveNext())
{
V_2 = V_1.get_Current();
if (V_2.get_Construct() as ILogicalConstruct as ConditionLogicalConstruct != null)
{
continue;
}
this.MarkAsGotoEdge(loopConstruct, V_2.get_Construct() as ILogicalConstruct);
}
}
finally
{
((IDisposable)V_1).Dispose();
}
return;
}
/// <summary>
/// Analyzes <paramref name="interval"/> and makes a loop from it, if possible.
/// </summary>
/// <param name="interval">The interval to be analyzed.</param>
/// <returns>Returns true if a loop was made.</returns>
private bool TryMakeLoop(IntervalConstruct interval, DominatorTree dominatorTree)
{
DFSTree dfsTree = DFSTBuilder.BuildTree(interval);
if (dfsTree.BackEdges.Count == 0)
{
/// No back edges in the interval, so no loop can be made.
return(false);
}
HashSet <ILogicalConstruct> loopBody;
HashSet <ILogicalConstruct> possibleLatchingNodes = BuildLoop(dfsTree, out loopBody);
ConditionLogicalConstruct loopCondition;
LoopType typeOfLoop = DetermineLoopType(loopBody, possibleLatchingNodes, interval, dominatorTree, out loopCondition);
if (loopBody.Count > 0)
{
LoopLogicalConstruct loop = new LoopLogicalConstruct(interval.Entry as ILogicalConstruct, loopBody, typeOfLoop, loopCondition, typeSystem);
CleanUpEdges(loop); /// Covers the case in IrregularbackedgeExitLoop
UpdateDominatorTree(dominatorTree, loop);
return(true);
}
else
{
/// Empty loops should not be created. Instead, backedges that form such loops will be marked as goto.
foreach (DFSTEdge backedge in dfsTree.BackEdges)
{
MarkAsGotoEdge(backedge.Start.Construct as ILogicalConstruct, backedge.End.Construct as ILogicalConstruct);
}
}
return(false);
}
private void UpdateDominatorTree(DominatorTree dominatorTree, LoopLogicalConstruct theLoopConstruct)
{
HashSet <ISingleEntrySubGraph> loopNodes = new HashSet <ISingleEntrySubGraph>();
if (theLoopConstruct.LoopCondition != null)
{
loopNodes.Add(theLoopConstruct.LoopCondition);
}
if (theLoopConstruct.LoopBodyBlock != null)
{
loopNodes.UnionWith(theLoopConstruct.LoopBodyBlock.Children);
}
ISingleEntrySubGraph loopEntry = (theLoopConstruct.LoopType == LoopType.PreTestedLoop) ? theLoopConstruct.LoopCondition : theLoopConstruct.LoopBodyBlock.Entry;
dominatorTree.MergeNodes(loopNodes, loopEntry, theLoopConstruct);
}
/// <summary>
/// Removes backedges exiting from <paramref name="loopConstruct"/>.
/// </summary>
/// <param name="loopConstruct">The loop construct.</param>
private void CleanUpEdges(LoopLogicalConstruct loopConstruct)
{
DFSTree dfsTree = DFSTBuilder.BuildTree(loopConstruct.Parent);
DFSTNode loopNode = dfsTree.ConstructToNodeMap[loopConstruct];
if (loopNode.BackEdgeSuccessors.Count == 0)
{
return;
}
foreach (DFSTNode backedgeSuccessor in loopNode.BackEdgeSuccessors)
{
ILogicalConstruct edgeEndConstruct = backedgeSuccessor.Construct as ILogicalConstruct;
if (!(edgeEndConstruct is ConditionLogicalConstruct)) /// if the target is ConditionLogicalConstruct, it can probably be a header of outer loop
{
MarkAsGotoEdge(loopConstruct, backedgeSuccessor.Construct as ILogicalConstruct);
}
}
}
private void UpdateDominatorTree(DominatorTree dominatorTree, LoopLogicalConstruct theLoopConstruct)
{
V_0 = new HashSet <ISingleEntrySubGraph>();
if (theLoopConstruct.get_LoopCondition() != null)
{
dummyVar0 = V_0.Add(theLoopConstruct.get_LoopCondition());
}
if (theLoopConstruct.get_LoopBodyBlock() != null)
{
V_0.UnionWith(theLoopConstruct.get_LoopBodyBlock().get_Children());
}
if (theLoopConstruct.get_LoopType() == 1)
{
stackVariable10 = theLoopConstruct.get_LoopCondition();
}
else
{
stackVariable10 = theLoopConstruct.get_LoopBodyBlock().get_Entry();
}
dominatorTree.MergeNodes(V_0, stackVariable10, theLoopConstruct);
return;
}
private void UpdateDominatorTree(DominatorTree dominatorTree, LoopLogicalConstruct theLoopConstruct)
{
HashSet<ISingleEntrySubGraph> loopNodes = new HashSet<ISingleEntrySubGraph>();
if (theLoopConstruct.LoopCondition != null)
{
loopNodes.Add(theLoopConstruct.LoopCondition);
}
if (theLoopConstruct.LoopBodyBlock != null)
{
loopNodes.UnionWith(theLoopConstruct.LoopBodyBlock.Children);
}
ISingleEntrySubGraph loopEntry = (theLoopConstruct.LoopType == LoopType.PreTestedLoop) ? theLoopConstruct.LoopCondition : theLoopConstruct.LoopBodyBlock.Entry;
dominatorTree.MergeNodes(loopNodes, loopEntry, theLoopConstruct);
}
/// <summary>
/// Removes backedges exiting from <paramref name="loopConstruct"/>.
/// </summary>
/// <param name="loopConstruct">The loop construct.</param>
private void CleanUpEdges(LoopLogicalConstruct loopConstruct)
{
DFSTree dfsTree = DFSTBuilder.BuildTree(loopConstruct.Parent);
DFSTNode loopNode = dfsTree.ConstructToNodeMap[loopConstruct];
if(loopNode.BackEdgeSuccessors.Count == 0)
{
return;
}
foreach (DFSTNode backedgeSuccessor in loopNode.BackEdgeSuccessors)
{
ILogicalConstruct edgeEndConstruct = backedgeSuccessor.Construct as ILogicalConstruct;
if (!(edgeEndConstruct is ConditionLogicalConstruct)) /// if the target is ConditionLogicalConstruct, it can probably be a header of outer loop
{
MarkAsGotoEdge(loopConstruct, backedgeSuccessor.Construct as ILogicalConstruct);
}
}
}
/// <summary>
/// Analyzes <paramref name="interval"/> and makes a loop from it, if possible.
/// </summary>
/// <param name="interval">The interval to be analyzed.</param>
/// <returns>Returns true if a loop was made.</returns>
private bool TryMakeLoop(IntervalConstruct interval, DominatorTree dominatorTree)
{
DFSTree dfsTree = DFSTBuilder.BuildTree(interval);
if (dfsTree.BackEdges.Count == 0)
{
/// No back edges in the interval, so no loop can be made.
return false;
}
HashSet<ILogicalConstruct> loopBody;
HashSet<ILogicalConstruct> possibleLatchingNodes = BuildLoop(dfsTree, out loopBody);
ConditionLogicalConstruct loopCondition;
LoopType typeOfLoop = DetermineLoopType(loopBody, possibleLatchingNodes, interval, dominatorTree, out loopCondition);
if (loopBody.Count > 0)
{
LoopLogicalConstruct loop = new LoopLogicalConstruct(interval.Entry as ILogicalConstruct, loopBody, typeOfLoop, loopCondition, typeSystem);
CleanUpEdges(loop); /// Covers the case in IrregularbackedgeExitLoop
UpdateDominatorTree(dominatorTree, loop);
return true;
}
else
{
/// Empty loops should not be created. Instead, backedges that form such loops will be marked as goto.
foreach (DFSTEdge backedge in dfsTree.BackEdges)
{
MarkAsGotoEdge(backedge.Start.Construct as ILogicalConstruct, backedge.End.Construct as ILogicalConstruct);
}
}
return false;
}
