<div dir="ltr"><br><div class="gmail_extra"><br><div class="gmail_quote">On Thu, Jun 15, 2017 at 4:56 PM, Xinliang David Li via llvm-commits <span dir="ltr"><<a href="mailto:llvm-commits@lists.llvm.org" target="_blank">llvm-commits@lists.llvm.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: davidxl<br>
Date: Thu Jun 15 18:56:59 2017<br>
New Revision: 305530<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=305530&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project?rev=305530&view=rev</a><br>
Log:<br>
[PartialInlining] Code Refactoring<br>
<br>
This is a NFC code refactoring and interface cleanup. This paves the<br>
way to enable outlining-only mode for the partial inliner.<br>
<br>
<br>
<br>
Modified:<br>
  Â  llvm/trunk/lib/Transforms/IPO/<wbr>PartialInlining.cpp<br>
<br>
Modified: llvm/trunk/lib/Transforms/IPO/<wbr>PartialInlining.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/IPO/PartialInlining.cpp?rev=305530&r1=305529&r2=305530&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-<wbr>project/llvm/trunk/lib/<wbr>Transforms/IPO/<wbr>PartialInlining.cpp?rev=<wbr>305530&r1=305529&r2=305530&<wbr>view=diff</a><br>
==============================<wbr>==============================<wbr>==================<br>
--- llvm/trunk/lib/Transforms/IPO/<wbr>PartialInlining.cpp (original)<br>
+++ llvm/trunk/lib/Transforms/IPO/<wbr>PartialInlining.cpp Thu Jun 15 18:56:59 2017<br>
@@ -103,6 +103,35 @@ struct PartialInlinerImpl {<br>
  Â bool run(Module &M);<br>
  Â Function *unswitchFunction(Function *F);<br>
<br>
+  // This class speculatively clones the the function to be partial inlined.<br>
+  // At the end of partial inlining, the remaining callsites to the cloned<br>
+  // function that are not partially inlined will be fixed up to reference<br>
+  // the original function, and the cloned function will be erased.<br>
+  struct FunctionCloner {<br>
+  Â  FunctionCloner(Function *F, FunctionOutliningInfo *OI);<br>
+  Â  ~FunctionCloner();<br>
+<br>
+  Â  // Prepare for function outlining: making sure there is only<br>
+  Â  // one incoming edge from the extracted/outlined region to<br>
+  Â  // the return block.<br>
+  Â  void NormalizeReturnBlock();<br>
+<br>
+  Â  // Do function outlining:<br>
+  Â  Function *DoFunctionOutlining();<br></blockquote><div><br></div><div>doFunctionOutlining in LLVM naming convention.</div><div><br></div><div>-- Sean Silva</div><div> </div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
+<br>
+  Â  Function *OrigFunc = nullptr;<br>
+  Â  Function *ClonedFunc = nullptr;<br>
+  Â  Function *OutlinedFunc = nullptr;<br>
+  Â  BasicBlock *OutliningCallBB = nullptr;<br>
+  Â  // ClonedFunc is inlined in one of its callers after function<br>
+  Â  // outlining.<br>
+  Â  bool IsFunctionInlined = false;<br>
+  Â  // The cost of the region to be outlined.<br>
+  Â  int OutlinedRegionCost = 0;<br>
+  Â  std::unique_ptr<<wbr>FunctionOutliningInfo> ClonedOI = nullptr;<br>
+  Â  std::unique_ptr<<wbr>BlockFrequencyInfo> ClonedFuncBFI = nullptr;<br>
+  };<br>
+<br>
 private:<br>
  Â int NumPartialInlining = 0;<br>
  Â std::function<AssumptionCache &(Function &)> *GetAssumptionCache;<br>
@@ -114,27 +143,18 @@ private:<br>
  Â // The result is no larger than 1 and is represented using BP.<br>
  Â // (Note that the outlined region's 'head' block can only have incoming<br>
  Â // edges from the guarding entry blocks).<br>
-  BranchProbability getOutliningCallBBRelativeFreq<wbr>(Function *F,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â FunctionOutliningInfo *OI,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â Function *DuplicateFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â BlockFrequencyInfo *BFI,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â BasicBlock *OutliningCallBB);<br>
+  BranchProbability getOutliningCallBBRelativeFreq<wbr>(FunctionCloner &Cloner);<br>
<br>
  Â // Return true if the callee of CS should be partially inlined with<br>
  Â // profit.<br>
-  bool shouldPartialInline(CallSite CS, Function *F, FunctionOutliningInfo *OI,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â BlockFrequencyInfo *CalleeBFI,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â BasicBlock *OutliningCallBB,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â int OutliningCallOverhead,<br>
+  bool shouldPartialInline(CallSite CS, FunctionCloner &Cloner,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â BlockFrequency WeightedOutliningRcost,<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  OptimizationRemarkEmitter &ORE);<br>
<br>
  Â // Try to inline DuplicateFunction (cloned from F with call to<br>
  Â // the OutlinedFunction into its callers. Return true<br>
  Â // if there is any successful inlining.<br>
-  bool tryPartialInline(Function *DuplicateFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Function *F, /*orignal function */<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  FunctionOutliningInfo *OI, Function *OutlinedFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  BlockFrequencyInfo *CalleeBFI);<br>
+  bool tryPartialInline(<wbr>FunctionCloner &Cloner);<br>
<br>
  Â // Compute the mapping from use site of DuplicationFunction to the enclosing<br>
  Â // BB's profile count.<br>
@@ -146,7 +166,7 @@ private:<br>
  Â  Â  Â  Â  Â  Â NumPartialInlining >= MaxNumPartialInlining);<br>
  Â }<br>
<br>
-  CallSite getCallSite(User *U) {<br>
+  static CallSite getCallSite(User *U) {<br>
  Â  Â CallSite CS;<br>
  Â  Â if (CallInst *CI = dyn_cast<CallInst>(U))<br>
  Â  Â  Â CS = CallSite(CI);<br>
@@ -157,7 +177,7 @@ private:<br>
  Â  Â return CS;<br>
  Â }<br>
<br>
-  CallSite getOneCallSiteTo(Function *F) {<br>
+  static CallSite getOneCallSiteTo(Function *F) {<br>
  Â  Â User *User = *F->user_begin();<br>
  Â  Â return getCallSite(User);<br>
  Â }<br>
@@ -171,20 +191,15 @@ private:<br>
<br>
  Â // Returns the costs associated with function outlining:<br>
  Â // - The first value is the non-weighted runtime cost for making the call<br>
-  //  Â to the outlined function 'OutlinedFunction', including the addtional<br>
-  //  Â setup cost in the outlined function itself;<br>
+  //  Â to the outlined function, including the addtional  setup cost in the<br>
+  //  Â  outlined function itself;<br>
  Â // - The second value is the estimated size of the new call sequence in<br>
-  //  Â basic block 'OutliningCallBB';<br>
-  // - The third value is the estimated size of the original code from<br>
-  //  Â function 'F' that is extracted into the outlined function.<br>
-  std::tuple<int, int, int><br>
-  computeOutliningCosts(Function *F, const FunctionOutliningInfo *OutliningInfo,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Function *OutlinedFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  BasicBlock *OutliningCallBB);<br>
+  //  Â basic block Cloner.OutliningCallBB;<br>
+  std::tuple<int, int> computeOutliningCosts(<wbr>FunctionCloner &Cloner);<br>
  Â // Compute the 'InlineCost' of block BB. InlineCost is a proxy used to<br>
  Â // approximate both the size and runtime cost (Note that in the current<br>
  Â // inline cost analysis, there is no clear distinction there either).<br>
-  int computeBBInlineCost(BasicBlock *BB);<br>
+  static int computeBBInlineCost(BasicBlock *BB);<br>
<br>
  Â std::unique_ptr<<wbr>FunctionOutliningInfo> computeOutliningInfo(Function *F);<br>
<br>
@@ -396,19 +411,19 @@ static bool hasProfileData(Function *F,<br>
  Â return false;<br>
 }<br>
<br>
-BranchProbability PartialInlinerImpl::<wbr>getOutliningCallBBRelativeFreq<wbr>(<br>
-  Â  Function *F, FunctionOutliningInfo *OI, Function *DuplicateFunction,<br>
-  Â  BlockFrequencyInfo *BFI, BasicBlock *OutliningCallBB) {<br>
+BranchProbability<br>
+PartialInlinerImpl::<wbr>getOutliningCallBBRelativeFreq<wbr>(FunctionCloner &Cloner) {<br>
<br>
  Â auto EntryFreq =<br>
-  Â  Â  BFI->getBlockFreq(&<wbr>DuplicateFunction-><wbr>getEntryBlock());<br>
-  auto OutliningCallFreq = BFI->getBlockFreq(<wbr>OutliningCallBB);<br>
+  Â  Â  Cloner.ClonedFuncBFI-><wbr>getBlockFreq(&Cloner.<wbr>ClonedFunc->getEntryBlock());<br>
+  auto OutliningCallFreq =<br>
+  Â  Â  Cloner.ClonedFuncBFI-><wbr>getBlockFreq(Cloner.<wbr>OutliningCallBB);<br>
<br>
  Â auto OutlineRegionRelFreq =<br>
  Â  Â  Â BranchProbability::<wbr>getBranchProbability(<wbr>OutliningCallFreq.<wbr>getFrequency(),<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â EntryFreq.getFrequency());<br>
<br>
-  if (hasProfileData(F, OI))<br>
+  if (hasProfileData(Cloner.<wbr>OrigFunc, Cloner.ClonedOI.get()))<br>
  Â  Â return OutlineRegionRelFreq;<br>
<br>
  Â // When profile data is not available, we need to be conservative in<br>
@@ -433,15 +448,17 @@ BranchProbability PartialInlinerImpl::ge<br>
 }<br>
<br>
 bool PartialInlinerImpl::<wbr>shouldPartialInline(<br>
-  Â  CallSite CS, Function *F /* Original Callee */, FunctionOutliningInfo *OI,<br>
-  Â  BlockFrequencyInfo *CalleeBFI, BasicBlock *OutliningCallBB,<br>
-  Â  int NonWeightedOutliningRcost, OptimizationRemarkEmitter &ORE) {<br>
+  Â  CallSite CS, FunctionCloner &Cloner, BlockFrequency WeightedOutliningRcost,<br>
+  Â  OptimizationRemarkEmitter &ORE) {<br>
+<br>
  Â using namespace ore;<br>
  Â if (SkipCostAnalysis)<br>
  Â  Â return true;<br>
<br>
  Â Instruction *Call = CS.getInstruction();<br>
  Â Function *Callee = CS.getCalledFunction();<br>
+  assert(Callee == Cloner.ClonedFunc);<br>
+<br>
  Â Function *Caller = CS.getCaller();<br>
  Â auto &CalleeTTI = (*GetTTI)(*Callee);<br>
  Â InlineCost IC = getInlineCost(CS, getInlineParams(), CalleeTTI,<br>
@@ -449,14 +466,14 @@ bool PartialInlinerImpl::<wbr>shouldPartialIn<br>
<br>
  Â if (IC.isAlways()) {<br>
  Â  Â ORE.emit(<wbr>OptimizationRemarkAnalysis(<wbr>DEBUG_TYPE, "AlwaysInline", Call)<br>
-  Â  Â  Â  Â  Â  Â << NV("Callee", F)<br>
+  Â  Â  Â  Â  Â  Â << NV("Callee", Cloner.OrigFunc)<br>
  Â  Â  Â  Â  Â  Â  << " should always be fully inlined, not partially");<br>
  Â  Â return false;<br>
  Â }<br>
<br>
  Â if (IC.isNever()) {<br>
  Â  Â ORE.emit(<wbr>OptimizationRemarkMissed(<wbr>DEBUG_TYPE, "NeverInline", Call)<br>
-  Â  Â  Â  Â  Â  Â << NV("Callee", F) << " not partially inlined into "<br>
+  Â  Â  Â  Â  Â  Â << NV("Callee", Cloner.OrigFunc) << " not partially inlined into "<br>
  Â  Â  Â  Â  Â  Â  << NV("Caller", Caller)<br>
  Â  Â  Â  Â  Â  Â  << " because it should never be inlined (cost=never)");<br>
  Â  Â return false;<br>
@@ -464,29 +481,25 @@ bool PartialInlinerImpl::<wbr>shouldPartialIn<br>
<br>
  Â if (!IC) {<br>
  Â  Â ORE.emit(<wbr>OptimizationRemarkAnalysis(<wbr>DEBUG_TYPE, "TooCostly", Call)<br>
-  Â  Â  Â  Â  Â  Â << NV("Callee", F) << " not partially inlined into "<br>
+  Â  Â  Â  Â  Â  Â << NV("Callee", Cloner.OrigFunc) << " not partially inlined into "<br>
  Â  Â  Â  Â  Â  Â  << NV("Caller", Caller) << " because too costly to inline (cost="<br>
  Â  Â  Â  Â  Â  Â  << NV("Cost", IC.getCost()) << ", threshold="<br>
  Â  Â  Â  Â  Â  Â  << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");<br>
  Â  Â return false;<br>
  Â }<br>
  Â const DataLayout &DL = Caller->getParent()-><wbr>getDataLayout();<br>
+<br>
  Â // The savings of eliminating the call:<br>
  Â int NonWeightedSavings = getCallsiteCost(CS, DL);<br>
  Â BlockFrequency NormWeightedSavings(<wbr>NonWeightedSavings);<br>
<br>
-  auto RelativeFreq =<br>
-  Â  Â  getOutliningCallBBRelativeFreq<wbr>(F, OI, Callee, CalleeBFI, OutliningCallBB);<br>
-  auto NormWeightedRcost =<br>
-  Â  Â  BlockFrequency(<wbr>NonWeightedOutliningRcost) * RelativeFreq;<br>
-<br>
  Â // Weighted saving is smaller than weighted cost, return false<br>
-  if (NormWeightedSavings < NormWeightedRcost) {<br>
+  if (NormWeightedSavings < WeightedOutliningRcost) {<br>
  Â  Â ORE.emit(<br>
  Â  Â  Â  Â OptimizationRemarkAnalysis(<wbr>DEBUG_TYPE, "OutliningCallcostTooHigh", Call)<br>
-  Â  Â  Â  << NV("Callee", F) << " not partially inlined into "<br>
+  Â  Â  Â  << NV("Callee", Cloner.OrigFunc) << " not partially inlined into "<br>
  Â  Â  Â  Â << NV("Caller", Caller) << " runtime overhead (overhead="<br>
-  Â  Â  Â  << NV("Overhead", (unsigned)NormWeightedRcost.<wbr>getFrequency())<br>
+  Â  Â  Â  << NV("Overhead", (unsigned)<wbr>WeightedOutliningRcost.<wbr>getFrequency())<br>
  Â  Â  Â  Â << ", savings="<br>
  Â  Â  Â  Â << NV("Savings", (unsigned)NormWeightedSavings.<wbr>getFrequency()) << ")"<br>
  Â  Â  Â  Â << " of making the outlined call is too high");<br>
@@ -495,7 +508,7 @@ bool PartialInlinerImpl::<wbr>shouldPartialIn<br>
  Â }<br>
<br>
  Â ORE.emit(<wbr>OptimizationRemarkAnalysis(<wbr>DEBUG_TYPE, "CanBePartiallyInlined", Call)<br>
-  Â  Â  Â  Â  Â << NV("Callee", F) << " can be partially inlined into "<br>
+  Â  Â  Â  Â  Â << NV("Callee", Cloner.OrigFunc) << " can be partially inlined into "<br>
  Â  Â  Â  Â  Â  << NV("Caller", Caller) << " with cost=" << NV("Cost", IC.getCost())<br>
  Â  Â  Â  Â  Â  << " (threshold="<br>
  Â  Â  Â  Â  Â  << NV("Threshold", IC.getCostDelta() + IC.getCost()) << ")");<br>
@@ -551,50 +564,32 @@ int PartialInlinerImpl::<wbr>computeBBInlineC<br>
  Â return InlineCost;<br>
 }<br>
<br>
-std::tuple<int, int, int> PartialInlinerImpl::<wbr>computeOutliningCosts(<br>
-  Â  Function *F, const FunctionOutliningInfo *OI, Function *OutlinedFunction,<br>
-  Â  BasicBlock *OutliningCallBB) {<br>
-  // First compute the cost of the outlined region 'OI' in the original<br>
-  // function 'F'.<br>
-  // FIXME: The code extractor (outliner) can now do code sinking/hoisting<br>
-  // to reduce outlining cost. The hoisted/sunk code currently do not<br>
-  // incur any runtime cost so it is still OK to compare the outlined<br>
-  // function cost with the outlined region in the original function.<br>
-  // If this ever changes, we will need to introduce new extractor api<br>
-  // to pass the information.<br>
-  int OutlinedRegionCost = 0;<br>
-  for (BasicBlock &BB : *F) {<br>
-  Â  if (&BB != OI->ReturnBlock &&<br>
-  Â  Â  Â  // Assuming Entry set is small -- do a linear search here:<br>
-  Â  Â  Â  std::find(OI->Entries.begin(), OI->Entries.end(), &BB) ==<br>
-  Â  Â  Â  Â  Â  OI->Entries.end()) {<br>
-  Â  Â  OutlinedRegionCost += computeBBInlineCost(&BB);<br>
-  Â  }<br>
-  }<br>
+std::tuple<int, int><br>
+PartialInlinerImpl::<wbr>computeOutliningCosts(<wbr>FunctionCloner &Cloner) {<br>
<br>
  Â // Now compute the cost of the call sequence to the outlined function<br>
  Â // 'OutlinedFunction' in BB 'OutliningCallBB':<br>
-  int OutliningFuncCallCost = computeBBInlineCost(<wbr>OutliningCallBB);<br>
+  int OutliningFuncCallCost = computeBBInlineCost(Cloner.<wbr>OutliningCallBB);<br>
<br>
  Â // Now compute the cost of the extracted/outlined function itself:<br>
  Â int OutlinedFunctionCost = 0;<br>
-  for (BasicBlock &BB : *OutlinedFunction) {<br>
+  for (BasicBlock &BB : *Cloner.OutlinedFunc) {<br>
  Â  Â OutlinedFunctionCost += computeBBInlineCost(&BB);<br>
  Â }<br>
<br>
-  assert(OutlinedFunctionCost >= OutlinedRegionCost &&<br>
+  assert(OutlinedFunctionCost >= Cloner.OutlinedRegionCost &&<br>
  Â  Â  Â  Â  "Outlined function cost should be no less than the outlined region");<br>
  Â // The code extractor introduces a new root and exit stub blocks with<br>
  Â // additional unconditional branches. Those branches will be eliminated<br>
  Â // later with bb layout. The cost should be adjusted accordingly:<br>
  Â OutlinedFunctionCost -= 2 * InlineConstants::InstrCost;<br>
<br>
-  int OutliningRuntimeOverhead = OutliningFuncCallCost +<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â (OutlinedFunctionCost - OutlinedRegionCost) +<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â ExtraOutliningPenalty;<br>
+  int OutliningRuntimeOverhead =<br>
+  Â  Â  OutliningFuncCallCost +<br>
+  Â  Â  (OutlinedFunctionCost - Cloner.OutlinedRegionCost) +<br>
+  Â  Â  ExtraOutliningPenalty;<br>
<br>
-  return std::make_tuple(<wbr>OutliningFuncCallCost, OutliningRuntimeOverhead,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â OutlinedRegionCost);<br>
+  return std::make_tuple(<wbr>OutliningFuncCallCost, OutliningRuntimeOverhead);<br>
 }<br>
<br>
 // Create the callsite to profile count map which is<br>
@@ -641,42 +636,30 @@ void PartialInlinerImpl::<wbr>computeCallsite<br>
  Â }<br>
 }<br>
<br>
-Function *PartialInlinerImpl::<wbr>unswitchFunction(Function *F) {<br>
-<br>
-  if (F->hasAddressTaken())<br>
-  Â  return nullptr;<br>
-<br>
-  // Let inliner handle it<br>
-  if (F->hasFnAttribute(Attribute::<wbr>AlwaysInline))<br>
-  Â  return nullptr;<br>
-<br>
-  if (F->hasFnAttribute(Attribute::<wbr>NoInline))<br>
-  Â  return nullptr;<br>
-<br>
-  if (PSI->isFunctionEntryCold(F))<br>
-  Â  return nullptr;<br>
-<br>
-  if (F->user_begin() == F->user_end())<br>
-  Â  return nullptr;<br>
-<br>
-  std::unique_ptr<<wbr>FunctionOutliningInfo> OI = computeOutliningInfo(F);<br>
-<br>
-  if (!OI)<br>
-  Â  return nullptr;<br>
+PartialInlinerImpl::<wbr>FunctionCloner::<wbr>FunctionCloner(Function *F,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â FunctionOutliningInfo *OI)<br>
+  Â  : OrigFunc(F) {<br>
+  ClonedOI = llvm::make_unique<<wbr>FunctionOutliningInfo>();<br>
<br>
  Â // Clone the function, so that we can hack away on it.<br>
  Â ValueToValueMapTy VMap;<br>
-  Function *DuplicateFunction = CloneFunction(F, VMap);<br>
-  BasicBlock *NewReturnBlock = cast<BasicBlock>(VMap[OI-><wbr>ReturnBlock]);<br>
-  BasicBlock *NewNonReturnBlock = cast<BasicBlock>(VMap[OI-><wbr>NonReturnBlock]);<br>
-  DenseSet<BasicBlock *> NewEntries;<br>
+  ClonedFunc = CloneFunction(F, VMap);<br>
+<br>
+  ClonedOI->ReturnBlock = cast<BasicBlock>(VMap[OI-><wbr>ReturnBlock]);<br>
+  ClonedOI->NonReturnBlock = cast<BasicBlock>(VMap[OI-><wbr>NonReturnBlock]);<br>
  Â for (BasicBlock *BB : OI->Entries) {<br>
-  Â  NewEntries.insert(cast<<wbr>BasicBlock>(VMap[BB]));<br>
+  Â  ClonedOI->Entries.push_back(<wbr>cast<BasicBlock>(VMap[BB]));<br>
+  }<br>
+  for (BasicBlock *E : OI->ReturnBlockPreds) {<br>
+  Â  BasicBlock *NewE = cast<BasicBlock>(VMap[E]);<br>
+  Â  ClonedOI->ReturnBlockPreds.<wbr>push_back(NewE);<br>
  Â }<br>
-<br>
  Â // Go ahead and update all uses to the duplicate, so that we can just<br>
  Â // use the inliner functionality when we're done hacking.<br>
-  F->replaceAllUsesWith(<wbr>DuplicateFunction);<br>
+  F->replaceAllUsesWith(<wbr>ClonedFunc);<br>
+}<br>
+<br>
+void PartialInlinerImpl::<wbr>FunctionCloner::<wbr>NormalizeReturnBlock() {<br>
<br>
  Â auto getFirstPHI = [](BasicBlock *BB) {<br>
  Â  Â BasicBlock::iterator I = BB->begin();<br>
@@ -692,14 +675,19 @@ Function *PartialInlinerImpl::<wbr>unswitchFu<br>
  Â  Â }<br>
  Â  Â return FirstPhi;<br>
  Â };<br>
+<br>
  Â // Special hackery is needed with PHI nodes that have inputs from more than<br>
  Â // one extracted block.  For simplicity, just split the PHIs into a two-level<br>
  Â // sequence of PHIs, some of which will go in the extracted region, and some<br>
  Â // of which will go outside.<br>
-  BasicBlock *PreReturn = NewReturnBlock;<br>
+  BasicBlock *PreReturn = ClonedOI->ReturnBlock;<br>
  Â // only split block when necessary:<br>
  Â PHINode *FirstPhi = getFirstPHI(PreReturn);<br>
-  unsigned NumPredsFromEntries = OI->ReturnBlockPreds.size();<br>
+  unsigned NumPredsFromEntries = ClonedOI->ReturnBlockPreds.<wbr>size();<br>
+<br>
+  if (!FirstPhi || FirstPhi-><wbr>getNumIncomingValues() <= NumPredsFromEntries + 1)<br>
+  Â  return;<br>
+<br>
  Â auto IsTrivialPhi = [](PHINode *PN) -> Value * {<br>
  Â  Â Value *CommonValue = PN->getIncomingValue(0);<br>
  Â  Â if (all_of(PN->incoming_values(),<br>
@@ -708,143 +696,185 @@ Function *PartialInlinerImpl::<wbr>unswitchFu<br>
  Â  Â return nullptr;<br>
  Â };<br>
<br>
-  if (FirstPhi && FirstPhi-><wbr>getNumIncomingValues() > NumPredsFromEntries + 1) {<br>
-<br>
-  Â  NewReturnBlock = NewReturnBlock-><wbr>splitBasicBlock(<br>
-  Â  Â  Â  NewReturnBlock-><wbr>getFirstNonPHI()->getIterator(<wbr>));<br>
-  Â  BasicBlock::iterator I = PreReturn->begin();<br>
-  Â  Instruction *Ins = &NewReturnBlock->front();<br>
-  Â  SmallVector<Instruction *, 4> DeadPhis;<br>
-  Â  while (I != PreReturn->end()) {<br>
-  Â  Â  PHINode *OldPhi = dyn_cast<PHINode>(I);<br>
-  Â  Â  if (!OldPhi)<br>
-  Â  Â  Â  break;<br>
-<br>
-  Â  Â  PHINode *RetPhi =<br>
-  Â  Â  Â  Â  PHINode::Create(OldPhi-><wbr>getType(), NumPredsFromEntries + 1, "", Ins);<br>
-  Â  Â  OldPhi->replaceAllUsesWith(<wbr>RetPhi);<br>
-  Â  Â  Ins = NewReturnBlock-><wbr>getFirstNonPHI();<br>
-<br>
-  Â  Â  RetPhi->addIncoming(&*I, PreReturn);<br>
-  Â  Â  for (BasicBlock *E : OI->ReturnBlockPreds) {<br>
-  Â  Â  Â  BasicBlock *NewE = cast<BasicBlock>(VMap[E]);<br>
-  Â  Â  Â  RetPhi->addIncoming(OldPhi-><wbr>getIncomingValueForBlock(NewE)<wbr>, NewE);<br>
-  Â  Â  Â  OldPhi->removeIncomingValue(<wbr>NewE);<br>
-  Â  Â  }<br>
-<br>
-  Â  Â  // After incoming values splitting, the old phi may become trivial.<br>
-  Â  Â  // Keeping the trivial phi can introduce definition inside the outline<br>
-  Â  Â  // region which is live-out, causing necessary overhead (load, store<br>
-  Â  Â  // arg passing etc).<br>
-  Â  Â  if (auto *OldPhiVal = IsTrivialPhi(OldPhi)) {<br>
-  Â  Â  Â  OldPhi->replaceAllUsesWith(<wbr>OldPhiVal);<br>
-  Â  Â  Â  DeadPhis.push_back(OldPhi);<br>
-  Â  Â  }<br>
+  ClonedOI->ReturnBlock = ClonedOI->ReturnBlock-><wbr>splitBasicBlock(<br>
+  Â  Â  ClonedOI->ReturnBlock-><wbr>getFirstNonPHI()->getIterator(<wbr>));<br>
+  BasicBlock::iterator I = PreReturn->begin();<br>
+  Instruction *Ins = &ClonedOI->ReturnBlock->front(<wbr>);<br>
+  SmallVector<Instruction *, 4> DeadPhis;<br>
+  while (I != PreReturn->end()) {<br>
+  Â  PHINode *OldPhi = dyn_cast<PHINode>(I);<br>
+  Â  if (!OldPhi)<br>
+  Â  Â  break;<br>
<br>
-  Â  Â  ++I;<br>
+  Â  PHINode *RetPhi =<br>
+  Â  Â  Â  PHINode::Create(OldPhi-><wbr>getType(), NumPredsFromEntries + 1, "", Ins);<br>
+  Â  OldPhi->replaceAllUsesWith(<wbr>RetPhi);<br>
+  Â  Ins = ClonedOI->ReturnBlock-><wbr>getFirstNonPHI();<br>
+<br>
+  Â  RetPhi->addIncoming(&*I, PreReturn);<br>
+  Â  for (BasicBlock *E : ClonedOI->ReturnBlockPreds) {<br>
+  Â  Â  RetPhi->addIncoming(OldPhi-><wbr>getIncomingValueForBlock(E), E);<br>
+  Â  Â  OldPhi->removeIncomingValue(E)<wbr>;<br>
+  Â  }<br>
+<br>
+  Â  // After incoming values splitting, the old phi may become trivial.<br>
+  Â  // Keeping the trivial phi can introduce definition inside the outline<br>
+  Â  // region which is live-out, causing necessary overhead (load, store<br>
+  Â  // arg passing etc).<br>
+  Â  if (auto *OldPhiVal = IsTrivialPhi(OldPhi)) {<br>
+  Â  Â  OldPhi->replaceAllUsesWith(<wbr>OldPhiVal);<br>
+  Â  Â  DeadPhis.push_back(OldPhi);<br>
+  Â  }<br>
+  Â  ++I;<br>
  Â  Â }<br>
-<br>
  Â  Â for (auto *DP : DeadPhis)<br>
  Â  Â  Â DP->eraseFromParent();<br>
<br>
-  Â  for (auto E : OI->ReturnBlockPreds) {<br>
-  Â  Â  BasicBlock *NewE = cast<BasicBlock>(VMap[E]);<br>
-  Â  Â  NewE->getTerminator()-><wbr>replaceUsesOfWith(PreReturn, NewReturnBlock);<br>
+  Â  for (auto E : ClonedOI->ReturnBlockPreds) {<br>
+  Â  Â  E->getTerminator()-><wbr>replaceUsesOfWith(PreReturn, ClonedOI->ReturnBlock);<br>
  Â  Â }<br>
-  }<br>
+}<br>
<br>
+Function *PartialInlinerImpl::<wbr>FunctionCloner::<wbr>DoFunctionOutlining() {<br>
  Â // Returns true if the block is to be partial inlined into the caller<br>
  Â // (i.e. not to be extracted to the out of line function)<br>
-  auto ToBeInlined = [&](BasicBlock *BB) {<br>
-  Â  return BB == NewReturnBlock || NewEntries.count(BB);<br>
+  auto ToBeInlined = [&, this](BasicBlock *BB) {<br>
+  Â  return BB == ClonedOI->ReturnBlock ||<br>
+  Â  Â  Â  Â  Â (std::find(ClonedOI->Entries.<wbr>begin(), ClonedOI->Entries.end(), BB) !=<br>
+  Â  Â  Â  Â  Â  ClonedOI->Entries.end());<br>
  Â };<br>
+<br>
  Â // Gather up the blocks that we're going to extract.<br>
  Â std::vector<BasicBlock *> ToExtract;<br>
-  ToExtract.push_back(<wbr>NewNonReturnBlock);<br>
-  for (BasicBlock &BB : *DuplicateFunction)<br>
-  Â  if (!ToBeInlined(&BB) && &BB != NewNonReturnBlock)<br>
+  ToExtract.push_back(ClonedOI-><wbr>NonReturnBlock);<br>
+  OutlinedRegionCost +=<br>
+  Â  Â  PartialInlinerImpl::<wbr>computeBBInlineCost(ClonedOI-><wbr>NonReturnBlock);<br>
+  for (BasicBlock &BB : *ClonedFunc)<br>
+  Â  if (!ToBeInlined(&BB) && &BB != ClonedOI->NonReturnBlock) {<br>
  Â  Â  Â ToExtract.push_back(&BB);<br>
+  Â  Â  // FIXME: the code extractor may hoist/sink more code<br>
+  Â  Â  // into the outlined function which may make the outlining<br>
+  Â  Â  // overhead (the difference of the outlined function cost<br>
+  Â  Â  // and OutliningRegionCost) look larger.<br>
+  Â  Â  OutlinedRegionCost += computeBBInlineCost(&BB);<br>
+  Â  }<br>
<br>
  Â // The CodeExtractor needs a dominator tree.<br>
  Â DominatorTree DT;<br>
-  DT.recalculate(*<wbr>DuplicateFunction);<br>
+  DT.recalculate(*ClonedFunc);<br>
<br>
  Â // Manually calculate a BlockFrequencyInfo and BranchProbabilityInfo.<br>
  Â LoopInfo LI(DT);<br>
-  BranchProbabilityInfo BPI(*DuplicateFunction, LI);<br>
-  BlockFrequencyInfo BFI(*DuplicateFunction, BPI, LI);<br>
+  BranchProbabilityInfo BPI(*ClonedFunc, LI);<br>
+  ClonedFuncBFI.reset(new BlockFrequencyInfo(*<wbr>ClonedFunc, BPI, LI));<br>
<br>
  Â // Extract the body of the if.<br>
-  Function *OutlinedFunction =<br>
-  Â  Â  CodeExtractor(ToExtract, &DT, /*AggregateArgs*/ false, &BFI, &BPI)<br>
-  Â  Â  Â  Â  .extractCodeRegion();<br>
+  OutlinedFunc = CodeExtractor(ToExtract, &DT, /*AggregateArgs*/ false,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â ClonedFuncBFI.get(), &BPI)<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â .extractCodeRegion();<br>
+<br>
+  if (OutlinedFunc) {<br>
+  Â  OutliningCallBB = PartialInlinerImpl::<wbr>getOneCallSiteTo(OutlinedFunc)<br>
+  Â  Â  Â  .getInstruction()<br>
+  Â  Â  Â  ->getParent();<br>
+  Â  assert(OutliningCallBB-><wbr>getParent() == ClonedFunc);<br>
+  }<br>
<br>
-  bool AnyInline =<br>
-  Â  Â  tryPartialInline(<wbr>DuplicateFunction, F, OI.get(), OutlinedFunction, &BFI);<br>
+  return OutlinedFunc;<br>
+}<br>
<br>
+PartialInlinerImpl::<wbr>FunctionCloner::~<wbr>FunctionCloner() {<br>
  Â // Ditch the duplicate, since we're done with it, and rewrite all remaining<br>
  Â // users (function pointers, etc.) back to the original function.<br>
-  DuplicateFunction-><wbr>replaceAllUsesWith(F);<br>
-  DuplicateFunction-><wbr>eraseFromParent();<br>
+  ClonedFunc-><wbr>replaceAllUsesWith(OrigFunc);<br>
+  ClonedFunc->eraseFromParent();<br>
+  if (!IsFunctionInlined) {<br>
+  Â  // Remove the function that is speculatively created if there is no<br>
+  Â  // reference.<br>
+  Â  if (OutlinedFunc)<br>
+  Â  Â  OutlinedFunc->eraseFromParent(<wbr>);<br>
+  }<br>
+}<br>
+<br>
+Function *PartialInlinerImpl::<wbr>unswitchFunction(Function *F) {<br>
+<br>
+  if (F->hasAddressTaken())<br>
+  Â  return nullptr;<br>
+<br>
+  // Let inliner handle it<br>
+  if (F->hasFnAttribute(Attribute::<wbr>AlwaysInline))<br>
+  Â  return nullptr;<br>
+<br>
+  if (F->hasFnAttribute(Attribute::<wbr>NoInline))<br>
+  Â  return nullptr;<br>
+<br>
+  if (PSI->isFunctionEntryCold(F))<br>
+  Â  return nullptr;<br>
+<br>
+  if (F->user_begin() == F->user_end())<br>
+  Â  return nullptr;<br>
+<br>
+  std::unique_ptr<<wbr>FunctionOutliningInfo> OI = computeOutliningInfo(F);<br>
+<br>
+  if (!OI)<br>
+  Â  return nullptr;<br>
+<br>
+  FunctionCloner Cloner(F, OI.get());<br>
+  Cloner.NormalizeReturnBlock();<br>
+  Function *OutlinedFunction = Cloner.DoFunctionOutlining();<br>
+<br>
+  bool AnyInline = tryPartialInline(Cloner);<br>
<br>
  Â if (AnyInline)<br>
  Â  Â return OutlinedFunction;<br>
<br>
-  // Remove the function that is speculatively created:<br>
-  if (OutlinedFunction)<br>
-  Â  OutlinedFunction-><wbr>eraseFromParent();<br>
-<br>
  Â return nullptr;<br>
 }<br>
<br>
-bool PartialInlinerImpl::<wbr>tryPartialInline(Function *DuplicateFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Function *F,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  FunctionOutliningInfo *OI,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Function *OutlinedFunction,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  BlockFrequencyInfo *CalleeBFI) {<br>
-  if (OutlinedFunction == nullptr)<br>
-  Â  return false;<br>
-<br>
+bool PartialInlinerImpl::<wbr>tryPartialInline(<wbr>FunctionCloner &Cloner) {<br>
  Â int NonWeightedRcost;<br>
  Â int SizeCost;<br>
-  int OutlinedRegionSizeCost;<br>
<br>
-  auto OutliningCallBB =<br>
-  Â  Â  getOneCallSiteTo(<wbr>OutlinedFunction).<wbr>getInstruction()->getParent();<br>
+  if (Cloner.OutlinedFunc == nullptr)<br>
+  Â  return false;<br>
+<br>
+  std::tie(SizeCost, NonWeightedRcost) = computeOutliningCosts(Cloner);<br>
<br>
-  std::tie(SizeCost, NonWeightedRcost, OutlinedRegionSizeCost) =<br>
-  Â  Â  computeOutliningCosts(F, OI, OutlinedFunction, OutliningCallBB);<br>
+  auto RelativeToEntryFreq = getOutliningCallBBRelativeFreq<wbr>(Cloner);<br>
+  auto WeightedRcost = BlockFrequency(<wbr>NonWeightedRcost) * RelativeToEntryFreq;<br>
<br>
  Â // The call sequence to the outlined function is larger than the original<br>
  Â // outlined region size, it does not increase the chances of inlining<br>
-  // 'F' with outlining (The inliner usies the size increase to model the<br>
-  // the cost of inlining a callee).<br>
-  if (!SkipCostAnalysis && OutlinedRegionSizeCost < SizeCost) {<br>
-  Â  OptimizationRemarkEmitter ORE(F);<br>
+  // the function with outlining (The inliner usies the size increase to<br>
+  // model the cost of inlining a callee).<br>
+  if (!SkipCostAnalysis && Cloner.OutlinedRegionCost < SizeCost) {<br>
+  Â  OptimizationRemarkEmitter ORE(Cloner.OrigFunc);<br>
  Â  Â DebugLoc DLoc;<br>
  Â  Â BasicBlock *Block;<br>
-  Â  std::tie(DLoc, Block) = getOneDebugLoc(<wbr>DuplicateFunction);<br>
+  Â  std::tie(DLoc, Block) = getOneDebugLoc(Cloner.<wbr>ClonedFunc);<br>
  Â  Â ORE.emit(<wbr>OptimizationRemarkAnalysis(<wbr>DEBUG_TYPE, "OutlineRegionTooSmall",<br>
  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â DLoc, Block)<br>
-  Â  Â  Â  Â  Â  Â << ore::NV("Function", F)<br>
+  Â  Â  Â  Â  Â  Â << ore::NV("Function", Cloner.OrigFunc)<br>
  Â  Â  Â  Â  Â  Â  << " not partially inlined into callers (Original Size = "<br>
-  Â  Â  Â  Â  Â  Â << ore::NV("<wbr>OutlinedRegionOriginalSize", OutlinedRegionSizeCost)<br>
+  Â  Â  Â  Â  Â  Â << ore::NV("<wbr>OutlinedRegionOriginalSize", Cloner.OutlinedRegionCost)<br>
  Â  Â  Â  Â  Â  Â  << ", Size of call sequence to outlined function = "<br>
  Â  Â  Â  Â  Â  Â  << ore::NV("NewSize", SizeCost) << ")");<br>
  Â  Â return false;<br>
  Â }<br>
<br>
-  assert(F->user_begin() == F->user_end() &&<br>
+  assert(Cloner.OrigFunc->user_<wbr>begin() == Cloner.OrigFunc->user_end() &&<br>
  Â  Â  Â  Â  "F's users should all be replaced!");<br>
-  std::vector<User *> Users(DuplicateFunction->user_<wbr>begin(),<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  DuplicateFunction->user_end())<wbr>;<br>
+<br>
+  std::vector<User *> Users(Cloner.ClonedFunc->user_<wbr>begin(),<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Cloner.ClonedFunc->user_end())<wbr>;<br>
<br>
  Â DenseMap<User *, uint64_t> CallSiteToProfCountMap;<br>
-  if (F->getEntryCount())<br>
-  Â  computeCallsiteToProfCountMap(<wbr>DuplicateFunction, CallSiteToProfCountMap);<br>
+  if (Cloner.OrigFunc-><wbr>getEntryCount())<br>
+  Â  computeCallsiteToProfCountMap(<wbr>Cloner.ClonedFunc, CallSiteToProfCountMap);<br>
<br>
-  auto CalleeEntryCount = F->getEntryCount();<br>
+  auto CalleeEntryCount = Cloner.OrigFunc-><wbr>getEntryCount();<br>
  Â uint64_t CalleeEntryCountV = (CalleeEntryCount ? *CalleeEntryCount : 0);<br>
+<br>
  Â bool AnyInline = false;<br>
  Â for (User *User : Users) {<br>
  Â  Â CallSite CS = getCallSite(User);<br>
@@ -854,13 +884,12 @@ bool PartialInlinerImpl::<wbr>tryPartialInlin<br>
<br>
  Â  Â OptimizationRemarkEmitter ORE(CS.getCaller());<br>
<br>
-  Â  if (!shouldPartialInline(CS, F, OI, CalleeBFI, OutliningCallBB,<br>
-  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â NonWeightedRcost, ORE))<br>
+  Â  if (!shouldPartialInline(CS, Cloner, WeightedRcost, ORE))<br>
  Â  Â  Â continue;<br>
<br>
  Â  Â ORE.emit(<br>
  Â  Â  Â  Â OptimizationRemark(DEBUG_TYPE, "PartiallyInlined", CS.getInstruction())<br>
-  Â  Â  Â  << ore::NV("Callee", F) << " partially inlined into "<br>
+  Â  Â  Â  << ore::NV("Callee", Cloner.OrigFunc) << " partially inlined into "<br>
  Â  Â  Â  Â << ore::NV("Caller", CS.getCaller()));<br>
<br>
  Â  Â InlineFunctionInfo IFI(nullptr, GetAssumptionCache, PSI);<br>
@@ -878,8 +907,11 @@ bool PartialInlinerImpl::<wbr>tryPartialInlin<br>
  Â  Â NumPartialInlined++;<br>
  Â }<br>
<br>
-  if (AnyInline && CalleeEntryCount)<br>
-  Â  F->setEntryCount(<wbr>CalleeEntryCountV);<br>
+  if (AnyInline) {<br>
+  Â  Cloner.IsFunctionInlined = true;<br>
+  Â  if (CalleeEntryCount)<br>
+  Â  Â  Cloner.OrigFunc-><wbr>setEntryCount(<wbr>CalleeEntryCountV);<br>
+  }<br>
<br>
  Â return AnyInline;<br>
 }<br>
<br>
<br>
______________________________<wbr>_________________<br>
llvm-commits mailing list<br>
<a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a><br>
<a href="http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits" rel="noreferrer" target="_blank">http://lists.llvm.org/cgi-bin/<wbr>mailman/listinfo/llvm-commits</a><br>
</blockquote></div><br></div></div>