FunctionPropertiesAnalysis: handle callsite BBs that loose edges

[mtrofin]

Summary

There could be successors that were reached before but now are only
reachable from elsewhere in the CFG.

Suppose the following diamond CFG (lines are arrows pointing down):

   A
 /   \
B     C
 \   /
   D

There's a call site in C that is inlined. Upon doing that, it turns out
it expands to:

call void @llvm.trap()
unreachable

D isn't reachable from C anymore, but we did discount it when we set up
FunctionPropertiesUpdater, so we need to re-include it here.

The patch also updates loop accounting to use LoopInfo rather than traverse BBs.

[kazu]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

225

I may be being paranoid here, but is pred_empty(Succ) a correct condition here?

If Succ doesn't have any incoming edge, we can certainly disregard it. Now, if Succ has at least one incoming edge, could we have a corner case like this?

• SuccA has no incoming edge after inlining, and
• SuccB has an incoming edge from SuccA after inlining with no other incoming edge.

In this case, neither SuccA nor SuccB is reachable from the entry basic block, but your algorithm would end up re-including SuccB.

If we know for sure that this kind of thing never happens, I wonder if we can put an assert somewhere. For example, each successor has exactly one incoming edge prior to inlining because of exception semantics or something, we may be able to assert that as we populate Successors.

[mtrofin]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

225

Good point - thanks - and we should be probably just using the dominator tree to see if a BB is reachable from the entry point. I need D127467 landed first, as this fix then depends on that.

[mtrofin]

updated to use domtree instead of counting preds

[kazu]

LGTM with some cosmetic suggestions. Thanks!

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

74

llvm::append_range(Worklist, LI);

80–81

llvm::append_range(Worklist, L->getSubLoops());

226–231

Could we simplify this a little bit like so?

for (const auto *Succ : Successors)
  if (DT.isReachableFromEntry(Succ) && ReIncluded.insert(Succ).second)
    FPI.reIncludeBB(*Succ);

We could use a SetVector as a uniquified work list and prime it with Successors as sentinels, thereby eliminating the two if statements in the while loop above like so:

SetVector<const BasicBlock *> Worklist;

if (&CallSiteBB != &*Caller.begin()) {
  FPI.reIncludeBB(*Caller.begin());
  Worklist.insert(&*Caller.begin());
}

for (const auto *Succ : Successors)
  if (DT.isReachableFromEntry(Succ) && Worklist.insert(Succ))
    FPI.reIncludeBB(*Succ);

unsigned InitialPos = Worklist.size();
Worklist.insert(&CallSiteBB);
for (unsigned I = InitialPos; I != Worklist.size(); I++) {
  const auto *BB = Worklist[I];
  FPI.reIncludeBB(*BB);
  for (const auto *Succ : successors(BB))
    Worklist.insert(Succ);
}

I hear that you have a follow-up patch. Take this suggestion only if it's compatible with your upcoming changes, of course.

[mtrofin]

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

226–231

Thanks, this looks neat!

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, const LoopInfo &LI);
+  void reIncludeBB(const BasicBlock &BB);
 
 public:
-  static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F,
-                                                          const LoopInfo &LI);
+  static FunctionPropertiesInfo
+  getFunctionPropertiesInfo(const 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);
   }

 /// 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);
 
-  void finish(const LoopInfo &LI) const;
+  void finish(FunctionAnalysisManager &FAM) const;
 
 private:
   FunctionPropertiesInfo &FPI;
   const BasicBlock &CallSiteBB;
   const Function &Caller;
 
   DenseSet<const BasicBlock *> Successors;
 };
 } // namespace llvm
 #endif // LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H

llvm/include/llvm/Analysis/MLInlineAdvisor.h

public:
   void recordUnattemptedInliningImpl() override;
 
   Function *getCaller() const { return Caller; }
   Function *getCallee() const { return Callee; }
 
   const int64_t CallerIRSize;
   const int64_t CalleeIRSize;
   const int64_t CallerAndCalleeEdges;
-  void updateCachedCallerFPI(const LoopInfo &LI) const;
+  void updateCachedCallerFPI(FunctionAnalysisManager &FAM) const;
 
 private:
   void reportContextForRemark(DiagnosticInfoOptimizationBase &OR);
   MLInlineAdvisor *getAdvisor() const {
     return static_cast<MLInlineAdvisor *>(Advisor);
   };
   // Make a copy of the FPI of the caller right before inlining. If inlining
   // fails, we can just update the cache with that value.
   const FunctionPropertiesInfo PreInlineCallerFPI;
   Optional<FunctionPropertiesUpdater> FPU;
 };
 
 } // namespace llvm
 
 #endif // LLVM_ANALYSIS_MLINLINEADVISOR_H

llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp

 //===- FunctionPropertiesAnalysis.cpp - Function Properties Analysis ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the FunctionPropertiesInfo and FunctionPropertiesAnalysis
 // classes used to extract function properties.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/IR/CFG.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include <deque>
 
 using namespace llvm;
 
 namespace {
 int64_t getNrBlocksFromCond(const BasicBlock &BB) {
   int64_t Ret = 0;
   if (const auto *BI = dyn_cast<BranchInst>(BB.getTerminator())) {
     if (BI->isConditional())
       Ret += BI->getNumSuccessors();
   } else if (const auto *SI = dyn_cast<SwitchInst>(BB.getTerminator())) {
     Ret += (SI->getNumCases() + (nullptr != SI->getDefaultDest()));
   }
   return Ret;
 }
 
 int64_t getUses(const Function &F) {
   return ((!F.hasLocalLinkage()) ? 1 : 0) + F.getNumUses();
 }
 } // namespace
 
-void FunctionPropertiesInfo::reIncludeBB(const BasicBlock &BB,
-                                         const LoopInfo &LI) {
+void FunctionPropertiesInfo::reIncludeBB(const BasicBlock &BB) {
   updateForBB(BB, +1);
-  MaxLoopDepth =
-      std::max(MaxLoopDepth, static_cast<int64_t>(LI.getLoopDepth(&BB)));
 }
 
 void FunctionPropertiesInfo::updateForBB(const BasicBlock &BB,
                                          int64_t Direction) {
   assert(Direction == 1 || Direction == -1);
   BasicBlockCount += Direction;
   BlocksReachedFromConditionalInstruction +=
       (Direction * getNrBlocksFromCond(BB));
void FunctionPropertiesInfo::updateForBB(const BasicBlock &BB,
   TotalInstructionCount += Direction * BB.sizeWithoutDebug();
 }
 
 void FunctionPropertiesInfo::updateAggregateStats(const Function &F,
                                                   const LoopInfo &LI) {
 
   Uses = getUses(F);
   TopLevelLoopCount = llvm::size(LI);
+  MaxLoopDepth = 0;
+  std::deque<const Loop *> Worklist;
+  llvm::append_range(Worklist, LI);
+  while (!Worklist.empty()) {
+    const auto *L = Worklist.front();
+    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,
-                                                  const LoopInfo &LI) {
+FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo(
+    const Function &F, FunctionAnalysisManager &FAM) {
 
   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 (!pred_empty(&BB) || BB.isEntryBlock())
-      FPI.reIncludeBB(BB, LI);
+    if (DT.isReachableFromEntry(&BB))
+      FPI.reIncludeBB(BB);
   FPI.updateAggregateStats(F, LI);
   return FPI;
 }
 
 void FunctionPropertiesInfo::print(raw_ostream &OS) const {
   OS << "BasicBlockCount: " << BasicBlockCount << "\n"
      << "BlocksReachedFromConditionalInstruction: "
      << BlocksReachedFromConditionalInstruction << "\n"
      << "Uses: " << Uses << "\n"
      << "DirectCallsToDefinedFunctions: " << DirectCallsToDefinedFunctions
      << "\n"
      << "LoadInstCount: " << LoadInstCount << "\n"
      << "StoreInstCount: " << StoreInstCount << "\n"
      << "MaxLoopDepth: " << MaxLoopDepth << "\n"
      << "TopLevelLoopCount: " << TopLevelLoopCount << "\n"
      << "TotalInstructionCount: " << TotalInstructionCount << "\n\n";
 }
 
 AnalysisKey FunctionPropertiesAnalysis::Key;
 
 FunctionPropertiesInfo
 FunctionPropertiesAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
-  return FunctionPropertiesInfo::getFunctionPropertiesInfo(
-      F, FAM.getResult<LoopAnalysis>(F));
+  return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, FAM);
 }
 
 PreservedAnalyses
 FunctionPropertiesPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
   OS << "Printing analysis results of CFA for function "
      << "'" << F.getName() << "':"
      << "\n";
   AM.getResult<FunctionPropertiesAnalysis>(F).print(OS);
FunctionPropertiesUpdater::FunctionPropertiesUpdater(
   // Commit the change. While some of the BBs accounted for above may play dual
   // role - e.g. caller's entry BB may be the same as the callsite BB - set
   // insertion semantics make sure we account them once. This needs to be
   // followed in `finish`, too.
   for (const auto *BB : LikelyToChangeBBs)
     FPI.updateForBB(*BB, -1);
 }
 
-void FunctionPropertiesUpdater::finish(const LoopInfo &LI) const {
-  DenseSet<const BasicBlock *> ReIncluded;
-  std::deque<const BasicBlock *> Worklist;
+void FunctionPropertiesUpdater::finish(FunctionAnalysisManager &FAM) const {
+  SetVector<const BasicBlock *> Worklist;
 
   if (&CallSiteBB != &*Caller.begin()) {
-    FPI.reIncludeBB(*Caller.begin(), LI);
-    ReIncluded.insert(&*Caller.begin());
+    FPI.reIncludeBB(*Caller.begin());
+    Worklist.insert(&*Caller.begin());
   }
 
   // Update feature values from the BBs that were copied from the callee, or
   // might have been modified because of inlining. The latter have been
   // subtracted in the FunctionPropertiesUpdater ctor.
-  Worklist.push_back(&CallSiteBB);
-  while (!Worklist.empty()) {
-    const auto *BB = Worklist.front();
-    Worklist.pop_front();
-    if (!ReIncluded.insert(BB).second)
-      continue;
-    FPI.reIncludeBB(*BB, LI);
-    if (!Successors.contains(BB))
-      for (const auto *Succ : successors(BB))
-        Worklist.push_back(Succ);
+  // There could be successors that were reached before but now are only
+  // reachable from elsewhere in the CFG.
+  // Suppose the following diamond CFG (lines are arrows pointing down):
+  //    A
+  //  /   \
+  // B     C
+  //  \   /
+  //    D
+  // There's a call site in C that is inlined. Upon doing that, it turns out
+  // it expands to
+  //   call void @llvm.trap()
+  //   unreachable
+  // D isn't reachable from C anymore, but we did discount it when we set up
+  // FunctionPropertiesUpdater, so we need to re-include it here.
+
+  const auto &DT =
+      FAM.getResult<DominatorTreeAnalysis>(const_cast<Function &>(Caller));
+  for (const auto *Succ : Successors)
+    if (DT.isReachableFromEntry(Succ) && Worklist.insert(Succ))
+      FPI.reIncludeBB(*Succ);
+
+  auto I = Worklist.size();
+  bool CSInsertion = Worklist.insert(&CallSiteBB);
+  (void)CSInsertion;
+  assert(CSInsertion);
+  for (; I < Worklist.size(); ++I) {
+    const auto *BB = Worklist[I];
+    FPI.reIncludeBB(*BB);
+      Worklist.insert(Succ);
   }
+
+  const auto &LI = FAM.getResult<LoopAnalysis>(const_cast<Function &>(Caller));
   FPI.updateAggregateStats(Caller, LI);
-  assert(FPI == FunctionPropertiesInfo::getFunctionPropertiesInfo(Caller, LI));
+  assert(FPI == FunctionPropertiesInfo::getFunctionPropertiesInfo(Caller, FAM));
 }

llvm/lib/Analysis/MLInlineAdvisor.cpp

 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/InlineModelFeatureMaps.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MLModelRunner.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 #if defined(LLVM_HAVE_TF_AOT_INLINERSIZEMODEL)
 #include "llvm/Analysis/ReleaseModeModelRunner.h"
void MLInlineAdvisor::onSuccessfulInlining(const MLInlineAdvice &Advice,
   assert(!ForceStop);
   Function *Caller = Advice.getCaller();
   Function *Callee = Advice.getCallee();
   // The caller features aren't valid anymore.
   {
     PreservedAnalyses PA = PreservedAnalyses::none();
     FAM.invalidate(*Caller, PA);
   }
-  Advice.updateCachedCallerFPI(FAM.getResult<LoopAnalysis>(*Caller));
+  Advice.updateCachedCallerFPI(FAM);
   int64_t IRSizeAfter =
       getIRSize(*Caller) + (CalleeWasDeleted ? 0 : Advice.CalleeIRSize);
   CurrentIRSize += IRSizeAfter - (Advice.CallerIRSize + Advice.CalleeIRSize);
   if (CurrentIRSize > SizeIncreaseThreshold * InitialIRSize)
     ForceStop = true;
 
   // We can delta-update module-wide features. We know the inlining only changed
   // the caller, and maybe the callee (by deleting the latter).
void MLInlineAdvice::reportContextForRemark(
   using namespace ore;
   OR << NV("Callee", Callee->getName());
   for (size_t I = 0; I < NumberOfFeatures; ++I)
     OR << NV(FeatureMap[I].name(),
              *getAdvisor()->getModelRunner().getTensor<int64_t>(I));
   OR << NV("ShouldInline", isInliningRecommended());
 }
 
-void MLInlineAdvice::updateCachedCallerFPI(const LoopInfo &LI) const {
-  FPU->finish(LI);
+void MLInlineAdvice::updateCachedCallerFPI(FunctionAnalysisManager &FAM) const {
+  FPU->finish(FAM);
 }
 
 void MLInlineAdvice::recordInliningImpl() {
   ORE.emit([&]() {
     OptimizationRemark R(DEBUG_TYPE, "InliningSuccess", DLoc, Block);
     reportContextForRemark(R);
     return R;
   });

llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp

 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Passes/PassBuilder.h"
+#include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "gtest/gtest.h"
 #include <cstring>
 
 using namespace llvm;
 namespace {
 
 class FunctionPropertiesAnalysisTest : public testing::Test {
+public:
+  FunctionPropertiesAnalysisTest() {
+    FAM.registerPass([&] { return DominatorTreeAnalysis(); });
+    FAM.registerPass([&] { return LoopAnalysis(); });
+    FAM.registerPass([&] { return PassInstrumentationAnalysis(); });
+  }
+
 protected:
   std::unique_ptr<DominatorTree> DT;
   std::unique_ptr<LoopInfo> LI;
+  FunctionAnalysisManager FAM;
 
   FunctionPropertiesInfo buildFPI(Function &F) {
-    DT.reset(new DominatorTree(F));
-    LI.reset(new LoopInfo(*DT));
-    return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, *LI);
+    return FunctionPropertiesInfo::getFunctionPropertiesInfo(F, FAM);
+  }
+
+  void invalidate(Function &F) {
+    PreservedAnalyses PA = PreservedAnalyses::none();
+    FAM.invalidate(F, PA);
   }
 
   std::unique_ptr<Module> makeLLVMModule(LLVMContext &C, const char *IR) {
     SMDiagnostic Err;
     std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
     if (!Mod)
       Err.print("MLAnalysisTests", errs());
     return Mod;
)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());
-  FPU.finish(*LI);
+  invalidate(*F1);
+  FPU.finish(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());
-  FPU.finish(*LI);
+  invalidate(*F1);
+  FPU.finish(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());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(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");
   CallBase* CB = findCall(*F1);
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(FAM);
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
             F1->getBasicBlockList().size());
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount());
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InvokeUnreachableHandler) {
   LLVMContext C;
)IR");
   CallBase* CB = findCall(*F1);
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(FAM);
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
             F1->getBasicBlockList().size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
-  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, LINew));
+  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, Rethrow) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 declare void @might_throw()
 
)IR");
   CallBase* CB = findCall(*F1);
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(FAM);
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
             F1->getBasicBlockList().size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
-  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, LINew));
+  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, LPadChanges) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 declare void @external_func()
 
)IR");
   CallBase* CB = findCall(*F1);
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(FAM);
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
             F1->getBasicBlockList().size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
-  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, LINew));
+  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, LPadChangesConditional) {
   LLVMContext C;
   std::unique_ptr<Module> M = makeLLVMModule(C,
                                              R"IR(
 declare void @external_func()
 
)IR");
   CallBase* CB = findCall(*F1);
   EXPECT_NE(CB, nullptr);
 
   auto FPI = buildFPI(*F1);
   FunctionPropertiesUpdater FPU(FPI, *CB);
   InlineFunctionInfo IFI;
   auto IR = llvm::InlineFunction(*CB, IFI);
   EXPECT_TRUE(IR.isSuccess());
-  DominatorTree DTNew(*F1);
-  LoopInfo LINew(DTNew);
-  FPU.finish(LINew);
+  invalidate(*F1);
+  FPU.finish(FAM);
   EXPECT_EQ(static_cast<size_t>(FPI.BasicBlockCount),
             F1->getBasicBlockList().size() - 1);
   EXPECT_EQ(static_cast<size_t>(FPI.TotalInstructionCount),
             F1->getInstructionCount() - 2);
-  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, LINew));
+  EXPECT_EQ(FPI, FunctionPropertiesInfo::getFunctionPropertiesInfo(*F1, FAM));
 }
 
 TEST_F(FunctionPropertiesAnalysisTest, InlineSameLoopBB) {
   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"
 target triple = "x86_64-pc-linux-gnu"
)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());
-  FPU.finish(*LI);
+  invalidate(*F1);
+  FPU.finish(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"
+target triple = "x86_64-pc-linux-gnu"
+
+define i64 @f1(i32 noundef %value) {
+entry:
+  br i1 true, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  %conv2 = sext i32 %value to i64
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  %call3 = call noundef i64 @f2()
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi i64 [ %conv2, %cond.true ], [ %call3, %cond.false ]
+  ret i64 %cond
+}
+
+define i64 @f2() {
+entry:
+  tail call void @llvm.trap()
+  unreachable
+}
+
+declare void @llvm.trap()
+)IR");
+
+  Function *F1 = M->getFunction("f1");
+  CallBase *CB = findCall(*F1);
+  EXPECT_NE(CB, nullptr);
+
+  FunctionPropertiesInfo ExpectedInitial;
+  ExpectedInitial.BasicBlockCount = 4;
+  ExpectedInitial.TotalInstructionCount = 7;
+  ExpectedInitial.BlocksReachedFromConditionalInstruction = 2;
+  ExpectedInitial.Uses = 1;
+  ExpectedInitial.DirectCallsToDefinedFunctions = 1;
+  
+  FunctionPropertiesInfo ExpectedFinal = ExpectedInitial;
+  ExpectedFinal.BasicBlockCount = 4;
+  ExpectedFinal.DirectCallsToDefinedFunctions = 0;
+  ExpectedFinal.TotalInstructionCount = 7;
+
+  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_EQ(FPI, ExpectedFinal);
 }
 
 } // end anonymous namespace