[ModuleInliner] Move UseInlinePriority to InlineOrder.cpp (NFC)

[kazu]

Summary

UseInlinePriority specifies the priority function. This patch
simplifies the code by moving UseInlinePriority closer to the actual
consumer -- the switch statement inside getInlineOrder.

[taolq]

LGTM

[kazu]

Thanks for the review Liqiang!

llvm/include/llvm/Analysis/InlineOrder.h

 #include "llvm/IR/InstrTypes.h"
 #include <algorithm>
 #include <utility>
 
 namespace llvm {
 class CallBase;
 class Function;
 
-enum class InlinePriorityMode : int { Size, Cost, OptRatio };
-
 template <typename T> class InlineOrder {
 public:
   using reference = T &;
   using const_reference = const T &;
 
   virtual ~InlineOrder() = default;
 
   virtual size_t size() = 0;
 
   virtual void push(const T &Elt) = 0;
 
   virtual T pop() = 0;
 
   virtual const_reference front() = 0;
 
   virtual void erase_if(function_ref<bool(T)> Pred) = 0;
 
   bool empty() { return !size(); }
 };
 
 std::unique_ptr<InlineOrder<std::pair<CallBase *, int>>>
-getInlineOrder(InlinePriorityMode UseInlinePriority,
-               FunctionAnalysisManager &FAM, const InlineParams &Params);
+getInlineOrder(FunctionAnalysisManager &FAM, const InlineParams &Params);
 
 } // namespace llvm
 #endif // LLVM_ANALYSIS_INLINEORDER_H

llvm/lib/Analysis/InlineOrder.cpp

 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Support/CommandLine.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "inline-order"
 
+enum class InlinePriorityMode : int { Size, Cost, OptRatio };
+
+static cl::opt<InlinePriorityMode> UseInlinePriority(
+    "inline-priority-mode", cl::init(InlinePriorityMode::Size), cl::Hidden,
+    cl::desc("Choose the priority mode to use in module inline"),
+    cl::values(clEnumValN(InlinePriorityMode::Size, "size",
+                          "Use callee size priority."),
+               clEnumValN(InlinePriorityMode::Cost, "cost",
+                          "Use inline cost priority.")));
+
 namespace {
 
 class InlinePriority {
 public:
   virtual ~InlinePriority() = default;
   virtual bool hasLowerPriority(const CallBase *L, const CallBase *R) const = 0;
   virtual void update(const CallBase *CB) = 0;
   virtual bool updateAndCheckDecreased(const CallBase *CB) = 0;
static llvm::InlineCost getInlineCostWrapper(CallBase &CB,
   bool RemarksEnabled =
       Callee.getContext().getDiagHandlerPtr()->isMissedOptRemarkEnabled(
           DEBUG_TYPE);
   return getInlineCost(CB, Params, CalleeTTI, GetAssumptionCache, GetTLI,
                        GetBFI, PSI, RemarksEnabled ? &ORE : nullptr);
 }
 
 std::unique_ptr<InlineOrder<std::pair<CallBase *, int>>>
-llvm::getInlineOrder(InlinePriorityMode UseInlinePriority,
-                     FunctionAnalysisManager &FAM, const InlineParams &Params) {
+llvm::getInlineOrder(FunctionAnalysisManager &FAM, const InlineParams &Params) {
   switch (UseInlinePriority) {
   case InlinePriorityMode::Size:
     LLVM_DEBUG(dbgs() << "    Current used priority: Size priority ---- \n");
     return std::make_unique<PriorityInlineOrder>(
         std::make_unique<SizePriority>());
 
   case InlinePriorityMode::Cost:
     LLVM_DEBUG(dbgs() << "    Current used priority: Cost priority ---- \n");

llvm/lib/Transforms/IPO/ModuleInliner.cpp

 
 using namespace llvm;
 
 #define DEBUG_TYPE "module-inline"
 
 STATISTIC(NumInlined, "Number of functions inlined");
 STATISTIC(NumDeleted, "Number of functions deleted because all callers found");
 
-static cl::opt<InlinePriorityMode> UseInlinePriority(
-    "inline-priority-mode", cl::init(InlinePriorityMode::Size), cl::Hidden,
-    cl::desc("Choose the priority mode to use in module inline"),
-    cl::values(clEnumValN(InlinePriorityMode::Size, "size",
-                          "Use callee size priority."),
-               clEnumValN(InlinePriorityMode::Cost, "cost",
-                          "Use inline cost priority.")));
-
 /// Return true if the specified inline history ID
 /// indicates an inline history that includes the specified function.
 static bool inlineHistoryIncludes(
     Function *F, int InlineHistoryID,
     const SmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {
   while (InlineHistoryID != -1) {
     assert(unsigned(InlineHistoryID) < InlineHistory.size() &&
            "Invalid inline history ID");
PreservedAnalyses ModuleInlinerPass::run(Module &M,
   // the entire Module. With this module inliner, the inline order is not
   // limited to bottom-up order. More globally scope inline order is enabled.
   // Also, the inline deferral logic become unnecessary in this module inliner.
   // It is possible to use other priority heuristics, e.g. profile-based
   // heuristic.
   //
   // TODO: Here is a huge amount duplicate code between the module inliner and
   // the SCC inliner, which need some refactoring.
-  auto Calls = getInlineOrder(UseInlinePriority, FAM, Params);
+  auto Calls = getInlineOrder(FAM, Params);
   assert(Calls != nullptr && "Expected an initialized InlineOrder");
 
   // Populate the initial list of calls in this module.
   for (Function &F : M) {
     auto &ORE = FAM.getResult<OptimizationRemarkEmitterAnalysis>(F);
     // We want to generally process call sites top-down in order for
     // simplifications stemming from replacing the call with the returned value
     // after inlining to be visible to subsequent inlining decisions.