[BOLT][NFC] Move getInliningInfo out of Inliner class

[Amir]

Summary

getInliningInfo is useful in other passes that need to check inlining
eligibility for some function. Move the declaration and InliningInfo definition
out of Inliner class. Prepare for subsequent use in ICP.

[rafauler]

LGTM

bolt/include/bolt/Passes/Inliner.h

 #ifndef BOLT_PASSES_INLINER_H
 #define BOLT_PASSES_INLINER_H
 
 #include "bolt/Passes/BinaryPasses.h"
 
 namespace llvm {
 namespace bolt {
 
-class Inliner : public BinaryFunctionPass {
-private:
-  enum InliningType : char {
-    INL_NONE = 0, /// Cannot inline
-    INL_TAILCALL, /// Can inline at tail call site
-    INL_ANY       /// Can inline at any call site
-  };
 
-  struct InliningInfo {
-    InliningType Type{INL_NONE};
-    uint64_t SizeAfterInlining{0};
-    uint64_t SizeAfterTailCallInlining{0};
 
-    InliningInfo(InliningType Type = INL_NONE) : Type(Type) {}
-  };
 
+/// Check if the inliner can handle inlining of \p BF.
+InliningInfo getInliningInfo(const BinaryFunction &BF);
+
+class Inliner : public BinaryFunctionPass {
   std::unordered_map<const BinaryFunction *, InliningInfo> InliningCandidates;
 
   /// Count total amount of bytes inlined for all instances of Inliner.
   /// Note that this number could be negative indicating that the inliner
   /// reduced the size.
   int64_t TotalInlinedBytes{0};
 
   /// Dynamic count of calls eliminated.
class Inliner : public BinaryFunctionPass {
   /// Inline a function call \p CallInst to function \p Callee.
   ///
   /// Return the location (basic block and instruction iterator) where the code
   /// of the caller function continues after the inlined code.
   std::pair<BinaryBasicBlock *, BinaryBasicBlock::iterator>
   inlineCall(BinaryBasicBlock &CallerBB, BinaryBasicBlock::iterator CallInst,
              const BinaryFunction &Callee);
 
-  /// Check if the inliner can handle inlining of \p BF.
-  InliningInfo getInliningInfo(const BinaryFunction &BF) const;
-
 public:
   explicit Inliner(const cl::opt<bool> &PrintPass)
       : BinaryFunctionPass(PrintPass) {}
 
   const char *getName() const override { return "inlining"; }
 
   bool shouldPrint(const BinaryFunction &BF) const override {
     return BinaryFunctionPass::shouldPrint(BF) && Modified.count(&BF) > 0;

bolt/lib/Passes/Inliner.cpp

uint64_t Inliner::getSizeOfTailCallInst(const BinaryContext &BC) {
 
   MCInst Inst;
   BC.MIB->createTailCall(Inst, BC.Ctx->createNamedTempSymbol(), BC.Ctx.get());
   SizeOfTailCallInst = BC.computeInstructionSize(Inst);
 
   return SizeOfTailCallInst;
 }
 
-Inliner::InliningInfo Inliner::getInliningInfo(const BinaryFunction &BF) const {
-  if (!shouldOptimize(BF))
-    return INL_NONE;
-
+InliningInfo getInliningInfo(const BinaryFunction &BF) {
   const BinaryContext &BC = BF.getBinaryContext();
   bool DirectSP = false;
   bool HasCFI = false;
   bool IsLeaf = true;
 
   // Perform necessary checks unless the option overrides it.
   if (!opts::mustConsider(BF)) {
     if (BF.hasSDTMarker())
InliningInfo getInliningInfo(const BinaryFunction &BF) {
   }
 
   return Info;
 }
 
 void Inliner::findInliningCandidates(BinaryContext &BC) {
   for (const auto &BFI : BC.getBinaryFunctions()) {
     const BinaryFunction &Function = BFI.second;
+    if (!shouldOptimize(Function))
+      continue;
     const InliningInfo InlInfo = getInliningInfo(Function);
     if (InlInfo.Type != INL_NONE)
       InliningCandidates[&Function] = InlInfo;
   }
 }
 
 std::pair<BinaryBasicBlock *, BinaryBasicBlock::iterator>
 Inliner::inlineCall(BinaryBasicBlock &CallerBB,