private void UpdateDominatorTree(DominatorTree dominatorTree, IfLogicalConstruct theIfConstruct)
{
V_0 = new HashSet <ISingleEntrySubGraph>();
dummyVar0 = V_0.Add(theIfConstruct.get_Condition());
V_0.UnionWith(theIfConstruct.get_Then().get_Children());
if (theIfConstruct.get_Else() != null)
{
V_0.UnionWith(theIfConstruct.get_Else().get_Children());
}
dominatorTree.MergeNodes(V_0, theIfConstruct.get_Condition(), theIfConstruct);
return;
}
private void UpdateDominatorTree(DominatorTree dominatorTree, IfLogicalConstruct theIfConstruct)
{
HashSet <ISingleEntrySubGraph> ifNodes = new HashSet <ISingleEntrySubGraph>();
ifNodes.Add(theIfConstruct.Condition);
ifNodes.UnionWith(theIfConstruct.Then.Children);
if (theIfConstruct.Else != null)
{
ifNodes.UnionWith(theIfConstruct.Else.Children);
}
dominatorTree.MergeNodes(ifNodes, theIfConstruct.Condition, theIfConstruct);
}
private void UpdateDominatorTree(DominatorTree dominatorTree, IfLogicalConstruct theIfConstruct)
{
HashSet<ISingleEntrySubGraph> ifNodes = new HashSet<ISingleEntrySubGraph>();
ifNodes.Add(theIfConstruct.Condition);
ifNodes.UnionWith(theIfConstruct.Then.Children);
if (theIfConstruct.Else != null)
{
ifNodes.UnionWith(theIfConstruct.Else.Children);
}
dominatorTree.MergeNodes(ifNodes, theIfConstruct.Condition, theIfConstruct);
}
private bool TryBuildIfConstruct(ConditionLogicalConstruct condition, DominatorTree dominatorTree, DFSTree dfsTree)
{
V_0 = condition.get_FalseSuccessor();
V_1 = condition.get_TrueSuccessor();
V_2 = dominatorTree.GetDominanceFrontier(V_0);
V_3 = dominatorTree.GetDominanceFrontier(V_1);
stackVariable15 = this.CheckSuccessor(condition, V_1, V_2, dfsTree);
if (stackVariable15 == null)
{
dummyVar0 = stackVariable15;
stackVariable15 = this.CheckSuccessor(condition, V_0, V_3, dfsTree);
}
V_4 = new HashSet <ISingleEntrySubGraph>(V_3);
V_4.IntersectWith(V_2);
if (stackVariable15 == null && V_2.get_Count() > 0 && V_3.get_Count() > 0 && V_4.get_Count() == 0)
{
return(false);
}
V_5 = this.GetBlockBody(dominatorTree, V_1, condition);
V_6 = this.GetBlockBody(dominatorTree, V_0, condition);
if (V_5 == null && V_6 == null)
{
return(false);
}
if (V_5 == null)
{
condition.Negate(this.typeSystem);
stackVariable86 = V_1;
V_1 = V_0;
V_0 = stackVariable86;
V_5 = V_6;
V_6 = null;
}
if (V_6 == null && !this.CheckSuccessors(V_5, V_0))
{
return(false);
}
if (this.ShouldInvertIfAndRemoveElse(V_5, V_1, V_6, V_0))
{
condition.Negate(this.typeSystem);
stackVariable73 = V_1;
V_1 = V_0;
V_0 = stackVariable73;
stackVariable75 = V_5;
V_5 = V_6;
V_6 = stackVariable75;
V_6 = null;
}
if (V_6 != null && !this.HasSuccessors(V_5))
{
stackVariable61 = V_1.get_FirstBlock().get_TheBlock();
stackVariable63 = new Code[2];
stackVariable63[0] = 41;
stackVariable63[1] = 119;
if (this.SubtreeEndsInInstructionCode(stackVariable61, stackVariable63))
{
V_6 = null;
}
}
V_7 = new BlockLogicalConstruct(V_1, V_5);
if (V_6 != null)
{
stackVariable46 = new BlockLogicalConstruct(V_0, V_6);
}
else
{
stackVariable46 = null;
}
this.UpdateDominatorTree(dominatorTree, IfLogicalConstruct.GroupInIfConstruct(condition, V_7, stackVariable46));
return(true);
}
/// <summary>
/// Tries to build an if construct with condition - the specified condition.
/// </summary>
/// <remarks>
/// The idea is to get the dominated nodes of the true successor to create the then block and the dominated nodes of the false successor
/// to create the else block.
/// If both the then and else blocks have successors, then they must have a common successor to create the if construct.
/// </remarks>
/// <param name="condition"></param>
/// <returns>True on success.</returns>
private bool TryBuildIfConstruct(ConditionLogicalConstruct condition, DominatorTree dominatorTree, DFSTree dfsTree)
{
//Store the true and false successors for optimization.
ILogicalConstruct falseSuccessor = condition.FalseSuccessor;
ILogicalConstruct trueSuccessor = condition.TrueSuccessor;
HashSet <ISingleEntrySubGraph> falseSuccessorFrontier = dominatorTree.GetDominanceFrontier(falseSuccessor);
HashSet <ISingleEntrySubGraph> trueSuccessorFrontier = dominatorTree.GetDominanceFrontier(trueSuccessor);
ILogicalConstruct exitSuccessor = CheckSuccessor(condition, trueSuccessor, falseSuccessorFrontier, dfsTree) ??
CheckSuccessor(condition, falseSuccessor, trueSuccessorFrontier, dfsTree);
HashSet <ISingleEntrySubGraph> frontierIntersection = new HashSet <ISingleEntrySubGraph>(trueSuccessorFrontier);
frontierIntersection.IntersectWith(falseSuccessorFrontier);
if (exitSuccessor == null && falseSuccessorFrontier.Count > 0 && trueSuccessorFrontier.Count > 0 && frontierIntersection.Count == 0)
{
//If none of the successors can be a proper exit and the false and true successor frontiers are not empty but have no common node,
//then we do not make the if since it will not have a common exit.
return(false);
}
HashSet <ILogicalConstruct> thenBody = GetBlockBody(dominatorTree, trueSuccessor, condition);
HashSet <ILogicalConstruct> elseBody = GetBlockBody(dominatorTree, falseSuccessor, condition);
if (thenBody == null && elseBody == null)
{
return(false);
}
else if (thenBody == null)
{
condition.Negate(typeSystem);
ILogicalConstruct swapHelper = trueSuccessor;
trueSuccessor = falseSuccessor;
falseSuccessor = swapHelper;
thenBody = elseBody;
elseBody = null;
}
//If the else body is null but the false successor is not a successor of the then body then we do not make the if.
if (elseBody == null && !CheckSuccessors(thenBody, falseSuccessor))
{
return(false);
}
if (ShouldInvertIfAndRemoveElse(thenBody, trueSuccessor, elseBody, falseSuccessor))
{
///This is performed for cosmetic reasons.
condition.Negate(typeSystem);
ILogicalConstruct successorSwapHelper = trueSuccessor;
trueSuccessor = falseSuccessor;
falseSuccessor = successorSwapHelper;
HashSet <ILogicalConstruct> swapHelper = thenBody;
thenBody = elseBody;
elseBody = swapHelper;
elseBody = null;
}
if (elseBody != null && !HasSuccessors(thenBody) &&
SubtreeEndsInInstructionCode(trueSuccessor.FirstBlock.TheBlock, new Code[] { Code.Ret, Code.Throw })) // check if all ends are throw and/or return -> allow mixed ends as well
{
// we don't need the else
elseBody = null;
}
BlockLogicalConstruct theThenBlock = new BlockLogicalConstruct(trueSuccessor, thenBody);
BlockLogicalConstruct theElseBlock = elseBody != null ? new BlockLogicalConstruct(falseSuccessor, elseBody) : null;
IfLogicalConstruct theIfConstruct = IfLogicalConstruct.GroupInIfConstruct(condition, theThenBlock, theElseBlock);
UpdateDominatorTree(dominatorTree, theIfConstruct);
return(true);
}