Remove LLVM 8.0.1 files.

1 files changed, 0 insertions, 784 deletions

diff --git a/gnu/llvm/unittests/IR/PassManagerTest.cpp b/gnu/llvm/unittests/IR/PassManagerTest.cpp
deleted file mode 100644
index 13b87f1022e..00000000000
--- a/gnu/llvm/unittests/IR/PassManagerTest.cpp
+++ /dev/null
@@ -1,784 +0,0 @@
-//===- llvm/unittest/IR/PassManager.cpp - PassManager tests ---------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/IR/PassManager.h"
-#include "llvm/AsmParser/Parser.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/SourceMgr.h"
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-namespace {
-
-class TestFunctionAnalysis : public AnalysisInfoMixin<TestFunctionAnalysis> {
-public:
-  struct Result {
-    Result(int Count) : InstructionCount(Count) {}
-    int InstructionCount;
-  };
-
-  TestFunctionAnalysis(int &Runs) : Runs(Runs) {}
-
-  /// Run the analysis pass over the function and return a result.
-  Result run(Function &F, FunctionAnalysisManager &AM) {
-    ++Runs;
-    int Count = 0;
-    for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI)
-      for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
-           ++II)
-        ++Count;
-    return Result(Count);
-  }
-
-private:
-  friend AnalysisInfoMixin<TestFunctionAnalysis>;
-  static AnalysisKey Key;
-
-  int &Runs;
-};
-
-AnalysisKey TestFunctionAnalysis::Key;
-
-class TestModuleAnalysis : public AnalysisInfoMixin<TestModuleAnalysis> {
-public:
-  struct Result {
-    Result(int Count) : FunctionCount(Count) {}
-    int FunctionCount;
-  };
-
-  TestModuleAnalysis(int &Runs) : Runs(Runs) {}
-
-  Result run(Module &M, ModuleAnalysisManager &AM) {
-    ++Runs;
-    int Count = 0;
-    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
-      ++Count;
-    return Result(Count);
-  }
-
-private:
-  friend AnalysisInfoMixin<TestModuleAnalysis>;
-  static AnalysisKey Key;
-
-  int &Runs;
-};
-
-AnalysisKey TestModuleAnalysis::Key;
-
-struct TestModulePass : PassInfoMixin<TestModulePass> {
-  TestModulePass(int &RunCount) : RunCount(RunCount) {}
-
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
-    ++RunCount;
-    return PreservedAnalyses::none();
-  }
-
-  int &RunCount;
-};
-
-struct TestPreservingModulePass : PassInfoMixin<TestPreservingModulePass> {
-  PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
-    return PreservedAnalyses::all();
-  }
-};
-
-struct TestFunctionPass : PassInfoMixin<TestFunctionPass> {
-  TestFunctionPass(int &RunCount, int &AnalyzedInstrCount,
-                   int &AnalyzedFunctionCount,
-                   bool OnlyUseCachedResults = false)
-      : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
-        AnalyzedFunctionCount(AnalyzedFunctionCount),
-        OnlyUseCachedResults(OnlyUseCachedResults) {}
-
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
-    ++RunCount;
-
-    const ModuleAnalysisManager &MAM =
-        AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager();
-    if (TestModuleAnalysis::Result *TMA =
-            MAM.getCachedResult<TestModuleAnalysis>(*F.getParent()))
-      AnalyzedFunctionCount += TMA->FunctionCount;
-
-    if (OnlyUseCachedResults) {
-      // Hack to force the use of the cached interface.
-      if (TestFunctionAnalysis::Result *AR =
-              AM.getCachedResult<TestFunctionAnalysis>(F))
-        AnalyzedInstrCount += AR->InstructionCount;
-    } else {
-      // Typical path just runs the analysis as needed.
-      TestFunctionAnalysis::Result &AR = AM.getResult<TestFunctionAnalysis>(F);
-      AnalyzedInstrCount += AR.InstructionCount;
-    }
-
-    return PreservedAnalyses::all();
-  }
-
-  int &RunCount;
-  int &AnalyzedInstrCount;
-  int &AnalyzedFunctionCount;
-  bool OnlyUseCachedResults;
-};
-
-// A test function pass that invalidates all function analyses for a function
-// with a specific name.
-struct TestInvalidationFunctionPass
-    : PassInfoMixin<TestInvalidationFunctionPass> {
-  TestInvalidationFunctionPass(StringRef FunctionName) : Name(FunctionName) {}
-
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
-    return F.getName() == Name ? PreservedAnalyses::none()
-                               : PreservedAnalyses::all();
-  }
-
-  StringRef Name;
-};
-
-std::unique_ptr<Module> parseIR(LLVMContext &Context, const char *IR) {
-  SMDiagnostic Err;
-  return parseAssemblyString(IR, Err, Context);
-}
-
-class PassManagerTest : public ::testing::Test {
-protected:
-  LLVMContext Context;
-  std::unique_ptr<Module> M;
-
-public:
-  PassManagerTest()
-      : M(parseIR(Context, "define void @f() {\n"
-                           "entry:\n"
-                           "  call void @g()\n"
-                           "  call void @h()\n"
-                           "  ret void\n"
-                           "}\n"
-                           "define void @g() {\n"
-                           "  ret void\n"
-                           "}\n"
-                           "define void @h() {\n"
-                           "  ret void\n"
-                           "}\n")) {}
-};
-
-TEST(PreservedAnalysesTest, Basic) {
-  PreservedAnalyses PA1 = PreservedAnalyses();
-  {
-    auto PAC = PA1.getChecker<TestFunctionAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  {
-    auto PAC = PA1.getChecker<TestModuleAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Module>>());
-  }
-  auto PA2 = PreservedAnalyses::none();
-  {
-    auto PAC = PA2.getChecker<TestFunctionAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  auto PA3 = PreservedAnalyses::all();
-  {
-    auto PAC = PA3.getChecker<TestFunctionAnalysis>();
-    EXPECT_TRUE(PAC.preserved());
-    EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  PreservedAnalyses PA4 = PA1;
-  {
-    auto PAC = PA4.getChecker<TestFunctionAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  PA4 = PA3;
-  {
-    auto PAC = PA4.getChecker<TestFunctionAnalysis>();
-    EXPECT_TRUE(PAC.preserved());
-    EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  PA4 = std::move(PA2);
-  {
-    auto PAC = PA4.getChecker<TestFunctionAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Function>>());
-  }
-  auto PA5 = PreservedAnalyses::allInSet<AllAnalysesOn<Function>>();
-  {
-    auto PAC = PA5.getChecker<TestFunctionAnalysis>();
-    EXPECT_FALSE(PAC.preserved());
-    EXPECT_TRUE(PAC.preservedSet<AllAnalysesOn<Function>>());
-    EXPECT_FALSE(PAC.preservedSet<AllAnalysesOn<Module>>());
-  }
-}
-
-TEST(PreservedAnalysesTest, Preserve) {
-  auto PA = PreservedAnalyses::none();
-  PA.preserve<TestFunctionAnalysis>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>().preserved());
-  PA.preserve<TestModuleAnalysis>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
-
-  // Redundant calls are fine.
-  PA.preserve<TestFunctionAnalysis>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>().preserved());
-}
-
-TEST(PreservedAnalysesTest, PreserveSets) {
-  auto PA = PreservedAnalyses::none();
-  PA.preserveSet<AllAnalysesOn<Function>>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
-                  .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>()
-                   .preservedSet<AllAnalysesOn<Module>>());
-  PA.preserveSet<AllAnalysesOn<Module>>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
-                  .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Mixing is fine.
-  PA.preserve<TestFunctionAnalysis>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
-                  .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Redundant calls are fine.
-  PA.preserveSet<AllAnalysesOn<Module>>();
-  EXPECT_TRUE(PA.getChecker<TestFunctionAnalysis>()
-                  .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_TRUE(PA.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-}
-
-TEST(PreservedAnalysisTest, Intersect) {
-  // Setup the initial sets.
-  auto PA1 = PreservedAnalyses::none();
-  PA1.preserve<TestFunctionAnalysis>();
-  PA1.preserveSet<AllAnalysesOn<Module>>();
-  auto PA2 = PreservedAnalyses::none();
-  PA2.preserve<TestFunctionAnalysis>();
-  PA2.preserveSet<AllAnalysesOn<Function>>();
-  PA2.preserve<TestModuleAnalysis>();
-  PA2.preserveSet<AllAnalysesOn<Module>>();
-  auto PA3 = PreservedAnalyses::none();
-  PA3.preserve<TestModuleAnalysis>();
-  PA3.preserveSet<AllAnalysesOn<Function>>();
-
-  // Self intersection is a no-op.
-  auto Intersected = PA1;
-  Intersected.intersect(PA1);
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting with all is a no-op.
-  Intersected.intersect(PreservedAnalyses::all());
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting a narrow set with a more broad set is the narrow set.
-  Intersected.intersect(PA2);
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting a broad set with a more narrow set is the narrow set.
-  Intersected = PA2;
-  Intersected.intersect(PA1);
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting with empty clears.
-  Intersected.intersect(PreservedAnalyses::none());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>()
-                   .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting non-overlapping clears.
-  Intersected = PA1;
-  Intersected.intersect(PA3);
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>()
-                   .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting with moves works in when there is storage on both sides.
-  Intersected = PA1;
-  auto Tmp = PA2;
-  Intersected.intersect(std::move(Tmp));
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-
-  // Intersecting with move works for incoming all and existing all.
-  auto Tmp2 = PreservedAnalyses::all();
-  Intersected.intersect(std::move(Tmp2));
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-  Intersected = PreservedAnalyses::all();
-  auto Tmp3 = PA1;
-  Intersected.intersect(std::move(Tmp3));
-  EXPECT_TRUE(Intersected.getChecker<TestFunctionAnalysis>().preserved());
-  EXPECT_FALSE(Intersected.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(Intersected.getChecker<TestModuleAnalysis>().preserved());
-  EXPECT_TRUE(Intersected.getChecker<TestModuleAnalysis>()
-                  .preservedSet<AllAnalysesOn<Module>>());
-}
-
-TEST(PreservedAnalysisTest, Abandon) {
-  auto PA = PreservedAnalyses::none();
-
-  // We can abandon things after they are preserved.
-  PA.preserve<TestFunctionAnalysis>();
-  PA.abandon<TestFunctionAnalysis>();
-  EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>().preserved());
-
-  // Repeated is fine, and abandoning if they were never preserved is fine.
-  PA.abandon<TestFunctionAnalysis>();
-  EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>().preserved());
-  PA.abandon<TestModuleAnalysis>();
-  EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>().preserved());
-
-  // Even if the sets are preserved, the abandoned analyses' checker won't
-  // return true for those sets.
-  PA.preserveSet<AllAnalysesOn<Function>>();
-  PA.preserveSet<AllAnalysesOn<Module>>();
-  EXPECT_FALSE(PA.getChecker<TestFunctionAnalysis>()
-                   .preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_FALSE(PA.getChecker<TestModuleAnalysis>()
-                   .preservedSet<AllAnalysesOn<Module>>());
-
-  // But an arbitrary (opaque) analysis will still observe the sets as
-  // preserved. This also checks that we can use an explicit ID rather than
-  // a type.
-  AnalysisKey FakeKey, *FakeID = &FakeKey;
-  EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Function>>());
-  EXPECT_TRUE(PA.getChecker(FakeID).preservedSet<AllAnalysesOn<Module>>());
-}
-
-TEST_F(PassManagerTest, Basic) {
-  FunctionAnalysisManager FAM(/*DebugLogging*/ true);
-  int FunctionAnalysisRuns = 0;
-  FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
-
-  ModuleAnalysisManager MAM(/*DebugLogging*/ true);
-  int ModuleAnalysisRuns = 0;
-  MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
-  MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
-  FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
-
-  MAM.registerPass([&] { return PassInstrumentationAnalysis(); });
-  FAM.registerPass([&] { return PassInstrumentationAnalysis(); });
-
-  ModulePassManager MPM;
-
-  // Count the runs over a Function.
-  int FunctionPassRunCount1 = 0;
-  int AnalyzedInstrCount1 = 0;
-  int AnalyzedFunctionCount1 = 0;
-  {
-    // Pointless scoped copy to test move assignment.
-    ModulePassManager NestedMPM(/*DebugLogging*/ true);
-    FunctionPassManager FPM;
-    {
-      // Pointless scope to test move assignment.
-      FunctionPassManager NestedFPM(/*DebugLogging*/ true);
-      NestedFPM.addPass(TestFunctionPass(
-          FunctionPassRunCount1, AnalyzedInstrCount1, AnalyzedFunctionCount1));
-      FPM = std::move(NestedFPM);
-    }
-    NestedMPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-    MPM = std::move(NestedMPM);
-  }
-
-  // Count the runs over a module.
-  int ModulePassRunCount = 0;
-  MPM.addPass(TestModulePass(ModulePassRunCount));
-
-  // Count the runs over a Function in a separate manager.
-  int FunctionPassRunCount2 = 0;
-  int AnalyzedInstrCount2 = 0;
-  int AnalyzedFunctionCount2 = 0;
-  {
-    FunctionPassManager FPM(/*DebugLogging*/ true);
-    FPM.addPass(TestFunctionPass(FunctionPassRunCount2, AnalyzedInstrCount2,
-                                 AnalyzedFunctionCount2));
-    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-  }
-
-  // A third function pass manager but with only preserving intervening passes
-  // and with a function pass that invalidates exactly one analysis.
-  MPM.addPass(TestPreservingModulePass());
-  int FunctionPassRunCount3 = 0;
-  int AnalyzedInstrCount3 = 0;
-  int AnalyzedFunctionCount3 = 0;
-  {
-    FunctionPassManager FPM(/*DebugLogging*/ true);
-    FPM.addPass(TestFunctionPass(FunctionPassRunCount3, AnalyzedInstrCount3,
-                                 AnalyzedFunctionCount3));
-    FPM.addPass(TestInvalidationFunctionPass("f"));
-    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-  }
-
-  // A fourth function pass manager but with only preserving intervening
-  // passes but triggering the module analysis.
-  MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
-  int FunctionPassRunCount4 = 0;
-  int AnalyzedInstrCount4 = 0;
-  int AnalyzedFunctionCount4 = 0;
-  {
-    FunctionPassManager FPM;
-    FPM.addPass(TestFunctionPass(FunctionPassRunCount4, AnalyzedInstrCount4,
-                                 AnalyzedFunctionCount4));
-    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-  }
-
-  // A fifth function pass manager which invalidates one function first but
-  // uses only cached results.
-  int FunctionPassRunCount5 = 0;
-  int AnalyzedInstrCount5 = 0;
-  int AnalyzedFunctionCount5 = 0;
-  {
-    FunctionPassManager FPM(/*DebugLogging*/ true);
-    FPM.addPass(TestInvalidationFunctionPass("f"));
-    FPM.addPass(TestFunctionPass(FunctionPassRunCount5, AnalyzedInstrCount5,
-                                 AnalyzedFunctionCount5,
-                                 /*OnlyUseCachedResults=*/true));
-    MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-  }
-
-  MPM.run(*M, MAM);
-
-  // Validate module pass counters.
-  EXPECT_EQ(1, ModulePassRunCount);
-
-  // Validate all function pass counter sets are the same.
-  EXPECT_EQ(3, FunctionPassRunCount1);
-  EXPECT_EQ(5, AnalyzedInstrCount1);
-  EXPECT_EQ(0, AnalyzedFunctionCount1);
-  EXPECT_EQ(3, FunctionPassRunCount2);
-  EXPECT_EQ(5, AnalyzedInstrCount2);
-  EXPECT_EQ(0, AnalyzedFunctionCount2);
-  EXPECT_EQ(3, FunctionPassRunCount3);
-  EXPECT_EQ(5, AnalyzedInstrCount3);
-  EXPECT_EQ(0, AnalyzedFunctionCount3);
-  EXPECT_EQ(3, FunctionPassRunCount4);
-  EXPECT_EQ(5, AnalyzedInstrCount4);
-  EXPECT_EQ(9, AnalyzedFunctionCount4);
-  EXPECT_EQ(3, FunctionPassRunCount5);
-  EXPECT_EQ(2, AnalyzedInstrCount5); // Only 'g' and 'h' were cached.
-  EXPECT_EQ(9, AnalyzedFunctionCount5);
-
-  // Validate the analysis counters:
-  //   first run over 3 functions, then module pass invalidates
-  //   second run over 3 functions, nothing invalidates
-  //   third run over 0 functions, but 1 function invalidated
-  //   fourth run over 1 function
-  //   fifth run invalidates 1 function first, but runs over 0 functions
-  EXPECT_EQ(7, FunctionAnalysisRuns);
-
-  EXPECT_EQ(1, ModuleAnalysisRuns);
-}
-
-// A customized pass manager that passes extra arguments through the
-// infrastructure.
-typedef AnalysisManager<Function, int> CustomizedAnalysisManager;
-typedef PassManager<Function, CustomizedAnalysisManager, int, int &>
-    CustomizedPassManager;
-
-class CustomizedAnalysis : public AnalysisInfoMixin<CustomizedAnalysis> {
-public:
-  struct Result {
-    Result(int I) : I(I) {}
-    int I;
-  };
-
-  Result run(Function &F, CustomizedAnalysisManager &AM, int I) {
-    return Result(I);
-  }
-
-private:
-  friend AnalysisInfoMixin<CustomizedAnalysis>;
-  static AnalysisKey Key;
-};
-
-AnalysisKey CustomizedAnalysis::Key;
-
-struct CustomizedPass : PassInfoMixin<CustomizedPass> {
-  std::function<void(CustomizedAnalysis::Result &, int &)> Callback;
-
-  template <typename CallbackT>
-  CustomizedPass(CallbackT Callback) : Callback(Callback) {}
-
-  PreservedAnalyses run(Function &F, CustomizedAnalysisManager &AM, int I,
-                        int &O) {
-    Callback(AM.getResult<CustomizedAnalysis>(F, I), O);
-    return PreservedAnalyses::none();
-  }
-};
-
-TEST_F(PassManagerTest, CustomizedPassManagerArgs) {
-  CustomizedAnalysisManager AM;
-  AM.registerPass([&] { return CustomizedAnalysis(); });
-  PassInstrumentationCallbacks PIC;
-  AM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
-
-  CustomizedPassManager PM;
-
-  // Add an instance of the customized pass that just accumulates the input
-  // after it is round-tripped through the analysis.
-  int Result = 0;
-  PM.addPass(
-      CustomizedPass([](CustomizedAnalysis::Result &R, int &O) { O += R.I; }));
-
-  // Run this over every function with the input of 42.
-  for (Function &F : *M)
-    PM.run(F, AM, 42, Result);
-
-  // And ensure that we accumulated the correct result.
-  EXPECT_EQ(42 * (int)M->size(), Result);
-}
-
-/// A test analysis pass which caches in its result another analysis pass and
-/// uses it to serve queries. This requires the result to invalidate itself
-/// when its dependency is invalidated.
-struct TestIndirectFunctionAnalysis
-    : public AnalysisInfoMixin<TestIndirectFunctionAnalysis> {
-  struct Result {
-    Result(TestFunctionAnalysis::Result &FDep, TestModuleAnalysis::Result &MDep)
-        : FDep(FDep), MDep(MDep) {}
-    TestFunctionAnalysis::Result &FDep;
-    TestModuleAnalysis::Result &MDep;
-
-    bool invalidate(Function &F, const PreservedAnalyses &PA,
-                    FunctionAnalysisManager::Invalidator &Inv) {
-      auto PAC = PA.getChecker<TestIndirectFunctionAnalysis>();
-      return !(PAC.preserved() ||
-               PAC.preservedSet<AllAnalysesOn<Function>>()) ||
-             Inv.invalidate<TestFunctionAnalysis>(F, PA);
-    }
-  };
-
-  TestIndirectFunctionAnalysis(int &Runs) : Runs(Runs) {}
-
-  /// Run the analysis pass over the function and return a result.
-  Result run(Function &F, FunctionAnalysisManager &AM) {
-    ++Runs;
-    auto &FDep = AM.getResult<TestFunctionAnalysis>(F);
-    auto &Proxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
-    const ModuleAnalysisManager &MAM = Proxy.getManager();
-    // For the test, we insist that the module analysis starts off in the
-    // cache.
-    auto &MDep = *MAM.getCachedResult<TestModuleAnalysis>(*F.getParent());
-    // And register the dependency as module analysis dependencies have to be
-    // pre-registered on the proxy.
-    Proxy.registerOuterAnalysisInvalidation<TestModuleAnalysis,
-                                            TestIndirectFunctionAnalysis>();
-    return Result(FDep, MDep);
-  }
-
-private:
-  friend AnalysisInfoMixin<TestIndirectFunctionAnalysis>;
-  static AnalysisKey Key;
-
-  int &Runs;
-};
-
-AnalysisKey TestIndirectFunctionAnalysis::Key;
-
-/// A test analysis pass which chaches in its result the result from the above
-/// indirect analysis pass.
-///
-/// This allows us to ensure that whenever an analysis pass is invalidated due
-/// to dependencies (especially dependencies across IR units that trigger
-/// asynchronous invalidation) we correctly detect that this may in turn cause
-/// other analysis to be invalidated.
-struct TestDoublyIndirectFunctionAnalysis
-    : public AnalysisInfoMixin<TestDoublyIndirectFunctionAnalysis> {
-  struct Result {
-    Result(TestIndirectFunctionAnalysis::Result &IDep) : IDep(IDep) {}
-    TestIndirectFunctionAnalysis::Result &IDep;
-
-    bool invalidate(Function &F, const PreservedAnalyses &PA,
-                    FunctionAnalysisManager::Invalidator &Inv) {
-      auto PAC = PA.getChecker<TestDoublyIndirectFunctionAnalysis>();
-      return !(PAC.preserved() ||
-               PAC.preservedSet<AllAnalysesOn<Function>>()) ||
-             Inv.invalidate<TestIndirectFunctionAnalysis>(F, PA);
-    }
-  };
-
-  TestDoublyIndirectFunctionAnalysis(int &Runs) : Runs(Runs) {}
-
-  /// Run the analysis pass over the function and return a result.
-  Result run(Function &F, FunctionAnalysisManager &AM) {
-    ++Runs;
-    auto &IDep = AM.getResult<TestIndirectFunctionAnalysis>(F);
-    return Result(IDep);
-  }
-
-private:
-  friend AnalysisInfoMixin<TestDoublyIndirectFunctionAnalysis>;
-  static AnalysisKey Key;
-
-  int &Runs;
-};
-
-AnalysisKey TestDoublyIndirectFunctionAnalysis::Key;
-
-struct LambdaPass : public PassInfoMixin<LambdaPass> {
-  using FuncT = std::function<PreservedAnalyses(Function &, FunctionAnalysisManager &)>;
-
-  LambdaPass(FuncT Func) : Func(std::move(Func)) {}
-
-  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
-    return Func(F, AM);
-  }
-
-  FuncT Func;
-};
-
-TEST_F(PassManagerTest, IndirectAnalysisInvalidation) {
-  FunctionAnalysisManager FAM(/*DebugLogging*/ true);
-  int FunctionAnalysisRuns = 0, ModuleAnalysisRuns = 0,
-      IndirectAnalysisRuns = 0, DoublyIndirectAnalysisRuns = 0;
-  FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
-  FAM.registerPass(
-      [&] { return TestIndirectFunctionAnalysis(IndirectAnalysisRuns); });
-  FAM.registerPass([&] {
-    return TestDoublyIndirectFunctionAnalysis(DoublyIndirectAnalysisRuns);
-  });
-
-  ModuleAnalysisManager MAM(/*DebugLogging*/ true);
-  MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
-  MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
-  FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
-
-  PassInstrumentationCallbacks PIC;
-  MAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
-  FAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
-
-  int InstrCount = 0, FunctionCount = 0;
-  ModulePassManager MPM(/*DebugLogging*/ true);
-  FunctionPassManager FPM(/*DebugLogging*/ true);
-  // First just use the analysis to get the instruction count, and preserve
-  // everything.
-  FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
-    auto &DoublyIndirectResult =
-        AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
-    auto &IndirectResult = DoublyIndirectResult.IDep;
-    InstrCount += IndirectResult.FDep.InstructionCount;
-    FunctionCount += IndirectResult.MDep.FunctionCount;
-    return PreservedAnalyses::all();
-  }));
-  // Next, invalidate
-  //   - both analyses for "f",
-  //   - just the underlying (indirect) analysis for "g", and
-  //   - just the direct analysis for "h".
-  FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
-    auto &DoublyIndirectResult =
-        AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
-    auto &IndirectResult = DoublyIndirectResult.IDep;
-    InstrCount += IndirectResult.FDep.InstructionCount;
-    FunctionCount += IndirectResult.MDep.FunctionCount;
-    auto PA = PreservedAnalyses::none();
-    if (F.getName() == "g")
-      PA.preserve<TestFunctionAnalysis>();
-    else if (F.getName() == "h")
-      PA.preserve<TestIndirectFunctionAnalysis>();
-    return PA;
-  }));
-  // Finally, use the analysis again on each function, forcing re-computation
-  // for all of them.
-  FPM.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
-    auto &DoublyIndirectResult =
-        AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
-    auto &IndirectResult = DoublyIndirectResult.IDep;
-    InstrCount += IndirectResult.FDep.InstructionCount;
-    FunctionCount += IndirectResult.MDep.FunctionCount;
-    return PreservedAnalyses::all();
-  }));
-
-  // Create a second function pass manager. This will cause the module-level
-  // invalidation to occur, which will force yet another invalidation of the
-  // indirect function-level analysis as the module analysis it depends on gets
-  // invalidated.
-  FunctionPassManager FPM2(/*DebugLogging*/ true);
-  FPM2.addPass(LambdaPass([&](Function &F, FunctionAnalysisManager &AM) {
-    auto &DoublyIndirectResult =
-        AM.getResult<TestDoublyIndirectFunctionAnalysis>(F);
-    auto &IndirectResult = DoublyIndirectResult.IDep;
-    InstrCount += IndirectResult.FDep.InstructionCount;
-    FunctionCount += IndirectResult.MDep.FunctionCount;
-    return PreservedAnalyses::all();
-  }));
-
-  // Add a requires pass to populate the module analysis and then our function
-  // pass pipeline.
-  MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
-  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
-  // Now require the module analysis again (it will have been invalidated once)
-  // and then use it again from a function pass manager.
-  MPM.addPass(RequireAnalysisPass<TestModuleAnalysis, Module>());
-  MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM2)));
-  MPM.run(*M, MAM);
-
-  // There are generally two possible runs for each of the three functions. But
-  // for one function, we only invalidate the indirect analysis so the base one
-  // only gets run five times.
-  EXPECT_EQ(5, FunctionAnalysisRuns);
-  // The module analysis pass should be run twice here.
-  EXPECT_EQ(2, ModuleAnalysisRuns);
-  // The indirect analysis is invalidated for each function (either directly or
-  // indirectly) and run twice for each.
-  EXPECT_EQ(9, IndirectAnalysisRuns);
-  EXPECT_EQ(9, DoublyIndirectAnalysisRuns);
-
-  // There are five instructions in the module and we add the count four
-  // times.
-  EXPECT_EQ(5 * 4, InstrCount);
-
-  // There are three functions and we count them four times for each of the
-  // three functions.
-  EXPECT_EQ(3 * 4 * 3, FunctionCount);
-}
-}