/// <summary> /// Checks whether there is a definition clear path from the beginning of the /// method to the current usage node. here v represents a usage node /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathFromBeginning(InstructionVertex v, HashSet <int> otherDefOffsets) { Stack <InstructionVertex> verticesStack = new Stack <InstructionVertex>(); verticesStack.Push(v); HashSet <InstructionVertex> visitiedVertices = new HashSet <InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); //Reached an end node, showing a feasible path if (this.m_VisitedGraph.NumInEdges(iv) == 0) { return(true); } foreach (var inelem in this.m_VisitedGraph.InEdges(iv)) { Edge inEdge = inelem as Edge; var source = inEdge.Source as InstructionVertex; //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(source) && !otherDefOffsets.Contains(source.Instruction.Offset)) { verticesStack.Push(source); } } } return(false); }
/// <summary> /// Checks whether the current vertex has a feasible path without encountering /// the other offsets /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathToEnd(InstructionVertex v, HashSet <int> otherDefOffsets) { Stack <InstructionVertex> verticesStack = new Stack <InstructionVertex>(); verticesStack.Push(v); HashSet <InstructionVertex> visitiedVertices = new HashSet <InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); //Reached an end node, showing a feasible path if (this.m_VisitedGraph.NumOutEdges(iv) == 0) { return(true); } foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var target = outEdge.Target as InstructionVertex; //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(target) && !otherDefOffsets.Contains(target.Instruction.Offset)) { verticesStack.Push(target); } } } return(false); }
/// <summary> /// Checks whether the current vertex has a feasible path without encountering /// the other offsets to the given other node /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathBetweenNodes(InstructionVertex source, InstructionVertex target, HashSet <int> otherDefOffsets) { Stack <InstructionVertex> verticesStack = new Stack <InstructionVertex>(); verticesStack.Push(source); HashSet <InstructionVertex> visitiedVertices = new HashSet <InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var edgetarget = outEdge.Target as InstructionVertex; if (target.Equals(edgetarget)) { return(true); } //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(edgetarget) && !otherDefOffsets.Contains(edgetarget.Instruction.Offset)) { verticesStack.Push(edgetarget); } } } return(false); }
/// <summary> /// Checks whether there is a definition clear path from the beginning of the /// method to the current usage node. here v represents a usage node /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathFromBeginning(InstructionVertex v, HashSet<int> otherDefOffsets) { Stack<InstructionVertex> verticesStack = new Stack<InstructionVertex>(); verticesStack.Push(v); HashSet<InstructionVertex> visitiedVertices = new HashSet<InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); //Reached an end node, showing a feasible path if (this.m_VisitedGraph.NumInEdges(iv) == 0) return true; foreach (var inelem in this.m_VisitedGraph.InEdges(iv)) { Edge inEdge = inelem as Edge; var source = inEdge.Source as InstructionVertex; //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(source) && !otherDefOffsets.Contains(source.Instruction.Offset)) { verticesStack.Push(source); } } } return false; }
/// <summary> /// Checks whether the current vertex has a feasible path without encountering /// the other offsets to the given other node /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathBetweenNodes(InstructionVertex source, InstructionVertex target, HashSet<int> otherDefOffsets) { Stack<InstructionVertex> verticesStack = new Stack<InstructionVertex>(); verticesStack.Push(source); HashSet<InstructionVertex> visitiedVertices = new HashSet<InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var edgetarget = outEdge.Target as InstructionVertex; if (target.Equals(edgetarget)) return true; //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(edgetarget) && !otherDefOffsets.Contains(edgetarget.Instruction.Offset)) { verticesStack.Push(edgetarget); } } } return false; }
public override bool Equals(object obj) { InstructionVertex iv = obj as InstructionVertex; if (iv == null) { return(false); } return(this.instruction.Offset == iv.instruction.Offset); }
/// <summary> /// Add a new InstructionVertex to the graph and returns it. /// </summary> /// <returns> /// Created vertex /// </returns> public InstructionVertex AddVertex(Instruction instruction) { InstructionVertex v = new InstructionVertex(instruction); if (this.vertices.Count == 0) this.rootVertex = v; List<Edge> outEdges = new List<Edge>(); this.vertexOutEdges.Add(v, outEdges); List<Edge> inEdges = new List<Edge>(); this.vertexInEdges.Add(v, inEdges); return v; }
public Edge AddEdge( InstructionVertex source, InstructionVertex target ) { // look for the vertex in the list if (!this.vertexOutEdges.ContainsKey(source)) throw new Exception("Could not find source vertex"); if (!this.vertexOutEdges.ContainsKey(target)) throw new Exception("Could not find target vertex"); // create edge Edge e = new Edge(source, target); this.vertexOutEdges[source].Add(e); this.vertexInEdges[target].Add(e); return e; }
/// <summary> /// Add a new InstructionVertex to the graph and returns it. /// </summary> /// <returns> /// Created vertex /// </returns> public InstructionVertex AddVertex(Instruction instruction) { InstructionVertex v = new InstructionVertex(instruction); if (this.vertices.Count == 0) { this.rootVertex = v; } List <Edge> outEdges = new List <Edge>(); this.vertexOutEdges.Add(v, outEdges); List <Edge> inEdges = new List <Edge>(); this.vertexInEdges.Add(v, inEdges); return(v); }
public Edge AddEdge( InstructionVertex source, InstructionVertex target ) { // look for the vertex in the list if (!this.vertexOutEdges.ContainsKey(source)) { throw new Exception("Could not find source vertex"); } if (!this.vertexOutEdges.ContainsKey(target)) { throw new Exception("Could not find target vertex"); } // create edge Edge e = new Edge(source, target); this.vertexOutEdges[source].Add(e); this.vertexInEdges[target].Add(e); return(e); }
/// <summary> /// Populates all vertices /// </summary> /// <param name="method"></param> private void PopulateVertices(Method method) { MethodBodyEx body; if (!method.TryGetBody(out body) || !body.HasInstructions) { return; } int offset = 0; Instruction instruction; while (body.TryGetInstruction(offset, out instruction)) { SafeDebug.AssumeNotNull(instruction, "instruction"); OpCode opCode = instruction.OpCode; InstructionVertex iv = this.AddVertex(instruction); this.vertices[offset] = iv; offset = instruction.NextOffset; } }
public void Traverse(InstructionVertex v) { Stack <InstructionVertex> verticesStack = new Stack <InstructionVertex>(); verticesStack.Push(v); HashSet <InstructionVertex> visitiedVertices = new HashSet <InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var target = outEdge.Target as InstructionVertex; if (!visitiedVertices.Contains(target)) { verticesStack.Push(target); } } } }
public void Traverse(InstructionVertex v) { Stack<InstructionVertex> verticesStack = new Stack<InstructionVertex>(); verticesStack.Push(v); HashSet<InstructionVertex> visitiedVertices = new HashSet<InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var target = outEdge.Target as InstructionVertex; if (!visitiedVertices.Contains(target)) { verticesStack.Push(target); } } } }
/// <summary> /// Checks whether the current vertex has a feasible path without encountering /// the other offsets /// </summary> /// <param name="v"></param> /// <param name="otherDefOffsets"></param> public bool HasDefClearPathToEnd(InstructionVertex v, HashSet<int> otherDefOffsets) { Stack<InstructionVertex> verticesStack = new Stack<InstructionVertex>(); verticesStack.Push(v); HashSet<InstructionVertex> visitiedVertices = new HashSet<InstructionVertex>(); while (verticesStack.Count > 0) { InstructionVertex iv = verticesStack.Pop(); visitiedVertices.Add(iv); //Reached an end node, showing a feasible path if (this.m_VisitedGraph.NumOutEdges(iv) == 0) return true; foreach (var outelem in this.m_VisitedGraph.OutEdges(iv)) { Edge outEdge = outelem as Edge; var target = outEdge.Target as InstructionVertex; //Visit a vertex further only if it is not in the redefined set if (!visitiedVertices.Contains(target) && !otherDefOffsets.Contains(target.Instruction.Offset)) { verticesStack.Push(target); } } } return false; }
/// <summary> /// Adds edges to the graph /// </summary> /// <param name="method"></param> private void PopulateEdges(Method method) { MethodBodyEx body; if (!method.TryGetBody(out body) || !body.HasInstructions) { return; } int offset = 0; Instruction instruction; InstructionVertex cv = null; //make the graph while (body.TryGetInstruction(offset, out instruction)) { SafeDebug.AssumeNotNull(instruction, "instruction"); OpCode opCode = instruction.OpCode; InstructionVertex iv = this.vertices[offset]; if (cv != null) { this.AddEdge(cv, iv); } if (MethodOrFieldAnalyzer.BranchOpCodes.Contains(opCode)) { InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset]; this.AddEdge(iv, alternatev); cv = iv; } else if (opCode == OpCodes.Switch) { foreach (var switchoff in instruction.SwitchOffsets) { InstructionVertex alternatev = this.vertices[switchoff]; this.AddEdge(iv, alternatev); } cv = iv; } else if (opCode == OpCodes.Br || opCode == OpCodes.Br_S) { InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset]; this.AddEdge(iv, alternatev); cv = null; } else if (opCode == OpCodes.Break) { InstructionVertex alternatev = this.vertices[instruction.BrTargetOffset]; this.AddEdge(iv, alternatev); cv = null; } else if (opCode == OpCodes.Ret || opCode == OpCodes.Throw) { cv = null; } else { cv = iv; } offset = instruction.NextOffset; } }