[NFC] Surface the validation of FunctionPropertiesAnalysis

[mtrofin]

Summary

Avoids relying on assert for some of the validation.

llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h

 #define LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
+class DominatorTree;
 class Function;
 class LoopInfo;
 
 class FunctionPropertiesInfo {
   friend class FunctionPropertiesUpdater;
   void updateForBB(const BasicBlock &BB, int64_t Direction);
   void updateAggregateStats(const Function &F, const LoopInfo &LI);
   void reIncludeBB(const BasicBlock &BB);
 
 public:
   static FunctionPropertiesInfo
-  getFunctionPropertiesInfo(const Function &F, FunctionAnalysisManager &FAM);
+  getFunctionPropertiesInfo(const Function &F, const DominatorTree &DT,
+                            const LoopInfo &LI);
+
+  static FunctionPropertiesInfo
+  getFunctionPropertiesInfo(Function &F, FunctionAnalysisManager &FAM);
 
   bool operator==(const FunctionPropertiesInfo &FPI) const {
     return std::memcmp(this, &FPI, sizeof(FunctionPropertiesInfo)) == 0;
   }
 
   bool operator!=(const FunctionPropertiesInfo &FPI) const {
     return !(*this == FPI);
   }

 /// Correctly update FunctionPropertiesInfo post-inlining. A
 /// FunctionPropertiesUpdater keeps the state necessary for tracking the changes
 /// llvm::InlineFunction makes. The idea is that inlining will at most modify
 /// a few BBs of the Caller (maybe the entry BB and definitely the callsite BB)
 /// and potentially affect exception handling BBs in the case of invoke
 /// inlining.
 class FunctionPropertiesUpdater {
 public:
-  FunctionPropertiesUpdater(FunctionPropertiesInfo &FPI, const CallBase &CB);
+  FunctionPropertiesUpdater(FunctionPropertiesInfo &FPI, CallBase &CB);
 
   void finish(FunctionAnalysisManager &FAM) const;
+  bool finishAndTest(FunctionAnalysisManager &FAM) const {
+    finish(FAM);
+    return isUpdateValid(Caller, FPI, FAM);
+  }
 
 private:
   FunctionPropertiesInfo &FPI;
-  const BasicBlock &CallSiteBB;
-  const Function &Caller;
+  BasicBlock &CallSiteBB;
+  Function &Caller;
+
+  static bool isUpdateValid(Function &F, const FunctionPropertiesInfo &FPI,
+                            FunctionAnalysisManager &FAM);
 
   DenseSet<const BasicBlock *> Successors;
 };
 } // namespace llvm
 #endif // LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

while (!Worklist.empty()) {
     MaxLoopDepth =
         std::max(MaxLoopDepth, static_cast<int64_t>(L->getLoopDepth()));
     Worklist.pop_front();
     llvm::append_range(Worklist, L->getSubLoops());
   }
 }
 
 FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo(
-    const Function &F, FunctionAnalysisManager &FAM) {
+    Function &F, FunctionAnalysisManager &FAM) {
+  return getFunctionPropertiesInfo(F, FAM.getResult<DominatorTreeAnalysis>(F),
+                                   FAM.getResult<LoopAnalysis>(F));
+}
+
+FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo(
+    const Function &F, const DominatorTree &DT, const LoopInfo &LI) {
 
   FunctionPropertiesInfo FPI;
-  // The const casts are due to the getResult API - there's no mutation of F.
-  const auto &LI = FAM.getResult<LoopAnalysis>(const_cast<Function &>(F));
-  const auto &DT =
-      FAM.getResult<DominatorTreeAnalysis>(const_cast<Function &>(F));
   for (const auto &BB : F)
     if (DT.isReachableFromEntry(&BB))
       FPI.reIncludeBB(BB);
   FPI.updateAggregateStats(F, LI);
   return FPI;
 }
 
 void FunctionPropertiesInfo::print(raw_ostream &OS) const {
FunctionPropertiesPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
   OS << "Printing analysis results of CFA for function "
      << "'" << F.getName() << "':"
      << "\n";
   AM.getResult<FunctionPropertiesAnalysis>(F).print(OS);
   return PreservedAnalyses::all();
 }
 
 FunctionPropertiesUpdater::FunctionPropertiesUpdater(
-    FunctionPropertiesInfo &FPI, const CallBase &CB)
+    FunctionPropertiesInfo &FPI, CallBase &CB)
     : FPI(FPI), CallSiteBB(*CB.getParent()), Caller(*CallSiteBB.getParent()) {
   assert(isa<CallInst>(CB) || isa<InvokeInst>(CB));
   // For BBs that are likely to change, we subtract from feature totals their
   // contribution. Some features, like max loop counts or depths, are left
   // invalid, as they will be updated post-inlining.
   SmallPtrSet<const BasicBlock *, 4> LikelyToChangeBBs;
   // The CB BB will change - it'll either be split or the callee's body (single
   // BB) will be pasted in.
if (I >= AlreadyExcludedMark)
       FPI.updateForBB(*U, -1);
     for (const auto *Succ : successors(U))
       if (!DT.isReachableFromEntry(Succ))
         Unreachable.insert(Succ);
   }
 
   const auto &LI = FAM.getResult<LoopAnalysis>(const_cast<Function &>(Caller));
   FPI.updateAggregateStats(Caller, LI);
-  assert(FPI == FunctionPropertiesInfo::getFunctionPropertiesInfo(Caller, FAM));
 }
+
+bool FunctionPropertiesUpdater::isUpdateValid(Function &F,
+                                              const FunctionPropertiesInfo &FPI,
+                                              FunctionAnalysisManager &FAM) {
+  DominatorTree DT(F);
+  LoopInfo LI(DT);
+  auto Fresh = FunctionPropertiesInfo::getFunctionPropertiesInfo(F, DT, LI);
+  return FPI == Fresh;
+}
 No newline at end of file

llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp

)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
 
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBLargerCFG) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
 
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InlineSameBBLoops) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
 
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InvokeSimple) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount), F1->size());
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount());
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InvokeUnreachableHandler) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
)IR");
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount), F1->size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
   EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, Rethrow) {
   LLVMContext C;
)IR");
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount), F1->size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
   EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, LPadChanges) {
   LLVMContext C;
)IR");
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount), F1->size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
   EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, LPadChangesConditional) {
   LLVMContext C;
)IR");
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount), F1->size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
   EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InlineSameLoopBB) {
   LLVMContext C;
)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
 
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, Unreachable) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
 
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InvokeSkipLP) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
)IR");
   auto FPI = buildFPI(*F1);
   EXPECT_EQ(FPI, ExpectedInitial);
 
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
   invalidate(*F1);
-  FPU.finish(FAM);
+  EXPECT_TRUE(FPU.finishAndTest(FAM));
   EXPECT_EQ(FPI, ExpectedFinal);
 }
 } // end anonymous namespace