[llvm][NFC] Add an explicit 'ComputeFullInlineCost' API

[mtrofin]

Summary

Added getInliningCostEstimate, which is essentially what getInlineCost
computes if passed default inlining params, and non-null ORE or
InlineParams::ComputeFullInlineCost.

[davidxl]

Why not passing the 'computeFullCost' as an additional parameter to InlineCostAnalyzer?

llvm/lib/Analysis/InlineCost.cpp

716

should it define 'shouldStop()' to return false?

[mtrofin]

feedback

[mtrofin]

In D78730#2002357, @davidxl wrote:

Why not passing the 'computeFullCost' as an additional parameter to InlineCostAnalyzer?

Because InlineCostAnalyzer's finalizeAnalysis looks at threshold (see lines 633-635).

Clarified documentation of the new API.

[mtrofin]

comments

[davidxl]

Perhaps add a 'ignoreThreshold' state in InlineCostANalyzer then? IgnoreThreshold implies 'ComputeFullCost' and will be honored by the finalize Method.

[mtrofin]

simplified

[mtrofin]

In D78730#2002590, @davidxl wrote:

Perhaps add a 'ignoreThreshold' state in InlineCostANalyzer then? IgnoreThreshold implies 'ComputeFullCost' and will be honored by the finalize Method.

That's simpler, indeed. Done.

[davidxl]

looks good but I think the shouldStop method should check IgnoreThreshold as well.

[mtrofin]

feedback

[davidxl]

lgtm

llvm/include/llvm/Analysis/InlineCost.h

 InlineCost
 getInlineCost(CallBase &Call, Function *Callee, const InlineParams &Params,
               TargetTransformInfo &CalleeTTI,
               std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
               Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
               function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
               ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE);
 
+/// Get the cost estimate ignoring thresholds. This is similar to getInlineCost
+/// when passed InlineParams::ComputeFullInlineCost, or a non-null ORE. It
+/// uses default InlineParams otherwise.
+Optional<int> getInliningCostEstimate(
+    CallBase &Call, TargetTransformInfo &CalleeTTI,
+    std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
+    Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
+    ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE);
+
 /// Minimal filter to detect invalid constructs for inlining.
 InlineResult isInlineViable(Function &Callee);
 } // namespace llvm
 
 #endif

llvm/lib/Analysis/InlineCost.cpp

public:
   unsigned NumConstantPtrDiffs = 0;
   unsigned NumInstructionsSimplified = 0;
 
   void dump();
 };
 
 /// FIXME: if it is necessary to derive from InlineCostCallAnalyzer, note
 /// the FIXME in onLoweredCall, when instantiating an InlineCostCallAnalyzer
-class InlineCostCallAnalyzer final : public CallAnalyzer {
+class InlineCostCallAnalyzer : public CallAnalyzer {
+protected:
   const int CostUpperBound = INT_MAX - InlineConstants::InstrCost - 1;
   const bool ComputeFullInlineCost;
   int LoadEliminationCost = 0;
   /// Bonus to be applied when percentage of vector instructions in callee is
   /// high (see more details in updateThreshold).
   int VectorBonus = 0;
   /// Bonus to be applied when the callee has only one reachable basic block.
   int SingleBBBonus = 0;
public:
   CostAnnotationWriter Writer;
 
   void dump();
 
   virtual ~InlineCostCallAnalyzer() {}
   int getThreshold() { return Threshold; }
   int getCost() { return Cost; }
 };
+
+/// Calculate inline cost irrespective of thresholds.
+class CompleteInlineCostAnalyzer final : public InlineCostCallAnalyzer {
+public:
+  CompleteInlineCostAnalyzer(
+      const TargetTransformInfo &TTI,
+      std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
+      Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI,
+      ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE, Function &Callee,
+      CallBase &Call,
+      const InlineParams Params = {/* DefaultThreshold*/ 0,
+                                   /*HintThreshold*/ {},
+                                   /*ColdThreshold*/ {},
+                                   /*OptSizeThreshold*/ {},
+                                   /*OptMinSizeThreshold*/ {},
+                                   /*HotCallSiteThreshold*/ {},
+                                   /*LocallyHotCallSiteThreshold*/ {},
+                                   /*ColdCallSiteThreshold*/ {},
+                                   /* ComputeFullInlineCost*/ true},
+      bool BoostIndirect = true)
+      : InlineCostCallAnalyzer(TTI, GetAssumptionCache, GetBFI, PSI, ORE,
+                               Callee, Call, Params, BoostIndirect) {}
+
+  // Ignore parent's result, and just return success.
+  InlineResult finalizeAnalysis() override {
+    InlineCostCallAnalyzer::finalizeAnalysis();
+    return InlineResult::success();
+  }
+
+  // Same as parent's onLoweredCall, just that it uses itself internally. Not
+  // worth doing something more elegant, because this implementation will go
+  // away.
+  void onLoweredCall(Function *F, CallBase &Call,
+                     bool IsIndirectCall) override {
+    addCost(Call.arg_size() * InlineConstants::InstrCost);
+
+    if (IsIndirectCall && BoostIndirectCalls) {
+      auto IndirectCallParams = Params;
+      IndirectCallParams.DefaultThreshold =
+          InlineConstants::IndirectCallThreshold;
+      CompleteInlineCostAnalyzer CA(TTI, GetAssumptionCache, GetBFI, PSI, ORE,
+                                    *F, Call, IndirectCallParams, false);
+      if (CA.analyze().isSuccess()) {
+        // We were able to inline the indirect call! Subtract the cost from the
+        // threshold to get the bonus we want to apply, but don't go below zero.
+        Cost -= std::max(0, CA.getThreshold() - CA.getCost());
+      }
+    } else
+      // Otherwise simply add the cost for merely making the call.
+      addCost(InlineConstants::CallPenalty);
+  }
+};
 } // namespace
 
 /// Test whether the given value is an Alloca-derived function argument.
 bool CallAnalyzer::isAllocaDerivedArg(Value *V) {
   return SROAArgValues.count(V);
 }
 
 void CallAnalyzer::disableSROAForArg(AllocaInst *SROAArg) {
InlineCost llvm::getInlineCost(
     std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
     function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
     ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE) {
   return getInlineCost(Call, Call.getCalledFunction(), Params, CalleeTTI,
                        GetAssumptionCache, GetBFI, GetTLI, PSI, ORE);
 }
 
+Optional<int> llvm::getInliningCostEstimate(
+    CallBase &Call, TargetTransformInfo &CalleeTTI,
+    std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
+    Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
+    ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE) {
+  CompleteInlineCostAnalyzer CA(CalleeTTI, GetAssumptionCache, GetBFI, PSI, ORE,
+                                *Call.getCalledFunction(), Call);
+  auto R = CA.analyze();
+  if (!R.isSuccess())
+    return llvm::None;
+  return CA.getCost();
+}
+
 InlineCost llvm::getInlineCost(
     CallBase &Call, Function *Callee, const InlineParams &Params,
     TargetTransformInfo &CalleeTTI,
     std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
     function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
     ProfileSummaryInfo *PSI, OptimizationRemarkEmitter *ORE) {