From 4a81067a84e18c44898149f5afdbaa3e18b3e821 Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sun, 31 Aug 2003 01:54:59 +0000
Subject: [PATCH] Initial checkin of the CallGraphSCCPass class

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8247 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/llvm/CallGraphSCCPass.h       | 42 +++++++++++++++++++++++++++
 lib/Analysis/IPA/CallGraphSCCPass.cpp | 30 +++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 include/llvm/CallGraphSCCPass.h
 create mode 100644 lib/Analysis/IPA/CallGraphSCCPass.cpp

diff --git a/include/llvm/CallGraphSCCPass.h b/include/llvm/CallGraphSCCPass.h
new file mode 100644
index 00000000000..1c22bad503b
--- /dev/null
+++ b/include/llvm/CallGraphSCCPass.h
@@ -0,0 +1,42 @@
+//===- CallGraphSCCPass.h - Pass that operates BU on call graph -*- C++ -*-===//
+//
+// This file defines the CallGraphSCCPass class, which is used for passes which
+// are implemented as bottom-up traversals on the call graph.  Because there may
+// be cycles in the call graph, passes of this type operate on the call-graph in
+// SCC order: that is, they process function bottom-up, except for recursive
+// functions, which they process all at once.
+//
+// These passes are inherently interprocedural, and are required to keep the
+// call graph up-to-date if they do anything which could modify it.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CALL_GRAPH_SCC_PASS_H
+#define LLVM_CALL_GRAPH_SCC_PASS_H
+
+#include "llvm/Pass.h"
+
+class CallGraphNode;
+
+struct CallGraphSCCPass : public Pass {
+
+  /// runOnSCC - This method should be implemented by the subclass to perform
+  /// whatever action is necessary for the specified SCC.  Note that
+  /// non-recursive (or only self-recursive) functions will have an SCC size of
+  /// 1, where recursive portions of the call graph will have SCC size > 1.
+  ///
+  virtual bool runOnSCC(const std::vector<CallGraphNode *> &SCC) = 0;
+
+  /// run - Run this pass, returning true if a modification was made to the
+  /// module argument.  This is implemented in terms of the runOnSCC method.
+  ///
+  virtual bool run(Module &M);
+
+
+  /// getAnalysisUsage - For this class, we declare that we require and preserve
+  /// the call graph.  If the derived class implements this method, it should
+  /// always explicitly call the implementation here.
+  virtual void getAnalysisUsage(AnalysisUsage &Info) const;
+};
+
+#endif
diff --git a/lib/Analysis/IPA/CallGraphSCCPass.cpp b/lib/Analysis/IPA/CallGraphSCCPass.cpp
new file mode 100644
index 00000000000..fd5e1ca80ef
--- /dev/null
+++ b/lib/Analysis/IPA/CallGraphSCCPass.cpp
@@ -0,0 +1,30 @@
+//===- CallGraphSCCPass.cpp - Pass that operates BU on call graph ---------===//
+//
+// This file implements the CallGraphSCCPass class, which is used for passes
+// which are implemented as bottom-up traversals on the call graph.  Because
+// there may be cycles in the call graph, passes of this type operate on the
+// call-graph in SCC order: that is, they process function bottom-up, except for
+// recursive functions, which they process all at once.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/CallGraphSCCPass.h"
+#include "llvm/Analysis/CallGraph.h"
+#include "Support/TarjanSCCIterator.h"
+
+/// getAnalysisUsage - For this class, we declare that we require and preserve
+/// the call graph.  If the derived class implements this method, it should
+/// always explicitly call the implementation here.
+void CallGraphSCCPass::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.addRequired<CallGraph>();
+  AU.addPreserved<CallGraph>();
+}
+
+bool CallGraphSCCPass::run(Module &M) {
+  CallGraph &CG = getAnalysis<CallGraph>();
+  bool Changed = false;
+  for (TarjanSCC_iterator<CallGraph*> I = tarj_begin(&CG), E = tarj_end(&CG);
+       I != E; ++I)
+    Changed = runOnSCC(**I);
+  return Changed;
+}