public ControlFlowEdge(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type) { if (from == null) throw new ArgumentNullException("from"); if (to == null) throw new ArgumentNullException("to"); this.From = from; this.To = to; this.Type = type; }
public override void VisitYieldStatement(YieldStatementSyntax node) { if (node.IsKind(SyntaxKind.YieldBreakStatement)) { // end not connected with data curNode = builder.CreateEndNode(node); } else { CreateConnectedEndNode(node); } }
public override void VisitTryStatement(TryStatementSyntax node) { ControlFlowNode end = builder.CreateEndNode(node, addToNodeList: false); HandleEmbeddedStatement(node.Block, curNode); var edge = Connect(curNode, end); if (node.Finally?.Block != null) edge.AddJumpOutOfTryFinally(node); var tryEndPoint = curNode; foreach (var cc in node.Catches) { HandleEmbeddedStatement(cc.Block, tryEndPoint); edge = Connect(tryEndPoint, end); if (node.Finally?.Block != null) edge.AddJumpOutOfTryFinally(node); } if (node.Finally?.Block != null) { // Don't connect the end of the try-finally block to anything. // Consumers of the CFG will have to special-case try-finally. HandleEmbeddedStatement(node.Finally.Block, curNode); } builder.nodes.Add(end); curNode = end; }
public override void VisitThrowStatement(ThrowStatementSyntax node) { // end not connected with data curNode = builder.CreateEndNode(node); }
public override void VisitGotoStatement(GotoStatementSyntax node) { if (node.IsKind(SyntaxKind.GotoDefaultStatement) || node.IsKind(SyntaxKind.GotoCaseStatement)) { gotoCaseOrDefault.Add(curNode); } else { builder.gotoStatements.Add(node); } curNode = builder.CreateEndNode(node); }
internal ControlFlowEdge Connect(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type = ControlFlowEdgeType.Normal) { if (from == null || to == null) return null; ControlFlowEdge edge = builder.CreateEdge(from, to, type); from.Outgoing.Add(edge); to.Incoming.Add(edge); return edge; }
public override void VisitSwitchStatement(SwitchStatementSyntax node) { // First, figure out which switch section will get called (if the expression is constant): var constant = builder.EvaluateConstant(node.Expression); SwitchSectionSyntax defaultSection = null; SwitchSectionSyntax sectionMatchedByConstant = null; foreach (var section in node.Sections) { foreach (var label in section.Labels) { if (label.IsKind(SyntaxKind.DefaultSwitchLabel)) { defaultSection = section; } else if (constant.HasValue /*&& constant.IsCompileTimeConstant*/) { var scl = label as CaseSwitchLabelSyntax; var labelConstant = builder.EvaluateConstant(scl.Value); if (builder.AreEqualConstants(constant, labelConstant)) { sectionMatchedByConstant = section; } } } } if (constant.HasValue && sectionMatchedByConstant == null) { sectionMatchedByConstant = defaultSection; } int gotoCaseOrDefaultInOuterScope = gotoCaseOrDefault.Count; List <ControlFlowNode> sectionStartNodes = new List <ControlFlowNode>(); ControlFlowNode end = builder.CreateEndNode(node, addToNodeList: false); breakTargets.Push(end); var myEntryPoint = curNode; foreach (var section in node.Sections) { int sectionStartNodeID = builder.nodes.Count; if (!constant.HasValue || section == sectionMatchedByConstant) { curNode = myEntryPoint; HandleStatementList(section.Statements, myEntryPoint); } else { // This section is unreachable: pass null to HandleStatementList. curNode = null; HandleStatementList(section.Statements, null); } // Don't bother connecting the ends of the sections: the 'break' statement takes care of that. // Store the section start node for 'goto case' statements. sectionStartNodes.Add(sectionStartNodeID < builder.nodes.Count ? builder.nodes[sectionStartNodeID] : null); } breakTargets.Pop(); if (defaultSection == null && sectionMatchedByConstant == null) { Connect(myEntryPoint, end); } if (gotoCaseOrDefault.Count > gotoCaseOrDefaultInOuterScope) { // Resolve 'goto case' statements: for (int i = gotoCaseOrDefaultInOuterScope; i < gotoCaseOrDefault.Count; i++) { ControlFlowNode gotoCaseNode = gotoCaseOrDefault[i]; var gotoCaseStatement = gotoCaseNode.NextStatement as GotoStatementSyntax; Optional <object> gotoCaseConstant = null; if (gotoCaseStatement != null) { gotoCaseConstant = builder.EvaluateConstant(gotoCaseStatement.Expression); } int targetSectionIndex = -1; int currentSectionIndex = 0; foreach (var section in node.Sections) { foreach (var label in section.Labels) { if (label is CaseSwitchLabelSyntax) { var scl = label as CaseSwitchLabelSyntax; // goto case if (scl.Value != null) { var labelConstant = builder.EvaluateConstant(scl.Value); if (builder.AreEqualConstants(gotoCaseConstant, labelConstant)) { targetSectionIndex = currentSectionIndex; } } } else { // goto default if (label.IsKind(SyntaxKind.DefaultSwitchLabel)) { targetSectionIndex = currentSectionIndex; } } } currentSectionIndex++; } if (targetSectionIndex >= 0 && sectionStartNodes[targetSectionIndex] != null) { Connect(gotoCaseNode, sectionStartNodes[targetSectionIndex], ControlFlowEdgeType.Jump); } else { Connect(gotoCaseNode, end, ControlFlowEdgeType.Jump); } } gotoCaseOrDefault.RemoveRange(gotoCaseOrDefaultInOuterScope, gotoCaseOrDefault.Count - gotoCaseOrDefaultInOuterScope); } builder.nodes.Add(end); curNode = end; }
public override void VisitBlock(BlockSyntax node) { // C# 4.0 spec: §8.2 Blocks curNode = HandleStatementList(node.Statements, curNode); CreateConnectedEndNode(node); }
public override void VisitForStatement(ForStatementSyntax forStatement) { // Initializers/Iterators ? -> difference between NR5/Roslyn -> they're not statements anymore. // HandleStatementList(forStatement.Initializers, curNode); // for (initializers <data>; <condition>cond; <iteratorStart>iterators<iteratorEnd>) { <bodyStart> embeddedStmt; <bodyEnd> } <end> ControlFlowNode end = builder.CreateEndNode(forStatement, addToNodeList: false); ControlFlowNode conditionNode = builder.CreateSpecialNode(forStatement, ControlFlowNodeType.LoopCondition); Connect(curNode, conditionNode); int iteratorStartNodeID = builder.nodes.Count; ControlFlowNode iteratorEnd = null; // HandleStatementList(forStatement.Incrementors, null); ControlFlowNode iteratorStart; if (iteratorEnd != null) { iteratorStart = builder.nodes[iteratorStartNodeID]; Connect(iteratorEnd, conditionNode); } else { iteratorStart = conditionNode; } breakTargets.Push(end); continueTargets.Push(iteratorStart); ControlFlowNode bodyStart = builder.CreateStartNode(forStatement.Statement); Visit (forStatement.Statement); Connect(curNode, iteratorStart); breakTargets.Pop(); continueTargets.Pop(); bool? cond = forStatement.Condition == null ? true : builder.EvaluateCondition(forStatement.Condition); if (cond != false) Connect(conditionNode, bodyStart, ControlFlowEdgeType.ConditionTrue); if (cond != true) Connect(conditionNode, end, ControlFlowEdgeType.ConditionFalse); builder.nodes.Add(end); curNode = end; }
public override void VisitDoStatement(DoStatementSyntax node) { // <data> do { <bodyStart> embeddedStmt; <bodyEnd>} <condition> while(cond); <end> ControlFlowNode end = builder.CreateEndNode(node, addToNodeList: false); ControlFlowNode conditionNode = builder.CreateSpecialNode(node, ControlFlowNodeType.LoopCondition, addToNodeList: false); breakTargets.Push(end); continueTargets.Push(conditionNode); ControlFlowNode bodyStart = builder.CreateStartNode(node.Statement); Connect(curNode, bodyStart); Visit(node.Statement); Connect(curNode, conditionNode); bool? cond = builder.EvaluateCondition(node.Condition); if (cond != false) Connect(conditionNode, bodyStart, ControlFlowEdgeType.ConditionTrue); if (cond != true) Connect(conditionNode, end, ControlFlowEdgeType.ConditionFalse); breakTargets.Pop(); continueTargets.Pop(); builder.nodes.Add(conditionNode); builder.nodes.Add(end); curNode = end; }
public override void VisitSwitchStatement(SwitchStatementSyntax node) { // First, figure out which switch section will get called (if the expression is constant): var constant = builder.EvaluateConstant(node.Expression); SwitchSectionSyntax defaultSection = null; SwitchSectionSyntax sectionMatchedByConstant = null; foreach (var section in node.Sections) { foreach (var label in section.Labels) { if (label.IsKind(SyntaxKind.DefaultSwitchLabel)) { defaultSection = section; } else if (constant.HasValue /*&& constant.IsCompileTimeConstant*/) { var scl = label as CaseSwitchLabelSyntax; var labelConstant = builder.EvaluateConstant(scl.Value); if (builder.AreEqualConstants(constant, labelConstant)) sectionMatchedByConstant = section; } } } if (constant.HasValue && sectionMatchedByConstant == null) sectionMatchedByConstant = defaultSection; int gotoCaseOrDefaultInOuterScope = gotoCaseOrDefault.Count; List<ControlFlowNode> sectionStartNodes = new List<ControlFlowNode>(); ControlFlowNode end = builder.CreateEndNode(node, addToNodeList: false); breakTargets.Push(end); var myEntryPoint = curNode; foreach (var section in node.Sections) { int sectionStartNodeID = builder.nodes.Count; if (!constant.HasValue || section == sectionMatchedByConstant) { curNode = myEntryPoint; HandleStatementList(section.Statements, myEntryPoint); } else { // This section is unreachable: pass null to HandleStatementList. curNode = null; HandleStatementList(section.Statements, null); } // Don't bother connecting the ends of the sections: the 'break' statement takes care of that. // Store the section start node for 'goto case' statements. sectionStartNodes.Add(sectionStartNodeID < builder.nodes.Count ? builder.nodes[sectionStartNodeID] : null); } breakTargets.Pop(); if (defaultSection == null && sectionMatchedByConstant == null) { Connect(myEntryPoint, end); } if (gotoCaseOrDefault.Count > gotoCaseOrDefaultInOuterScope) { // Resolve 'goto case' statements: for (int i = gotoCaseOrDefaultInOuterScope; i < gotoCaseOrDefault.Count; i++) { ControlFlowNode gotoCaseNode = gotoCaseOrDefault[i]; var gotoCaseStatement = gotoCaseNode.NextStatement as GotoStatementSyntax; Optional<object> gotoCaseConstant = null; if (gotoCaseStatement != null) { gotoCaseConstant = builder.EvaluateConstant(gotoCaseStatement.Expression); } int targetSectionIndex = -1; int currentSectionIndex = 0; foreach (var section in node.Sections) { foreach (var label in section.Labels) { if (label is CaseSwitchLabelSyntax) { var scl = label as CaseSwitchLabelSyntax; // goto case if (scl.Value != null) { var labelConstant = builder.EvaluateConstant(scl.Value); if (builder.AreEqualConstants(gotoCaseConstant, labelConstant)) targetSectionIndex = currentSectionIndex; } } else { // goto default if (label.IsKind(SyntaxKind.DefaultSwitchLabel)) targetSectionIndex = currentSectionIndex; } } currentSectionIndex++; } if (targetSectionIndex >= 0 && sectionStartNodes[targetSectionIndex] != null) Connect(gotoCaseNode, sectionStartNodes[targetSectionIndex], ControlFlowEdgeType.Jump); else Connect(gotoCaseNode, end, ControlFlowEdgeType.Jump); } gotoCaseOrDefault.RemoveRange(gotoCaseOrDefaultInOuterScope, gotoCaseOrDefault.Count - gotoCaseOrDefaultInOuterScope); } builder.nodes.Add(end); curNode = end; }
public override void VisitIfStatement(IfStatementSyntax node) { bool? cond = builder.EvaluateCondition(node.Condition); var startNode = curNode; ControlFlowNode trueBegin = builder.CreateStartNode(node.Statement); if (cond != false) Connect(startNode, trueBegin, ControlFlowEdgeType.ConditionTrue); curNode = trueBegin; Visit(node.Statement); ControlFlowNode trueEnd = curNode; ControlFlowNode falseEnd = null; if (node.Else?.Statement != null) { ControlFlowNode falseBegin = builder.CreateStartNode(node.Else?.Statement); if (cond != true) Connect(startNode, falseBegin, ControlFlowEdgeType.ConditionFalse); curNode = trueBegin; Visit(node.Else?.Statement); falseEnd = curNode; } // (if no else statement exists, both falseBegin and falseEnd will be null) ControlFlowNode end = builder.CreateEndNode(node); Connect(trueEnd, end); if (falseEnd != null) { Connect(falseEnd, end); } else if (cond != true) { Connect(startNode, end, ControlFlowEdgeType.ConditionFalse); } curNode = end; }
ControlFlowNode HandleStatementList(IEnumerable<StatementSyntax> statements, ControlFlowNode source) { var oldCurNode = curNode; ControlFlowNode childNode = null; foreach (var stmt in statements) { if (childNode == null) { curNode = childNode = builder.CreateStartNode(stmt); if (source != null) Connect(source, childNode); } // Debug.Assert(childNode.NextStatement == stmt); Visit(stmt); childNode = curNode; // Debug.Assert(childNode.PreviousStatement == stmt); } curNode = oldCurNode; return childNode ?? source; }
/// <summary> /// Creates an end node for <c>stmt</c> and connects <c>from</c> with the new node. /// </summary> void CreateConnectedEndNode(StatementSyntax stmt) { ControlFlowNode newNode = builder.CreateEndNode(stmt); Connect(curNode, newNode); curNode = newNode; }
void HandleEmbeddedStatement(StatementSyntax embeddedStatement, ControlFlowNode source) { if (embeddedStatement == null) { curNode = source; } ControlFlowNode bodyStart = builder.CreateStartNode(embeddedStatement); if (source != null) Connect(source, bodyStart); Visit(embeddedStatement); }
protected virtual ControlFlowEdge CreateEdge(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type) { cancellationToken.ThrowIfCancellationRequested(); return(new ControlFlowEdge(from, to, type)); }
public override void VisitForEachStatement(ForEachStatementSyntax node) { // <data> foreach (<condition>...) { <bodyStart>embeddedStmt<bodyEnd> } <end> ControlFlowNode end = builder.CreateEndNode(node, addToNodeList: false); ControlFlowNode conditionNode = builder.CreateSpecialNode(node, ControlFlowNodeType.LoopCondition); Connect(curNode, conditionNode); breakTargets.Push(end); continueTargets.Push(conditionNode); HandleEmbeddedStatement(node.Statement, conditionNode); Connect(curNode, conditionNode); breakTargets.Pop(); continueTargets.Pop(); Connect(conditionNode, end); builder.nodes.Add(end); curNode = end; }
ControlFlowNode HandleStatementList(IEnumerable <StatementSyntax> statements, ControlFlowNode source) { var oldCurNode = curNode; ControlFlowNode childNode = null; foreach (var stmt in statements) { if (childNode == null) { curNode = childNode = builder.CreateStartNode(stmt); if (source != null) { Connect(source, childNode); } } // Debug.Assert(childNode.NextStatement == stmt); Visit(stmt); childNode = curNode; // Debug.Assert(childNode.PreviousStatement == stmt); } curNode = oldCurNode; return(childNode ?? source); }
public override void VisitContinueStatement(ContinueStatementSyntax node) { if (continueTargets.Count > 0) { var target = continueTargets.Peek(); Connect(curNode, target, ControlFlowEdgeType.Jump); curNode = target; } curNode = builder.CreateEndNode(node); }
protected virtual ControlFlowEdge CreateEdge(ControlFlowNode from, ControlFlowNode to, ControlFlowEdgeType type) { cancellationToken.ThrowIfCancellationRequested(); return new ControlFlowEdge(from, to, type); }