private SwitchStatement(Statement head, Statement poststat) : this() { first = head; stats.AddWithKey(head, head.id); // find post node HashSet <Statement> lstNodes = new HashSet <Statement>(head.GetNeighbours(StatEdge. Type_Regular, Direction_Forward)); // cluster nodes if (poststat != null) { post = poststat; lstNodes.Remove(post); } default_edge = head.GetSuccessorEdges(Statement.Statedge_Direct_All)[0]; foreach (Statement st in lstNodes) { stats.AddWithKey(st, st.id); } }
public virtual void CollapseNodesToStatement(Statement stat) { Statement head = stat.GetFirst(); Statement post = stat.GetPost(); VBStyleCollection <Statement, int> setNodes = stat.GetStats(); // post edges if (post != null) { foreach (StatEdge edge in post.GetEdges(Statedge_Direct_All, Direction_Backward)) { if (stat.ContainsStatementStrict(edge.GetSource())) { edge.GetSource().ChangeEdgeType(Direction_Forward, edge, StatEdge.Type_Break); stat.AddLabeledEdge(edge); } } } // regular head edges foreach (StatEdge prededge in head.GetAllPredecessorEdges()) { if (prededge.GetType() != StatEdge.Type_Exception && stat.ContainsStatementStrict (prededge.GetSource())) { prededge.GetSource().ChangeEdgeType(Direction_Forward, prededge, StatEdge.Type_Continue ); stat.AddLabeledEdge(prededge); } head.RemovePredecessor(prededge); prededge.GetSource().ChangeEdgeNode(Direction_Forward, prededge, stat); stat.AddPredecessor(prededge); } if (setNodes.ContainsKey(first.id)) { first = stat; } // exception edges HashSet <Statement> setHandlers = new HashSet <Statement>(head.GetNeighbours(StatEdge .Type_Exception, Direction_Forward)); foreach (Statement node in setNodes) { setHandlers.UnionWith(node.GetNeighbours(StatEdge.Type_Exception, Direction_Forward )); } if (!(setHandlers.Count == 0)) { foreach (StatEdge edge in head.GetEdges(StatEdge.Type_Exception, Direction_Forward )) { Statement handler = edge.GetDestination(); if (setHandlers.Contains(handler)) { if (!setNodes.ContainsKey(handler.id)) { stat.AddSuccessor(new StatEdge(stat, handler, edge.GetExceptions())); } } } foreach (Statement node in setNodes) { foreach (StatEdge edge in node.GetEdges(StatEdge.Type_Exception, Direction_Forward )) { if (setHandlers.Contains(edge.GetDestination())) { node.RemoveSuccessor(edge); } } } } if (post != null && !stat.GetNeighbours(StatEdge.Type_Exception, Direction_Forward ).Contains(post)) { // TODO: second condition redundant? stat.AddSuccessor(new StatEdge(StatEdge.Type_Regular, stat, post)); } // adjust statement collection foreach (Statement st in setNodes) { stats.RemoveWithKey(st.id); } stats.AddWithKey(stat, stat.id); stat.SetAllParent(); stat.SetParent(this); stat.BuildContinueSet(); // monitorenter and monitorexit stat.BuildMonitorFlags(); if (stat.type == Type_Switch) { // special case switch, sorting leaf nodes ((SwitchStatement)stat).SortEdgesAndNodes(); } }
// ***************************************************************************** // private methods // ***************************************************************************** public virtual void SortEdgesAndNodes() { Dictionary <StatEdge, int> mapEdgeIndex = new Dictionary <StatEdge, int>(); List <StatEdge> lstFirstSuccs = first.GetSuccessorEdges(Statedge_Direct_All); for (int i = 0; i < lstFirstSuccs.Count; i++) { Sharpen.Collections.Put(mapEdgeIndex, lstFirstSuccs[i], i == 0 ? lstFirstSuccs.Count : i); } // case values BasicBlockStatement bbstat = (BasicBlockStatement)first; int[] values = ((SwitchInstruction)bbstat.GetBlock().GetLastInstruction()).GetValues (); List <Statement> nodes = new List <Statement>(stats.Count - 1); List <List <int?> > edges = new List <List <int?> >(stats.Count - 1); // collect regular edges for (int i = 1; i < stats.Count; i++) { Statement stat = stats[i]; List <int?> lst = new List <int?>(); foreach (StatEdge edge in stat.GetPredecessorEdges(StatEdge.Type_Regular)) { if (edge.GetSource() == first) { lst.Add(mapEdgeIndex.GetOrNullable(edge)); } } lst.Sort(); nodes.Add(stat); edges.Add(lst); } // collect exit edges List <StatEdge> lstExitEdges = first.GetSuccessorEdges(StatEdge.Type_Break | StatEdge .Type_Continue); while (!(lstExitEdges.Count == 0)) { StatEdge edge = lstExitEdges[0]; List <int?> lst = new List <int?>(); for (int i = lstExitEdges.Count - 1; i >= 0; i--) { StatEdge edgeTemp = lstExitEdges[i]; if (edgeTemp.GetDestination() == edge.GetDestination() && edgeTemp.GetType() == edge .GetType()) { lst.Add(mapEdgeIndex.GetOrNullable(edgeTemp)); lstExitEdges.RemoveAtReturningValue(i); } } lst.Sort(); nodes.Add(null); edges.Add(lst); } // sort edges (bubblesort) for (int i = 0; i < edges.Count - 1; i++) { for (int j = edges.Count - 1; j > i; j--) { if (edges[j - 1][0] > edges[j][0]) { edges[j] = edges[j - 1] = edges[j]; nodes[j] = nodes[j - 1] = nodes[j]; } } } // sort statement cliques for (int index = 0; index < nodes.Count; index++) { Statement stat = nodes[index]; if (stat != null) { HashSet <Statement> setPreds = new HashSet <Statement>(stat.GetNeighbours(StatEdge. Type_Regular, Direction_Backward)); setPreds.Remove(first); if (!(setPreds.Count == 0)) { Statement pred = new Sharpen.EnumeratorAdapter <Statement>(setPreds.GetEnumerator()).Next(); // assumption: at most one predecessor node besides the head. May not hold true for obfuscated code. for (int j = 0; j < nodes.Count; j++) { if (j != (index - 1) && nodes[j] == pred) { nodes.Add(j + 1, stat); edges.Add(j + 1, edges[index]); if (j > index) { nodes.RemoveAtReturningValue(index); edges.RemoveAtReturningValue(index); index--; } else { nodes.RemoveAtReturningValue(index + 1); edges.RemoveAtReturningValue(index + 1); } break; } } } } } // translate indices back into edges List <List <StatEdge> > lstEdges = new List <List <StatEdge> >(edges.Count); List <List <Exprent> > lstValues = new List <List <Exprent> >(edges.Count); foreach (List <int?> lst in edges) { List <StatEdge> lste = new List <StatEdge>(lst.Count); List <Exprent> lstv = new List <Exprent>(lst.Count); List <StatEdge> lstSuccs = first.GetSuccessorEdges(Statedge_Direct_All); foreach (int? @in in lst) { int?index = @in == lstSuccs.Count ? 0 : @in; if (!index.HasValue) { continue; } lste.Add(lstSuccs[index.Value]); lstv.Add(index == 0 ? null : new ConstExprent(values[index.Value - 1], false, null)); } lstEdges.Add(lste); lstValues.Add(lstv); } // replace null statements with dummy basic blocks for (int i = 0; i < nodes.Count; i++) { if (nodes[i] == null) { BasicBlockStatement bstat = new BasicBlockStatement(new BasicBlock(DecompilerContext .GetCounterContainer().GetCounterAndIncrement(CounterContainer.Statement_Counter ))); StatEdge sample_edge = lstEdges[i][0]; bstat.AddSuccessor(new StatEdge(sample_edge.GetType(), bstat, sample_edge.GetDestination (), sample_edge.closure)); foreach (StatEdge edge in lstEdges[i]) { edge.GetSource().ChangeEdgeType(Direction_Forward, edge, StatEdge.Type_Regular); edge.closure.GetLabelEdges().Remove(edge); edge.GetDestination().RemovePredecessor(edge); edge.GetSource().ChangeEdgeNode(Direction_Forward, edge, bstat); bstat.AddPredecessor(edge); } nodes[i] = bstat; stats.AddWithKey(bstat, bstat.id); bstat.SetParent(this); } } caseStatements = nodes; caseEdges = lstEdges; caseValues = lstValues; }