[MLInliner] Don't inline call sites in unreachable basic blocks

[mtrofin]

Summary

This requires DominatorTree be updated, which we do in the ml inliner
case, but not in the default case, and the cost of doing so is
noticeable to compile time for the latter[1]. So the patch only affects
the ML inliner.

[1] https://llvm-compile-time-tracker.com/compare.php?from=9fc0aa45e3312944431ba7e1ca0cec99c613992b&to=7af461b1ce0d9138211ef5f883f35d5b9ddf47be&stat=wall-time

[kazu]

LGTM modulo minor cosmetic changes. Thanks!

llvm/lib/Analysis/MLInlineAdvisor.cpp

279–282

Remove the trailing space.

292–293

Could you move this up to the beginning of the function if all you need is CB?

[mtrofin]

feedback

llvm/include/llvm/Analysis/MLInlineAdvisor.h

protected:
   // introduced afterwards.
   // TODO: should we keep this updated?
   unsigned getInitialFunctionLevel(const Function &F) const;
 
   std::unique_ptr<MLModelRunner> ModelRunner;
 
 private:
   int64_t getModuleIRSize() const;
-
+  std::unique_ptr<InlineAdvice>
+  getSkipAdviceIfUnreachableCallsite(CallBase &CB);
   void print(raw_ostream &OS) const override;
 
   mutable DenseMap<const Function *, FunctionPropertiesInfo> FPICache;
 
   LazyCallGraph &CG;
 
   int64_t NodeCount = 0;
   int64_t EdgeCount = 0;

llvm/lib/Analysis/MLInlineAdvisor.cpp

FunctionPropertiesInfo &MLInlineAdvisor::getCachedFPI(Function &F) const {
   auto InsertPair =
       FPICache.insert(std::make_pair(&F, FunctionPropertiesInfo()));
   if (!InsertPair.second)
     return InsertPair.first->second;
   InsertPair.first->second = FAM.getResult<FunctionPropertiesAnalysis>(F);
   return InsertPair.first->second;
 }
 
 std::unique_ptr<InlineAdvice> MLInlineAdvisor::getAdviceImpl(CallBase &CB) {
+  if (auto Skip = getSkipAdviceIfUnreachableCallsite(CB))
+    return Skip;
+
   auto &Caller = *CB.getCaller();
   auto &Callee = *CB.getCalledFunction();
 
   auto GetAssumptionCache = [&](Function &F) -> AssumptionCache & {
     return FAM.getResult<AssumptionAnalysis>(F);
   };
   auto &TIR = FAM.getResult<TargetIRAnalysis>(Callee);
   auto &ORE = FAM.getResult<OptimizationRemarkEmitterAnalysis>(Caller);
 
   auto MandatoryKind = InlineAdvisor::getMandatoryKind(CB, FAM, ORE);
   // If this is a "never inline" case, there won't be any changes to internal
   // state we need to track, so we can just return the base InlineAdvice, which
   // will do nothing interesting.
   // Same thing if this is a recursive case.
   if (MandatoryKind == InlineAdvisor::MandatoryInliningKind::Never ||
       &Caller == &Callee)
     return getMandatoryAdvice(CB, false);
 
   bool Mandatory =

 
 std::unique_ptr<MLInlineAdvice>
 MLInlineAdvisor::getAdviceFromModel(CallBase &CB,
                                     OptimizationRemarkEmitter &ORE) {
   return std::make_unique<MLInlineAdvice>(
       this, CB, ORE, static_cast<bool>(ModelRunner->evaluate<int64_t>()));
 }
 
+std::unique_ptr<InlineAdvice>
+MLInlineAdvisor::getSkipAdviceIfUnreachableCallsite(CallBase &CB) {
+  if (!FAM.getResult<DominatorTreeAnalysis>(*CB.getCaller())
+           .isReachableFromEntry(CB.getParent()))
+    return std::make_unique<InlineAdvice>(this, CB, getCallerORE(CB), false);
+  return nullptr;
+}
+
 std::unique_ptr<InlineAdvice> MLInlineAdvisor::getMandatoryAdvice(CallBase &CB,
                                                                   bool Advice) {
   // Make sure we track inlinings in all cases - mandatory or not.
+  if (auto Skip = getSkipAdviceIfUnreachableCallsite(CB))
+    return Skip;
   if (Advice && !ForceStop)
     return getMandatoryAdviceImpl(CB);
 
   // If this is a "never inline" case, there won't be any changes to internal
   // state we need to track, so we can just return the base InlineAdvice, which
   // will do nothing interesting.
   // Same if we are forced to stop - we don't track anymore.
   return std::make_unique<InlineAdvice>(this, CB, getCallerORE(CB), Advice);

llvm/test/Transforms/Inline/ML/skip-unreachable.ll

+; Test skipping inlining when the callsite is unreachable (for both mandatory
+; and non-mandatory cases)
+; REQUIRES: llvm_inliner_model_autogenerated
+; RUN: opt -passes=inliner-ml-advisor-release -S < %s | FileCheck %s --check-prefix=CHECK
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-grtev4-linux-gnu"
+
+; Mandatory case
+define i32 @f1() {
+entry:
+  br label %exit
+some_bb:  ; unreachable - has no predecessors
+  %r = call i32 @f2()
+  br label %exit
+exit:
+  ret i32 1
+}
+
+define i32 @f2() #0 {
+  ret i32 2
+}
+
+; Non-mandatory case
+define i32 @f3() {
+entry:
+  br label %exit
+some_bb:  ; unreachable - has no predecessors
+  %r = call i32 @f4()
+  br label %exit
+exit:
+  ret i32 1
+}
+
+define i32 @f4() {
+  ret i32 2
+}
+
+attributes #0 = { alwaysinline }
+
+; CHECK-LABEL: @f1
+; CHECK-LABEL: some_bb
+; CHECK-NEXT: call i32 @f2
+; CHECK-LABEL: @f3
+; CHECK-LABEL: some_bb
+; CHECK-NEXT: call i32 @f4