ExplodedGraph* ExplodedGraph::TrimInternal(const ExplodedNode* const* BeginSources, const ExplodedNode* const* EndSources, InterExplodedGraphMap* M, llvm::DenseMap<const void*, const void*> *InverseMap) const { typedef llvm::DenseSet<const ExplodedNode*> Pass1Ty; Pass1Ty Pass1; typedef llvm::DenseMap<const ExplodedNode*, ExplodedNode*> Pass2Ty; Pass2Ty& Pass2 = M->M; SmallVector<const ExplodedNode*, 10> WL1, WL2; // ===- Pass 1 (reverse DFS) -=== for (const ExplodedNode* const* I = BeginSources; I != EndSources; ++I) { assert(*I); WL1.push_back(*I); } // Process the first worklist until it is empty. Because it is a std::list // it acts like a FIFO queue. while (!WL1.empty()) { const ExplodedNode *N = WL1.back(); WL1.pop_back(); // Have we already visited this node? If so, continue to the next one. if (Pass1.count(N)) continue; // Otherwise, mark this node as visited. Pass1.insert(N); // If this is a root enqueue it to the second worklist. if (N->Preds.empty()) { WL2.push_back(N); continue; } // Visit our predecessors and enqueue them. for (ExplodedNode::pred_iterator I = N->Preds.begin(), E = N->Preds.end(); I != E; ++I) WL1.push_back(*I); } // We didn't hit a root? Return with a null pointer for the new graph. if (WL2.empty()) return 0; // Create an empty graph. ExplodedGraph* G = MakeEmptyGraph(); // ===- Pass 2 (forward DFS to construct the new graph) -=== while (!WL2.empty()) { const ExplodedNode *N = WL2.back(); WL2.pop_back(); // Skip this node if we have already processed it. if (Pass2.find(N) != Pass2.end()) continue; // Create the corresponding node in the new graph and record the mapping // from the old node to the new node. ExplodedNode *NewN = G->getNode(N->getLocation(), N->State, N->isSink(), 0); Pass2[N] = NewN; // Also record the reverse mapping from the new node to the old node. if (InverseMap) (*InverseMap)[NewN] = N; // If this node is a root, designate it as such in the graph. if (N->Preds.empty()) G->addRoot(NewN); // In the case that some of the intended predecessors of NewN have already // been created, we should hook them up as predecessors. // Walk through the predecessors of 'N' and hook up their corresponding // nodes in the new graph (if any) to the freshly created node. for (ExplodedNode::pred_iterator I = N->Preds.begin(), E = N->Preds.end(); I != E; ++I) { Pass2Ty::iterator PI = Pass2.find(*I); if (PI == Pass2.end()) continue; NewN->addPredecessor(PI->second, *G); } // In the case that some of the intended successors of NewN have already // been created, we should hook them up as successors. Otherwise, enqueue // the new nodes from the original graph that should have nodes created // in the new graph. for (ExplodedNode::succ_iterator I = N->Succs.begin(), E = N->Succs.end(); I != E; ++I) { Pass2Ty::iterator PI = Pass2.find(*I); if (PI != Pass2.end()) { PI->second->addPredecessor(NewN, *G); continue; } // Enqueue nodes to the worklist that were marked during pass 1. if (Pass1.count(*I)) WL2.push_back(*I); } } return G; }