[BOLT] Add icp-inline option

[Amir]

Summary

Add an option to only peel ICP targets that can be subsequently inlined.
Yet there's no guarantee that they will be inlined.

The mode is independent from the heuristic used to choose ICP targets: by exec
count, mispredictions, or memory profile.

[rafauler]

LGTM

bolt/lib/Passes/IndirectCallPromotion.cpp

 //===- bolt/Passes/IndirectCallPromotion.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the IndirectCallPromotion class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "bolt/Passes/IndirectCallPromotion.h"
 #include "bolt/Passes/BinaryFunctionCallGraph.h"
 #include "bolt/Passes/DataflowInfoManager.h"
+#include "bolt/Passes/Inliner.h"
 #include "llvm/Support/CommandLine.h"
 
 #define DEBUG_TYPE "ICP"
 #define DEBUG_VERBOSE(Level, X)                                                \
   if (opts::Verbosity >= (Level)) {                                            \
     X;                                                                         \
   }
 
ICPOldCodeSequence("icp-old-code-sequence",
                        cl::cat(BoltOptCategory));
 
 static cl::opt<bool> ICPJumpTablesByTarget(
     "icp-jump-tables-targets",
     cl::desc(
         "for jump tables, optimize indirect jmp targets instead of indices"),
     cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
 
+static cl::opt<bool> ICPPeelForInline(
+    "icp-inline", cl::desc("only promote call targets eligible for inlining"),
+    cl::init(false), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+
 } // namespace opts
 
 namespace llvm {
 namespace bolt {
 
 namespace {
 
 bool verifyProfile(std::map<uint64_t, BinaryFunction> &BFs) {
if (!IsJumpTable || opts::ICPJumpTablesByTarget) {
                  << format("%.1f", TopNMispredictFrequency) << "% < "
                  << opts::ICPMispredictThreshold << "%\n";
         }
         return 0;
       }
     }
   }
 
+  // Filter by inline-ability of target functions, stop at first target that
+  // can't be inlined.
+  if (opts::ICPPeelForInline) {
+    for (size_t I = 0; I < N; ++I) {
+      const MCSymbol *TargetSym = Targets[I].To.Sym;
+      const BinaryFunction *TargetBF = BC.getFunctionForSymbol(TargetSym);
+      if (!BinaryFunctionPass::shouldOptimize(*TargetBF) ||
+          getInliningInfo(*TargetBF).Type == InliningType::INL_NONE) {
+        N = I;
+        break;
+      }
+    }
+  }
+
   // Filter functions that can have ICP applied (for debugging)
   if (!opts::ICPFuncsList.empty()) {
     for (std::string &Name : opts::ICPFuncsList)
       if (BF->hasName(Name))
         return N;
     return 0;
   }