internal ControlFlowGraph(ControlFlowNode[] nodes)
 {
     this.nodes = new ReadOnlyCollection<ControlFlowNode>(nodes);
     Debug.Assert(EntryPoint.NodeType == ControlFlowNodeType.EntryPoint);
     Debug.Assert(RegularExit.NodeType == ControlFlowNodeType.RegularExit);
     Debug.Assert(ExceptionalExit.NodeType == ControlFlowNodeType.ExceptionalExit);
 }

 static void FindLoopContents(HashSet<ControlFlowNode> nodes, HashSet<ControlFlowNode> loopContents, ControlFlowNode loopHead, ControlFlowNode addNode)
 {
     if (nodes.Contains(addNode) && loopHead.Dominates(addNode) && loopContents.Add(addNode)) {
         foreach (var edge in addNode.Incoming) {
             FindLoopContents(nodes, loopContents, loopHead, edge.Source);
         }
     }
 }

		ControlFlowGraph BuildGraph(List<ILNode> nodes, ILLabel entryLabel)
		{
			cached_ControlFlowGraph.Nodes.Clear();
			int index = 0;
			var cfNodes = cached_ControlFlowGraph.Nodes;
			ControlFlowNode entryPoint = new ControlFlowNode(index++, 0, ControlFlowNodeType.EntryPoint);
			cfNodes.Add(entryPoint);
			ControlFlowNode regularExit = new ControlFlowNode(index++, null, ControlFlowNodeType.RegularExit);
			cfNodes.Add(regularExit);
			ControlFlowNode exceptionalExit = new ControlFlowNode(index++, null, ControlFlowNodeType.ExceptionalExit);
			cfNodes.Add(exceptionalExit);

			// Create graph nodes
			labelToCfNode.Clear();
			Dictionary<ILNode, ControlFlowNode> astNodeToCfNode = new Dictionary<ILNode, ControlFlowNode>();
			List<ILLabel> listLabels = null;
			foreach(ILBasicBlock node in nodes) {
				ControlFlowNode cfNode = new ControlFlowNode(index++, null, ControlFlowNodeType.Normal);
				cfNodes.Add(cfNode);
				astNodeToCfNode[node] = cfNode;
				cfNode.UserData = node;
				
				// Find all contained labels
				foreach(ILLabel label in node.GetSelfAndChildrenRecursive<ILLabel>(listLabels ?? (listLabels = new List<ILLabel>()))) {
					labelToCfNode[label] = cfNode;
				}
			}
			
			// Entry endge
			ControlFlowNode entryNode = labelToCfNode[entryLabel];
			ControlFlowEdge entryEdge = new ControlFlowEdge(entryPoint, entryNode, JumpType.Normal);
			entryPoint.Outgoing.Add(entryEdge);
			entryNode.Incoming.Add(entryEdge);

			// Create edges
			List<ILExpression> listExpressions = null;
			foreach(ILBasicBlock node in nodes) {
				ControlFlowNode source = astNodeToCfNode[node];
				
				// Find all branches
				foreach(ILLabel target in node.GetSelfAndChildrenRecursive<ILExpression>(listExpressions ?? (listExpressions = new List<ILExpression>()), e => e.IsBranch()).SelectMany(e => e.GetBranchTargets())) {
					ControlFlowNode destination;
					// Labels which are out of out scope will not be in the collection
					// Insert self edge only if we are sure we are a loop
					if (labelToCfNode.TryGetValue(target, out destination) && (destination != source || target == node.Body.FirstOrDefault())) {
						ControlFlowEdge edge = new ControlFlowEdge(source, destination, JumpType.Normal);
						source.Outgoing.Add(edge);
						destination.Incoming.Add(edge);
					}
				}
			}

			return cached_ControlFlowGraph;
		}

		private ControlFlowGraphBuilder(MethodBody methodBody)
		{
			this.methodBody = methodBody;
			offsets = methodBody.Instructions.Select(i => i.Offset).ToArray();
			hasIncomingJumps = new bool[methodBody.Instructions.Count];
			
			entryPoint = new ControlFlowNode(0, 0, ControlFlowNodeType.EntryPoint);
			nodes.Add(entryPoint);
			regularExit = new ControlFlowNode(1, -1, ControlFlowNodeType.RegularExit);
			nodes.Add(regularExit);
			exceptionalExit = new ControlFlowNode(2, -1, ControlFlowNodeType.ExceptionalExit);
			nodes.Add(exceptionalExit);
			Debug.Assert(nodes.Count == 3);
		}

        static HashSet<ControlFlowNode> FindDominatedNodes(HashSet<ControlFlowNode> scope, ControlFlowNode head)
        {
            HashSet<ControlFlowNode> agenda = new HashSet<ControlFlowNode>();
            HashSet<ControlFlowNode> result = new HashSet<ControlFlowNode>();
            agenda.Add(head);

            while(agenda.Count > 0) {
                ControlFlowNode addNode = agenda.First();
                agenda.Remove(addNode);

                if (scope.Contains(addNode) && head.Dominates(addNode) && result.Add(addNode)) {
                    for (int i = 0; i < addNode.Outgoing.Count; i++) {
                        agenda.Add(addNode.Outgoing[i].Target);
                    }
                }
            }

            return result;
        }

        static HashSet<ControlFlowNode> FindDominatedNodes(HashSet<ControlFlowNode> nodes, ControlFlowNode head)
        {
            var exitNodes = head.DominanceFrontier.SelectMany(n => n.Predecessors);
            HashSet<ControlFlowNode> agenda = new HashSet<ControlFlowNode>(exitNodes);
            HashSet<ControlFlowNode> result = new HashSet<ControlFlowNode>();

            while(agenda.Count > 0) {
                ControlFlowNode addNode = agenda.First();
                agenda.Remove(addNode);

                if (nodes.Contains(addNode) && head.Dominates(addNode) && result.Add(addNode)) {
                    foreach (var predecessor in addNode.Predecessors) {
                        agenda.Add(predecessor);
                    }
                }
            }
            if (nodes.Contains(head))
                result.Add(head);

            return result;
        }

		/// <summary>
		/// Gets whether <c>this</c> dominates <paramref name="node"/>.
		/// </summary>
		public bool Dominates(ControlFlowNode node)
		{
			// TODO: this can be made O(1) by numbering the dominator tree
			ControlFlowNode tmp = node;
			while (tmp != null) {
				if (tmp == this)
					return true;
				tmp = tmp.ImmediateDominator;
			}
			return false;
		}

		internal ControlFlowNode(int blockIndex, ExceptionHandler exceptionHandler, ControlFlowNode endFinallyOrFaultNode)
		{
			BlockIndex = blockIndex;
			NodeType = endFinallyOrFaultNode != null ? ControlFlowNodeType.FinallyOrFaultHandler : ControlFlowNodeType.CatchHandler;
			ExceptionHandler = exceptionHandler;
			EndFinallyOrFaultNode = endFinallyOrFaultNode;
			Debug.Assert((exceptionHandler.HandlerType == ExceptionHandlerType.Finally || exceptionHandler.HandlerType == ExceptionHandlerType.Fault) == (endFinallyOrFaultNode != null));
			Offset = exceptionHandler.HandlerStart.Offset;
		}

		ControlFlowNode FindCommonDominator(ControlFlowNode b1, ControlFlowNode b2)
		{
			// Here we could use the postorder numbers to get rid of the hashset, see "A Simple, Fast Dominance Algorithm"
			FindCommonDominator_path1.Clear();
			while (b1 != null && FindCommonDominator_path1.Add(b1))
				b1 = b1.ImmediateDominator;
			while (b2 != null) {
				if (FindCommonDominator_path1.Contains(b2))
					return b2;
				else
					b2 = b2.ImmediateDominator;
			}
			throw new Exception("No common dominator found!");
		}

		void CreateEdge(ControlFlowNode fromNode, ControlFlowNode toNode, JumpType type)
		{
			ControlFlowEdge edge = new ControlFlowEdge(fromNode, toNode, type);
			fromNode.Outgoing.Add(edge);
			toNode.Incoming.Add(edge);
		}

			ControlFlowNode GetNew(ControlFlowNode oldNode)
			{
				if (oldNode == end)
					return newEnd;
				ControlFlowNode newNode;
				if (oldToNew.TryGetValue(oldNode, out newNode))
					return newNode;
				return oldNode;
			}

			void CollectNodes(ControlFlowNode node)
			{
				if (node == end || node == newEnd)
					throw new InvalidOperationException("unexpected cycle involving finally construct");
				if (!oldToNew.ContainsKey(node)) {
					int newBlockIndex = builder.nodes.Count;
					ControlFlowNode copy;
					switch (node.NodeType) {
						case ControlFlowNodeType.Normal:
							copy = new ControlFlowNode(newBlockIndex, node.Start, node.End);
							break;
						case ControlFlowNodeType.FinallyOrFaultHandler:
							copy = new ControlFlowNode(newBlockIndex, node.ExceptionHandler, node.EndFinallyOrFaultNode);
							break;
						default:
							// other nodes shouldn't occur when copying finally blocks
							throw new NotSupportedException(node.NodeType.ToString());
					}
					copy.CopyFrom = node;
					builder.nodes.Add(copy);
					oldToNew.Add(node, copy);
					
					if (node != start) {
						foreach (ControlFlowNode n in node.Predecessors) {
							CollectNodes(n);
						}
					}
				}
			}

		/// <summary>
		/// Creates a copy of all nodes pointing to 'end' and replaces those references with references to 'newEnd'.
		/// Nodes pointing to the copied node are copied recursively to update those references, too.
		/// This recursion stops at 'start'. The modified version of start is returned.
		/// </summary>
		ControlFlowNode CopyFinallySubGraph(ControlFlowNode start, ControlFlowNode end, ControlFlowNode newEnd)
		{
			return new CopyFinallySubGraphLogic(this, start, end, newEnd).CopyFinallySubGraph();
		}

        ControlFlowGraph BuildGraph(List<ILNode> nodes, ILLabel entryLabel)
        {
            int index = 0;
            List<ControlFlowNode> cfNodes = new List<ControlFlowNode>();
            ControlFlowNode entryPoint = new ControlFlowNode(index++, 0, ControlFlowNodeType.EntryPoint);
            cfNodes.Add(entryPoint);
            ControlFlowNode regularExit = new ControlFlowNode(index++, -1, ControlFlowNodeType.RegularExit);
            cfNodes.Add(regularExit);
            ControlFlowNode exceptionalExit = new ControlFlowNode(index++, -1, ControlFlowNodeType.ExceptionalExit);
            cfNodes.Add(exceptionalExit);

            // Create graph nodes
            labelToCfNode = new Dictionary<ILLabel, ControlFlowNode>();
            Dictionary<ILNode, ControlFlowNode>  astNodeToCfNode = new Dictionary<ILNode, ControlFlowNode>();
            foreach(ILNode node in nodes) {
                ControlFlowNode cfNode = new ControlFlowNode(index++, -1, ControlFlowNodeType.Normal);
                cfNodes.Add(cfNode);
                astNodeToCfNode[node] = cfNode;
                cfNode.UserData = node;

                // Find all contained labels
                foreach(ILLabel label in node.GetSelfAndChildrenRecursive<ILLabel>()) {
                    labelToCfNode[label] = cfNode;
                }
            }

            // Entry endge
            ControlFlowNode entryNode = labelToCfNode[entryLabel];
            ControlFlowEdge entryEdge = new ControlFlowEdge(entryPoint, entryNode, JumpType.Normal);
            entryPoint.Outgoing.Add(entryEdge);
            entryNode.Incoming.Add(entryEdge);

            // Create edges
            foreach(ILNode node in nodes) {
                ControlFlowNode source = astNodeToCfNode[node];

                // Find all branches
                foreach(ILExpression child in node.GetSelfAndChildrenRecursive<ILExpression>()) {
                    IEnumerable<ILLabel> targets = child.GetBranchTargets();
                    if (targets != null) {
                        foreach(ILLabel target in targets) {
                            ControlFlowNode destination;
                            // Labels which are out of out scope will not be int the collection
                            if (labelToCfNode.TryGetValue(target, out destination) && destination != source) {
                                ControlFlowEdge edge = new ControlFlowEdge(source, destination, JumpType.Normal);
                                source.Outgoing.Add(edge);
                                destination.Incoming.Add(edge);
                            }
                        }
                    }
                }
            }

            return new ControlFlowGraph(cfNodes.ToArray());
        }

        List<ILNode> FindLoops(HashSet<ControlFlowNode> scope, ControlFlowNode entryPoint, bool excludeEntryPoint)
        {
            List<ILNode> result = new List<ILNode>();

            Queue<ControlFlowNode> agenda  = new Queue<ControlFlowNode>();
            agenda.Enqueue(entryPoint);
            while(agenda.Count > 0) {
                ControlFlowNode node = agenda.Dequeue();

                if (scope.Contains(node)
                        && node.DominanceFrontier.Contains(node)
                        && (node != entryPoint || !excludeEntryPoint))
                {
                    HashSet<ControlFlowNode> loopContents = FindDominatedNodes(scope, node);

                    ILWhileLoop loop = new ILWhileLoop();

                    ILCondition cond;
                    HashSet<ControlFlowNode> condNodes;
                    ILLabel condLabel;
                    if (TryMatchCondition(loopContents, new ControlFlowNode[]{}, node, out cond, out condNodes, out condLabel)) {
                        loopContents.ExceptWith(condNodes);
                        scope.ExceptWith(condNodes);
                        // Use loop to implement condition
                        loop.Condition      = cond.Condition;
                        loop.PreLoopLabel   = condLabel;
                        loop.PostLoopGoto   = cond.FalseBlock.EntryGoto;
                        loop.BodyBlock      = new ILBlock() { EntryGoto = cond.TrueBlock.EntryGoto };
                    } else {
                        // Give the block some explicit entry point
                        ILLabel entryLabel  = new ILLabel() { Name = "Loop_" + (nextBlockIndex++) };
                        loop.BodyBlock      = new ILBlock() { EntryGoto = new ILExpression(ILCode.Br, entryLabel) };
                        ((ILBasicBlock)node.UserData).Body.Insert(0, entryLabel);
                    }
                    loop.BodyBlock.Body = FindLoops(loopContents, node, true);

                    // Move the content into loop block
                    scope.ExceptWith(loopContents);
                    result.Add(loop);
                }

                // Using the dominator tree should ensure we find the the widest loop first
                foreach(var child in node.DominatorTreeChildren) {
                    agenda.Enqueue(child);
                }
            }

            // Add whatever is left
            foreach(var node in scope) {
                result.Add((ILNode)node.UserData);
            }

            return result;
        }

        List<ILNode> FindLoops(HashSet<ControlFlowNode> nodes, ControlFlowNode entryPoint, bool excludeEntryPoint)
        {
            List<ILNode> result = new List<ILNode>();

            Queue<ControlFlowNode> agenda  = new Queue<ControlFlowNode>();
            agenda.Enqueue(entryPoint);
            while(agenda.Count > 0) {
                ControlFlowNode node = agenda.Dequeue();

                if (nodes.Contains(node)
                        && node.DominanceFrontier.Contains(node)
                        && (node != entryPoint || !excludeEntryPoint))
                {
                    HashSet<ControlFlowNode> loopContents = new HashSet<ControlFlowNode>();
                    FindLoopContents(nodes, loopContents, node, node);

                    // Move the content into loop block
                    nodes.ExceptWith(loopContents);
                    ILLabel entryLabel = new ILLabel() { Name = "Loop_" + (nextBlockIndex++) };
                    ((ILBlock)node.UserData).Body.Insert(0, entryLabel);
                    result.Add(new ILLoop() { ContentBlock = new ILBlock(FindLoops(loopContents, node, true)) { EntryPoint = entryLabel } });
                }

                // Using the dominator tree should ensure we find the the widest loop first
                foreach(var child in node.DominatorTreeChildren) {
                    agenda.Enqueue(child);
                }
            }

            // Add whatever is left
            foreach(var node in nodes) {
                result.Add((ILNode)node.UserData);
            }

            return result;
        }

        List<ILNode> FindConditions(HashSet<ControlFlowNode> nodes, ControlFlowNode entryNode)
        {
            List<ILNode> result = new List<ILNode>();

            Queue<ControlFlowNode> agenda  = new Queue<ControlFlowNode>();
            agenda.Enqueue(entryNode);
            while(agenda.Count > 0) {
                ControlFlowNode node = agenda.Dequeue();

                // Find a block that represents a simple condition
                if (nodes.Contains(node)) {

                    ILMoveableBlock block = node.UserData as ILMoveableBlock;

                    if (block != null && block.Body.Count == 3) {

                        ILLabel      label      = block.Body[0] as ILLabel;
                        ILExpression condBranch = block.Body[1] as ILExpression;
                        ILExpression statBranch = block.Body[2] as ILExpression;

                        // Switch
                        if (label != null &&
                            condBranch != null && condBranch.Operand is ILLabel[] && condBranch.Arguments.Count > 0 &&
                            statBranch != null && statBranch.Operand is ILLabel   && statBranch.Arguments.Count == 0)
                        {
                            ILSwitch ilSwitch = new ILSwitch() { Condition = condBranch };

                            // Replace the two branches with a conditional structure - this preserves the node label
                            block.Body.Remove(condBranch);
                            block.Body.Remove(statBranch);
                            block.Body.Add(ilSwitch);

                            ControlFlowNode statTarget = null;
                            labelToCfNode.TryGetValue((ILLabel)statBranch.Operand, out statTarget);

                            // Pull in the conditional code
                            HashSet<ControlFlowNode> frontiers = new HashSet<ControlFlowNode>();

                            if (statTarget != null)
                                frontiers.UnionWith(statTarget.DominanceFrontier);

                            foreach(ILLabel condLabel in (ILLabel[])condBranch.Operand) {
                                ControlFlowNode condTarget = null;
                                labelToCfNode.TryGetValue(condLabel, out condTarget);

                                if (condTarget != null)
                                    frontiers.UnionWith(condTarget.DominanceFrontier);
                            }

                            foreach(ILLabel condLabel in (ILLabel[])condBranch.Operand) {
                                ControlFlowNode condTarget = null;
                                labelToCfNode.TryGetValue(condLabel, out condTarget);

                                ILBlock caseBlock = new ILBlock() { EntryPoint = condLabel };
                                if (condTarget != null && !frontiers.Contains(condTarget)) {
                                    HashSet<ControlFlowNode> content = FindDominatedNodes(nodes, condTarget);
                                    nodes.ExceptWith(content);
                                    caseBlock.Body.AddRange(FindConditions(content, condTarget));
                                }
                                ilSwitch.CaseBlocks.Add(caseBlock);
                            }

                            // The labels will not be used - kill them
                            condBranch.Operand = null;

                            result.Add(block);
                            nodes.Remove(node);
                        }

                        // Two-way branch
                        if (label != null &&
                            condBranch != null && condBranch.Operand is ILLabel && condBranch.Arguments.Count > 0 &&
                            statBranch != null && statBranch.Operand is ILLabel && statBranch.Arguments.Count == 0)
                        {
                            ControlFlowNode statTarget = null;
                            labelToCfNode.TryGetValue((ILLabel)statBranch.Operand, out statTarget);
                            ControlFlowNode condTarget = null;
                            labelToCfNode.TryGetValue((ILLabel)condBranch.Operand, out condTarget);

                            ILCondition condition = new ILCondition() {
                                Condition  = condBranch,
                                TrueBlock  = new ILBlock() { EntryPoint = (ILLabel)condBranch.Operand },
                                FalseBlock = new ILBlock() { EntryPoint = (ILLabel)statBranch.Operand }
                            };

                            // Replace the two branches with a conditional structure - this preserves the node label
                            block.Body.Remove(condBranch);
                            block.Body.Remove(statBranch);
                            block.Body.Add(condition);

                            // Pull in the conditional code
                            HashSet<ControlFlowNode> frontiers = new HashSet<ControlFlowNode>();
                            if (statTarget != null)
                                frontiers.UnionWith(statTarget.DominanceFrontier);
                            if (condTarget != null)
                                frontiers.UnionWith(condTarget.DominanceFrontier);

                            if (condTarget != null && !frontiers.Contains(condTarget)) {
                                HashSet<ControlFlowNode> content = FindDominatedNodes(nodes, condTarget);
                                nodes.ExceptWith(content);
//.........这里部分代码省略.........

		internal SsaBlock(ControlFlowNode node)
		{
			this.NodeType = node.NodeType;
			this.BlockIndex = node.BlockIndex;
		}

		void CreateNodes()
		{
			// Step 2a: find basic blocks and create nodes for them
			for (int i = 0; i < methodBody.Instructions.Count; i++) {
				Instruction blockStart = methodBody.Instructions[i];
				ExceptionHandler blockStartEH = FindInnermostExceptionHandler(blockStart.Offset);
				// try and see how big we can make that block:
				for (; i + 1 < methodBody.Instructions.Count; i++) {
					Instruction inst = methodBody.Instructions[i];
					if (IsBranch(inst.OpCode) || CanThrowException(inst.OpCode))
						break;
					if (hasIncomingJumps[i + 1])
						break;
					if (inst.Next != null) {
						// ensure that blocks never contain instructions from different try blocks
						ExceptionHandler instEH = FindInnermostExceptionHandler(inst.Next.Offset);
						if (instEH != blockStartEH)
							break;
					}
				}
				
				nodes.Add(new ControlFlowNode(nodes.Count, blockStart, methodBody.Instructions[i]));
			}
			// Step 2b: Create special nodes for the exception handling constructs
			foreach (ExceptionHandler handler in methodBody.ExceptionHandlers) {
				if (handler.HandlerType == ExceptionHandlerType.Filter)
					throw new NotSupportedException();
				ControlFlowNode endFinallyOrFaultNode = null;
				if (handler.HandlerType == ExceptionHandlerType.Finally || handler.HandlerType == ExceptionHandlerType.Fault) {
					endFinallyOrFaultNode = new ControlFlowNode(nodes.Count, handler.HandlerEnd.Offset, ControlFlowNodeType.EndFinallyOrFault);
					nodes.Add(endFinallyOrFaultNode);
				}
				nodes.Add(new ControlFlowNode(nodes.Count, handler, endFinallyOrFaultNode));
			}
		}

		List<ILNode> FindLoops(HashSet<ControlFlowNode> scope, ControlFlowNode entryPoint, bool excludeEntryPoint)
		{
			List<ILNode> result = new List<ILNode>();
			
			// Do not modify entry data
			scope = new HashSet<ControlFlowNode>(scope);
			
			Queue<ControlFlowNode> agenda  = new Queue<ControlFlowNode>();
			agenda.Enqueue(entryPoint);
			while(agenda.Count > 0) {
				ControlFlowNode node = agenda.Dequeue();
				
				// If the node is a loop header
				if (scope.Contains(node)
				    && node.DominanceFrontier.Contains(node)
				    && (node != entryPoint || !excludeEntryPoint))
				{
					HashSet<ControlFlowNode> loopContents = FindLoopContent(scope, node);
					
					// If the first expression is a loop condition
					ILBasicBlock basicBlock = (ILBasicBlock)node.UserData;
					ILExpression condExpr;
					ILLabel trueLabel;
					ILLabel falseLabel;
					// It has to be just brtrue - any preceding code would introduce goto
					if(basicBlock.MatchSingleAndBr(ILCode.Brtrue, out trueLabel, out condExpr, out falseLabel))
					{
						ControlFlowNode trueTarget;
						labelToCfNode.TryGetValue(trueLabel, out trueTarget);
						ControlFlowNode falseTarget;
						labelToCfNode.TryGetValue(falseLabel, out falseTarget);
						
						// If one point inside the loop and the other outside
						if ((!loopContents.Contains(trueTarget) && loopContents.Contains(falseTarget)) ||
						    (loopContents.Contains(trueTarget) && !loopContents.Contains(falseTarget)) )
						{
							loopContents.RemoveOrThrow(node);
							scope.RemoveOrThrow(node);
							
							// If false means enter the loop
							if (loopContents.Contains(falseTarget) || falseTarget == node)
							{
								// Negate the condition
								condExpr = new ILExpression(ILCode.LogicNot, null, condExpr);
								ILLabel tmp = trueLabel;
								trueLabel = falseLabel;
								falseLabel = tmp;
							}
							
							ControlFlowNode postLoopTarget;
							labelToCfNode.TryGetValue(falseLabel, out postLoopTarget);
							if (postLoopTarget != null) {
								// Pull more nodes into the loop
								HashSet<ControlFlowNode> postLoopContents = FindDominatedNodes(scope, postLoopTarget);
								var pullIn = scope.Except(postLoopContents).Where(n => node.Dominates(n));
								loopContents.UnionWith(pullIn);
							}
							
							// Use loop to implement the brtrue
							basicBlock.Body.RemoveTail(ILCode.Brtrue, ILCode.Br);
							basicBlock.Body.Add(new ILWhileLoop() {
								Condition = condExpr,
								BodyBlock = new ILBlock() {
									EntryGoto = new ILExpression(ILCode.Br, trueLabel),
									Body = FindLoops(loopContents, node, false)
								}
							});
							basicBlock.Body.Add(new ILExpression(ILCode.Br, falseLabel));
							result.Add(basicBlock);
							
							scope.ExceptWith(loopContents);
						}
					}
					
					// Fallback method: while(true)
					if (scope.Contains(node)) {
						result.Add(new ILBasicBlock() {
							Body = new List<ILNode>() {
								new ILLabel() { Name = "Loop_" + (nextLabelIndex++) },
								new ILWhileLoop() {
									BodyBlock = new ILBlock() {
										EntryGoto = new ILExpression(ILCode.Br, (ILLabel)basicBlock.Body.First()),
										Body = FindLoops(loopContents, node, true)
									}
								},
							},
						});
						
						scope.ExceptWith(loopContents);
					}
				}

				// Using the dominator tree should ensure we find the the widest loop first
				foreach(var child in node.DominatorTreeChildren) {
					agenda.Enqueue(child);
				}
			}
			
			// Add whatever is left
			foreach(var node in scope) {
//.........这里部分代码省略.........