[llvm][NFC] Factor some common data in InlineAdvice

[mtrofin]

Summary

Other derivations will all want to emit optimization remarks and, as
part of that, use debug info.

Additionally, drive-by const-ing.

[davidxl]

llvm/include/llvm/Analysis/InlineAdvisor.h

51

why making it public?

[mtrofin]

llvm/include/llvm/Analysis/InlineAdvisor.h

51

see D81515 - it is a good-enough Advice if we don't want to track any state between advice and inline, and there are a few cases like that in the MLInlineAdvisor (e.g. if the call site or callee are 'inline never')

[davidxl]

lgtm

llvm/include/llvm/Analysis/InlineAdvisor.h

 /// its impact being observable. When collecting model training data, this
 /// allows recording features/decisions/partial reward data sets.
 ///
 /// Derivations of this type are expected to be tightly coupled with their
 /// InliningAdvisors. The base type implements the minimal contractual
 /// obligations.
 class InlineAdvice {
 public:
+  InlineAdvice(InlineAdvisor *Advisor, CallBase &CB,
+               OptimizationRemarkEmitter &ORE, bool IsInliningRecommended);
+
   InlineAdvice(InlineAdvice &&) = delete;
   InlineAdvice(const InlineAdvice &) = delete;
   virtual ~InlineAdvice() {
     assert(Recorded && "InlineAdvice should have been informed of the "
                        "inliner's decision in all cases");
   }
 
   /// Exactly one of the record* APIs must be called. Implementers may extend
public:
   /// Call to indicate inlining was not attempted.
   void recordUnattemptedInlining() {
     markRecorded();
     recordUnattemptedInliningImpl();
   }
 
   /// Get the inlining recommendation.
   bool isInliningRecommended() const { return IsInliningRecommended; }
+  const DebugLoc &getOriginalCallSiteDebugLoc() const { return DLoc; }
+  const BasicBlock *getOriginalCallSiteBasicBlock() const { return Block; }
 
 protected:
-  InlineAdvice(InlineAdvisor *Advisor, CallBase &CB,
-               bool IsInliningRecommended);
-
   virtual void recordInliningImpl() {}
   virtual void recordInliningWithCalleeDeletedImpl() {}
   virtual void recordUnsuccessfulInliningImpl(const InlineResult &Result) {}
   virtual void recordUnattemptedInliningImpl() {}
 
   InlineAdvisor *const Advisor;
   /// Caller and Callee are pre-inlining.
   Function *const Caller;
   Function *const Callee;
+
+  // Capture the context of CB before inlining, as a successful inlining may
+  // change that context, and we want to report success or failure in the
+  // original context.
+  const DebugLoc DLoc;
+  const BasicBlock *const Block;
+  OptimizationRemarkEmitter &ORE;
   const bool IsInliningRecommended;
 
 private:
   void markRecorded() {
     assert(!Recorded && "Recording should happen exactly once");
     Recorded = true;
   }
 
protected:
   /// module has finished. This allows us to reliably use function pointers as
   /// unique identifiers, as an efficient implementation detail of the
   /// InlineAdvisor. Otherwise, it is possible the memory allocator
   /// re-allocate Function objects at the same address of a deleted Function;
   /// and Functions are potentially created during the function passes called
   /// after each SCC inlining (e.g. argument promotion does that).
   void freeDeletedFunctions();
 
-  bool isFunctionDeleted(Function *F) const {
+  bool isFunctionDeleted(const Function *F) const {
     return DeletedFunctions.count(F);
   }
 
 private:
   friend class InlineAdvice;
   void markFunctionAsDeleted(Function *F);
-  std::unordered_set<Function *> DeletedFunctions;
+  std::unordered_set<const Function *> DeletedFunctions;
 };
 
 /// The default (manual heuristics) implementation of the InlineAdvisor. This
 /// implementation does not need to keep state between inliner pass runs, and is
 /// reusable as-is for inliner pass test scenarios, as well as for regular use.
 class DefaultInlineAdvisor : public InlineAdvisor {
 public:
   DefaultInlineAdvisor(FunctionAnalysisManager &FAM, InlineParams Params)

llvm/lib/Analysis/InlineAdvisor.cpp

InlineDeferralScale("inline-deferral-scale",
                         cl::desc("Scale to limit the cost of inline deferral"),
                         cl::init(2), cl::Hidden);
 
 namespace {
 class DefaultInlineAdvice : public InlineAdvice {
 public:
   DefaultInlineAdvice(DefaultInlineAdvisor *Advisor, CallBase &CB,
                       Optional<InlineCost> OIC, OptimizationRemarkEmitter &ORE)
-      : InlineAdvice(Advisor, CB, OIC.hasValue()), OriginalCB(&CB), OIC(OIC),
-        ORE(ORE), DLoc(CB.getDebugLoc()), Block(CB.getParent()) {}
+      : InlineAdvice(Advisor, CB, ORE, OIC.hasValue()), OriginalCB(&CB),
+        OIC(OIC) {}
 
 private:
   void recordUnsuccessfulInliningImpl(const InlineResult &Result) override {
     using namespace ore;
     llvm::setInlineRemark(*OriginalCB, std::string(Result.getFailureReason()) +
                                            "; " + inlineCostStr(*OIC));
     ORE.emit([&]() {
       return OptimizationRemarkMissed(DEBUG_TYPE, "NotInlined", DLoc, Block)
private:
 
   void recordInliningImpl() override {
     emitInlinedInto(ORE, DLoc, Block, *Callee, *Caller, *OIC);
   }
 
 private:
   CallBase *const OriginalCB;
   Optional<InlineCost> OIC;
-  OptimizationRemarkEmitter &ORE;
-
-  // Capture the context of CB before inlining, as a successful inlining may
-  // change that context, and we want to report success or failure in the
-  // original context.
-  const DebugLoc DLoc;
-  const BasicBlock *const Block;
 };
 
 } // namespace
 
 std::unique_ptr<InlineAdvice> DefaultInlineAdvisor::getAdvice(CallBase &CB) {
   Function &Caller = *CB.getCaller();
   ProfileSummaryInfo *PSI =
       FAM.getResult<ModuleAnalysisManagerFunctionProxy>(Caller)
std::unique_ptr<InlineAdvice> DefaultInlineAdvisor::getAdvice(CallBase &CB) {
   };
   auto OIC = llvm::shouldInline(CB, GetInlineCost, ORE,
                                 Params.EnableDeferral.hasValue() &&
                                     Params.EnableDeferral.getValue());
   return std::make_unique<DefaultInlineAdvice>(this, CB, OIC, ORE);
 }
 
 InlineAdvice::InlineAdvice(InlineAdvisor *Advisor, CallBase &CB,
+                           OptimizationRemarkEmitter &ORE,
                            bool IsInliningRecommended)
     : Advisor(Advisor), Caller(CB.getCaller()), Callee(CB.getCalledFunction()),
+      DLoc(CB.getDebugLoc()), Block(CB.getParent()), ORE(ORE),
       IsInliningRecommended(IsInliningRecommended) {}
 
 void InlineAdvisor::markFunctionAsDeleted(Function *F) {
   assert((!DeletedFunctions.count(F)) &&
          "Cannot put cause a function to become dead twice!");
   DeletedFunctions.insert(F);
 }