1 files changed, 43 insertions, 79 deletions

diff --git a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
index fa3a09483f8..828ec991e1b 100644
--- a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
+++ b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp
@@ -126,87 +126,27 @@ private:
 
 char TestImmutableFunctionAnalysis::PassID;
 
-struct TestModulePass {
-  TestModulePass(int &RunCount) : RunCount(RunCount) {}
-
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
-    ++RunCount;
-    (void)AM.getResult<TestModuleAnalysis>(M);
-    return PreservedAnalyses::all();
-  }
-
-  static StringRef name() { return "TestModulePass"; }
-
-  int &RunCount;
-};
-
-struct TestSCCPass {
-  TestSCCPass(int &RunCount, int &AnalyzedInstrCount,
-              int &AnalyzedSCCFunctionCount, int &AnalyzedModuleFunctionCount,
-              bool OnlyUseCachedResults = false)
-      : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
-        AnalyzedSCCFunctionCount(AnalyzedSCCFunctionCount),
-        AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount),
-        OnlyUseCachedResults(OnlyUseCachedResults) {}
+struct LambdaSCCPass : public PassInfoMixin<LambdaSCCPass> {
+  template <typename T> LambdaSCCPass(T &&Arg) : Func(std::forward<T>(Arg)) {}
 
   PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
                         LazyCallGraph &CG, CGSCCUpdateResult &UR) {
-    ++RunCount;
-
-    const ModuleAnalysisManager &MAM =
-        AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C, CG).getManager();
-    FunctionAnalysisManager &FAM =
-        AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
-    if (TestModuleAnalysis::Result *TMA =
-            MAM.getCachedResult<TestModuleAnalysis>(
-                *C.begin()->getFunction().getParent()))
-      AnalyzedModuleFunctionCount += TMA->FunctionCount;
-
-    if (OnlyUseCachedResults) {
-      // Hack to force the use of the cached interface.
-      if (TestSCCAnalysis::Result *AR = AM.getCachedResult<TestSCCAnalysis>(C))
-        AnalyzedSCCFunctionCount += AR->FunctionCount;
-      for (LazyCallGraph::Node &N : C)
-        if (TestFunctionAnalysis::Result *FAR =
-                FAM.getCachedResult<TestFunctionAnalysis>(N.getFunction()))
-          AnalyzedInstrCount += FAR->InstructionCount;
-    } else {
-      // Typical path just runs the analysis as needed.
-      TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C, CG);
-      AnalyzedSCCFunctionCount += AR.FunctionCount;
-      for (LazyCallGraph::Node &N : C) {
-        TestFunctionAnalysis::Result &FAR =
-            FAM.getResult<TestFunctionAnalysis>(N.getFunction());
-        AnalyzedInstrCount += FAR.InstructionCount;
-
-        // Just ensure we get the immutable results.
-        (void)FAM.getResult<TestImmutableFunctionAnalysis>(N.getFunction());
-      }
-    }
-
-    return PreservedAnalyses::all();
+    return Func(C, AM, CG, UR);
   }
 
-  static StringRef name() { return "TestSCCPass"; }
-
-  int &RunCount;
-  int &AnalyzedInstrCount;
-  int &AnalyzedSCCFunctionCount;
-  int &AnalyzedModuleFunctionCount;
-  bool OnlyUseCachedResults;
+  std::function<PreservedAnalyses(LazyCallGraph::SCC &, CGSCCAnalysisManager &,
+                                  LazyCallGraph &, CGSCCUpdateResult &)>
+      Func;
 };
 
-struct TestFunctionPass {
-  TestFunctionPass(int &RunCount) : RunCount(RunCount) {}
+struct LambdaFunctionPass : public PassInfoMixin<LambdaFunctionPass> {
+  template <typename T> LambdaFunctionPass(T &&Arg) : Func(std::forward<T>(Arg)) {}
 
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
-    ++RunCount;
-    return PreservedAnalyses::none();
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
+    return Func(F, AM);
   }
 
-  static StringRef name() { return "TestFunctionPass"; }
-
-  int &RunCount;
+  std::function<PreservedAnalyses(Function &, FunctionAnalysisManager &)> Func;
 };
 
 std::unique_ptr<Module> parseIR(const char *IR) {
@@ -276,28 +216,52 @@ TEST(CGSCCPassManagerTest, Basic) {
   FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
 
   ModulePassManager MPM(/*DebugLogging*/ true);
-  int ModulePassRunCount1 = 0;
-  MPM.addPass(TestModulePass(ModulePassRunCount1));
+  MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
 
   CGSCCPassManager CGPM1(/*DebugLogging*/ true);
   int SCCPassRunCount1 = 0;
   int AnalyzedInstrCount1 = 0;
   int AnalyzedSCCFunctionCount1 = 0;
   int AnalyzedModuleFunctionCount1 = 0;
-  CGPM1.addPass(TestSCCPass(SCCPassRunCount1, AnalyzedInstrCount1,
-                            AnalyzedSCCFunctionCount1,
-                            AnalyzedModuleFunctionCount1));
+  CGPM1.addPass(
+      LambdaSCCPass([&](LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &CG, CGSCCUpdateResult &UR) {
+        ++SCCPassRunCount1;
+
+        const ModuleAnalysisManager &MAM =
+            AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C, CG).getManager();
+        FunctionAnalysisManager &FAM =
+            AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
+        if (TestModuleAnalysis::Result *TMA =
+                MAM.getCachedResult<TestModuleAnalysis>(
+                    *C.begin()->getFunction().getParent()))
+          AnalyzedModuleFunctionCount1 += TMA->FunctionCount;
+
+        TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C, CG);
+        AnalyzedSCCFunctionCount1 += AR.FunctionCount;
+        for (LazyCallGraph::Node &N : C) {
+          TestFunctionAnalysis::Result &FAR =
+              FAM.getResult<TestFunctionAnalysis>(N.getFunction());
+          AnalyzedInstrCount1 += FAR.InstructionCount;
+
+          // Just ensure we get the immutable results.
+          (void)FAM.getResult<TestImmutableFunctionAnalysis>(N.getFunction());
+        }
+
+        return PreservedAnalyses::all();
+      }));
 
   FunctionPassManager FPM1(/*DebugLogging*/ true);
   int FunctionPassRunCount1 = 0;
-  FPM1.addPass(TestFunctionPass(FunctionPassRunCount1));
+  FPM1.addPass(LambdaFunctionPass([&](Function &, FunctionAnalysisManager &) {
+    ++FunctionPassRunCount1;
+    return PreservedAnalyses::all();
+  }));
   CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
   MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
 
   MPM.run(*M, MAM);
 
-  EXPECT_EQ(1, ModulePassRunCount1);
-
   EXPECT_EQ(1, ModuleAnalysisRuns);
   EXPECT_EQ(4, SCCAnalysisRuns);
   EXPECT_EQ(6, FunctionAnalysisRuns);