1 //===- CallSiteSplitting.cpp ----------------------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements a transformation that tries to split a call-site to pass
11 // more constrained arguments if its argument is predicated in the control flow
12 // so that we can expose better context to the later passes (e.g, inliner, jump
13 // threading, or IPA-CP based function cloning, etc.).
14 // As of now we support two cases :
15 //
16 // 1) Try to a split call-site with constrained arguments, if any constraints
17 // on any argument can be found by following the single predecessors of the
18 // all site's predecessors. Currently this pass only handles call-sites with 2
19 // predecessors. For example, in the code below, we try to split the call-site
20 // since we can predicate the argument(ptr) based on the OR condition.
21 //
22 // Split from :
23 //   if (!ptr || c)
24 //     callee(ptr);
25 // to :
26 //   if (!ptr)
27 //     callee(null)         // set the known constant value
28 //   else if (c)
29 //     callee(nonnull ptr)  // set non-null attribute in the argument
30 //
31 // 2) We can also split a call-site based on constant incoming values of a PHI
32 // For example,
33 // from :
34 //   Header:
35 //    %c = icmp eq i32 %i1, %i2
36 //    br i1 %c, label %Tail, label %TBB
37 //   TBB:
38 //    br label Tail%
39 //   Tail:
40 //    %p = phi i32 [ 0, %Header], [ 1, %TBB]
41 //    call void @bar(i32 %p)
42 // to
43 //   Header:
44 //    %c = icmp eq i32 %i1, %i2
45 //    br i1 %c, label %Tail-split0, label %TBB
46 //   TBB:
47 //    br label %Tail-split1
48 //   Tail-split0:
49 //    call void @bar(i32 0)
50 //    br label %Tail
51 //   Tail-split1:
52 //    call void @bar(i32 1)
53 //    br label %Tail
54 //   Tail:
55 //    %p = phi i32 [ 0, %Tail-split0 ], [ 1, %Tail-split1 ]
56 //
57 //===----------------------------------------------------------------------===//
58 
59 #include "llvm/Transforms/Scalar/CallSiteSplitting.h"
60 #include "llvm/ADT/Statistic.h"
61 #include "llvm/Analysis/TargetLibraryInfo.h"
62 #include "llvm/Analysis/TargetTransformInfo.h"
63 #include "llvm/Transforms/Utils/Local.h"
64 #include "llvm/IR/IntrinsicInst.h"
65 #include "llvm/IR/PatternMatch.h"
66 #include "llvm/Support/Debug.h"
67 #include "llvm/Transforms/Scalar.h"
68 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
69 #include "llvm/Transforms/Utils/Cloning.h"
70 
71 using namespace llvm;
72 using namespace PatternMatch;
73 
74 #define DEBUG_TYPE "callsite-splitting"
75 
76 STATISTIC(NumCallSiteSplit, "Number of call-site split");
77 
78 /// Only allow instructions before a call, if their CodeSize cost is below
79 /// DuplicationThreshold. Those instructions need to be duplicated in all
80 /// split blocks.
81 static cl::opt<unsigned>
82     DuplicationThreshold("callsite-splitting-duplication-threshold", cl::Hidden,
83                          cl::desc("Only allow instructions before a call, if "
84                                   "their cost is below DuplicationThreshold"),
85                          cl::init(5));
86 
addNonNullAttribute(CallSite CS,Value * Op)87 static void addNonNullAttribute(CallSite CS, Value *Op) {
88   unsigned ArgNo = 0;
89   for (auto &I : CS.args()) {
90     if (&*I == Op)
91       CS.addParamAttr(ArgNo, Attribute::NonNull);
92     ++ArgNo;
93   }
94 }
95 
setConstantInArgument(CallSite CS,Value * Op,Constant * ConstValue)96 static void setConstantInArgument(CallSite CS, Value *Op,
97                                   Constant *ConstValue) {
98   unsigned ArgNo = 0;
99   for (auto &I : CS.args()) {
100     if (&*I == Op) {
101       // It is possible we have already added the non-null attribute to the
102       // parameter by using an earlier constraining condition.
103       CS.removeParamAttr(ArgNo, Attribute::NonNull);
104       CS.setArgument(ArgNo, ConstValue);
105     }
106     ++ArgNo;
107   }
108 }
109 
isCondRelevantToAnyCallArgument(ICmpInst * Cmp,CallSite CS)110 static bool isCondRelevantToAnyCallArgument(ICmpInst *Cmp, CallSite CS) {
111   assert(isa<Constant>(Cmp->getOperand(1)) && "Expected a constant operand.");
112   Value *Op0 = Cmp->getOperand(0);
113   unsigned ArgNo = 0;
114   for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E;
115        ++I, ++ArgNo) {
116     // Don't consider constant or arguments that are already known non-null.
117     if (isa<Constant>(*I) || CS.paramHasAttr(ArgNo, Attribute::NonNull))
118       continue;
119 
120     if (*I == Op0)
121       return true;
122   }
123   return false;
124 }
125 
126 typedef std::pair<ICmpInst *, unsigned> ConditionTy;
127 typedef SmallVector<ConditionTy, 2> ConditionsTy;
128 
129 /// If From has a conditional jump to To, add the condition to Conditions,
130 /// if it is relevant to any argument at CS.
recordCondition(CallSite CS,BasicBlock * From,BasicBlock * To,ConditionsTy & Conditions)131 static void recordCondition(CallSite CS, BasicBlock *From, BasicBlock *To,
132                             ConditionsTy &Conditions) {
133   auto *BI = dyn_cast<BranchInst>(From->getTerminator());
134   if (!BI || !BI->isConditional())
135     return;
136 
137   CmpInst::Predicate Pred;
138   Value *Cond = BI->getCondition();
139   if (!match(Cond, m_ICmp(Pred, m_Value(), m_Constant())))
140     return;
141 
142   ICmpInst *Cmp = cast<ICmpInst>(Cond);
143   if (Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE)
144     if (isCondRelevantToAnyCallArgument(Cmp, CS))
145       Conditions.push_back({Cmp, From->getTerminator()->getSuccessor(0) == To
146                                      ? Pred
147                                      : Cmp->getInversePredicate()});
148 }
149 
150 /// Record ICmp conditions relevant to any argument in CS following Pred's
151 /// single predecessors. If there are conflicting conditions along a path, like
152 /// x == 1 and x == 0, the first condition will be used.
recordConditions(CallSite CS,BasicBlock * Pred,ConditionsTy & Conditions)153 static void recordConditions(CallSite CS, BasicBlock *Pred,
154                              ConditionsTy &Conditions) {
155   recordCondition(CS, Pred, CS.getInstruction()->getParent(), Conditions);
156   BasicBlock *From = Pred;
157   BasicBlock *To = Pred;
158   SmallPtrSet<BasicBlock *, 4> Visited;
159   while (!Visited.count(From->getSinglePredecessor()) &&
160          (From = From->getSinglePredecessor())) {
161     recordCondition(CS, From, To, Conditions);
162     Visited.insert(From);
163     To = From;
164   }
165 }
166 
addConditions(CallSite CS,const ConditionsTy & Conditions)167 static void addConditions(CallSite CS, const ConditionsTy &Conditions) {
168   for (auto &Cond : Conditions) {
169     Value *Arg = Cond.first->getOperand(0);
170     Constant *ConstVal = cast<Constant>(Cond.first->getOperand(1));
171     if (Cond.second == ICmpInst::ICMP_EQ)
172       setConstantInArgument(CS, Arg, ConstVal);
173     else if (ConstVal->getType()->isPointerTy() && ConstVal->isNullValue()) {
174       assert(Cond.second == ICmpInst::ICMP_NE);
175       addNonNullAttribute(CS, Arg);
176     }
177   }
178 }
179 
getTwoPredecessors(BasicBlock * BB)180 static SmallVector<BasicBlock *, 2> getTwoPredecessors(BasicBlock *BB) {
181   SmallVector<BasicBlock *, 2> Preds(predecessors((BB)));
182   assert(Preds.size() == 2 && "Expected exactly 2 predecessors!");
183   return Preds;
184 }
185 
canSplitCallSite(CallSite CS,TargetTransformInfo & TTI)186 static bool canSplitCallSite(CallSite CS, TargetTransformInfo &TTI) {
187   // FIXME: As of now we handle only CallInst. InvokeInst could be handled
188   // without too much effort.
189   Instruction *Instr = CS.getInstruction();
190   if (!isa<CallInst>(Instr))
191     return false;
192 
193   BasicBlock *CallSiteBB = Instr->getParent();
194   // Need 2 predecessors and cannot split an edge from an IndirectBrInst.
195   SmallVector<BasicBlock *, 2> Preds(predecessors(CallSiteBB));
196   if (Preds.size() != 2 || isa<IndirectBrInst>(Preds[0]->getTerminator()) ||
197       isa<IndirectBrInst>(Preds[1]->getTerminator()))
198     return false;
199 
200   // BasicBlock::canSplitPredecessors is more agressive, so checking for
201   // BasicBlock::isEHPad as well.
202   if (!CallSiteBB->canSplitPredecessors() || CallSiteBB->isEHPad())
203     return false;
204 
205   // Allow splitting a call-site only when the CodeSize cost of the
206   // instructions before the call is less then DuplicationThreshold. The
207   // instructions before the call will be duplicated in the split blocks and
208   // corresponding uses will be updated.
209   unsigned Cost = 0;
210   for (auto &InstBeforeCall :
211        llvm::make_range(CallSiteBB->begin(), Instr->getIterator())) {
212     Cost += TTI.getInstructionCost(&InstBeforeCall,
213                                    TargetTransformInfo::TCK_CodeSize);
214     if (Cost >= DuplicationThreshold)
215       return false;
216   }
217 
218   return true;
219 }
220 
cloneInstForMustTail(Instruction * I,Instruction * Before,Value * V)221 static Instruction *cloneInstForMustTail(Instruction *I, Instruction *Before,
222                                          Value *V) {
223   Instruction *Copy = I->clone();
224   Copy->setName(I->getName());
225   Copy->insertBefore(Before);
226   if (V)
227     Copy->setOperand(0, V);
228   return Copy;
229 }
230 
231 /// Copy mandatory `musttail` return sequence that follows original `CI`, and
232 /// link it up to `NewCI` value instead:
233 ///
234 ///   * (optional) `bitcast NewCI to ...`
235 ///   * `ret bitcast or NewCI`
236 ///
237 /// Insert this sequence right before `SplitBB`'s terminator, which will be
238 /// cleaned up later in `splitCallSite` below.
copyMustTailReturn(BasicBlock * SplitBB,Instruction * CI,Instruction * NewCI)239 static void copyMustTailReturn(BasicBlock *SplitBB, Instruction *CI,
240                                Instruction *NewCI) {
241   bool IsVoid = SplitBB->getParent()->getReturnType()->isVoidTy();
242   auto II = std::next(CI->getIterator());
243 
244   BitCastInst* BCI = dyn_cast<BitCastInst>(&*II);
245   if (BCI)
246     ++II;
247 
248   ReturnInst* RI = dyn_cast<ReturnInst>(&*II);
249   assert(RI && "`musttail` call must be followed by `ret` instruction");
250 
251   TerminatorInst *TI = SplitBB->getTerminator();
252   Value *V = NewCI;
253   if (BCI)
254     V = cloneInstForMustTail(BCI, TI, V);
255   cloneInstForMustTail(RI, TI, IsVoid ? nullptr : V);
256 
257   // FIXME: remove TI here, `DuplicateInstructionsInSplitBetween` has a bug
258   // that prevents doing this now.
259 }
260 
261 /// For each (predecessor, conditions from predecessors) pair, it will split the
262 /// basic block containing the call site, hook it up to the predecessor and
263 /// replace the call instruction with new call instructions, which contain
264 /// constraints based on the conditions from their predecessors.
265 /// For example, in the IR below with an OR condition, the call-site can
266 /// be split. In this case, Preds for Tail is [(Header, a == null),
267 /// (TBB, a != null, b == null)]. Tail is replaced by 2 split blocks, containing
268 /// CallInst1, which has constraints based on the conditions from Head and
269 /// CallInst2, which has constraints based on the conditions coming from TBB.
270 ///
271 /// From :
272 ///
273 ///   Header:
274 ///     %c = icmp eq i32* %a, null
275 ///     br i1 %c %Tail, %TBB
276 ///   TBB:
277 ///     %c2 = icmp eq i32* %b, null
278 ///     br i1 %c %Tail, %End
279 ///   Tail:
280 ///     %ca = call i1  @callee (i32* %a, i32* %b)
281 ///
282 ///  to :
283 ///
284 ///   Header:                          // PredBB1 is Header
285 ///     %c = icmp eq i32* %a, null
286 ///     br i1 %c %Tail-split1, %TBB
287 ///   TBB:                             // PredBB2 is TBB
288 ///     %c2 = icmp eq i32* %b, null
289 ///     br i1 %c %Tail-split2, %End
290 ///   Tail-split1:
291 ///     %ca1 = call @callee (i32* null, i32* %b)         // CallInst1
292 ///    br %Tail
293 ///   Tail-split2:
294 ///     %ca2 = call @callee (i32* nonnull %a, i32* null) // CallInst2
295 ///    br %Tail
296 ///   Tail:
297 ///    %p = phi i1 [%ca1, %Tail-split1],[%ca2, %Tail-split2]
298 ///
299 /// Note that in case any arguments at the call-site are constrained by its
300 /// predecessors, new call-sites with more constrained arguments will be
301 /// created in createCallSitesOnPredicatedArgument().
splitCallSite(CallSite CS,const SmallVectorImpl<std::pair<BasicBlock *,ConditionsTy>> & Preds,DominatorTree * DT)302 static void splitCallSite(
303     CallSite CS,
304     const SmallVectorImpl<std::pair<BasicBlock *, ConditionsTy>> &Preds,
305     DominatorTree *DT) {
306   Instruction *Instr = CS.getInstruction();
307   BasicBlock *TailBB = Instr->getParent();
308   bool IsMustTailCall = CS.isMustTailCall();
309 
310   PHINode *CallPN = nullptr;
311 
312   // `musttail` calls must be followed by optional `bitcast`, and `ret`. The
313   // split blocks will be terminated right after that so there're no users for
314   // this phi in a `TailBB`.
315   if (!IsMustTailCall && !Instr->use_empty())
316     CallPN = PHINode::Create(Instr->getType(), Preds.size(), "phi.call");
317 
318   LLVM_DEBUG(dbgs() << "split call-site : " << *Instr << " into \n");
319 
320   assert(Preds.size() == 2 && "The ValueToValueMaps array has size 2.");
321   // ValueToValueMapTy is neither copy nor moveable, so we use a simple array
322   // here.
323   ValueToValueMapTy ValueToValueMaps[2];
324   for (unsigned i = 0; i < Preds.size(); i++) {
325     BasicBlock *PredBB = Preds[i].first;
326     BasicBlock *SplitBlock = DuplicateInstructionsInSplitBetween(
327         TailBB, PredBB, &*std::next(Instr->getIterator()), ValueToValueMaps[i],
328         DT);
329     assert(SplitBlock && "Unexpected new basic block split.");
330 
331     Instruction *NewCI =
332         &*std::prev(SplitBlock->getTerminator()->getIterator());
333     CallSite NewCS(NewCI);
334     addConditions(NewCS, Preds[i].second);
335 
336     // Handle PHIs used as arguments in the call-site.
337     for (PHINode &PN : TailBB->phis()) {
338       unsigned ArgNo = 0;
339       for (auto &CI : CS.args()) {
340         if (&*CI == &PN) {
341           NewCS.setArgument(ArgNo, PN.getIncomingValueForBlock(SplitBlock));
342         }
343         ++ArgNo;
344       }
345     }
346     LLVM_DEBUG(dbgs() << "    " << *NewCI << " in " << SplitBlock->getName()
347                       << "\n");
348     if (CallPN)
349       CallPN->addIncoming(NewCI, SplitBlock);
350 
351     // Clone and place bitcast and return instructions before `TI`
352     if (IsMustTailCall)
353       copyMustTailReturn(SplitBlock, Instr, NewCI);
354   }
355 
356   NumCallSiteSplit++;
357 
358   // FIXME: remove TI in `copyMustTailReturn`
359   if (IsMustTailCall) {
360     // Remove superfluous `br` terminators from the end of the Split blocks
361     // NOTE: Removing terminator removes the SplitBlock from the TailBB's
362     // predecessors. Therefore we must get complete list of Splits before
363     // attempting removal.
364     SmallVector<BasicBlock *, 2> Splits(predecessors((TailBB)));
365     assert(Splits.size() == 2 && "Expected exactly 2 splits!");
366     for (unsigned i = 0; i < Splits.size(); i++)
367       Splits[i]->getTerminator()->eraseFromParent();
368 
369     // Erase the tail block once done with musttail patching
370     TailBB->eraseFromParent();
371     return;
372   }
373 
374   auto *OriginalBegin = &*TailBB->begin();
375   // Replace users of the original call with a PHI mering call-sites split.
376   if (CallPN) {
377     CallPN->insertBefore(OriginalBegin);
378     Instr->replaceAllUsesWith(CallPN);
379   }
380 
381   // Remove instructions moved to split blocks from TailBB, from the duplicated
382   // call instruction to the beginning of the basic block. If an instruction
383   // has any uses, add a new PHI node to combine the values coming from the
384   // split blocks. The new PHI nodes are placed before the first original
385   // instruction, so we do not end up deleting them. By using reverse-order, we
386   // do not introduce unnecessary PHI nodes for def-use chains from the call
387   // instruction to the beginning of the block.
388   auto I = Instr->getReverseIterator();
389   while (I != TailBB->rend()) {
390     Instruction *CurrentI = &*I++;
391     if (!CurrentI->use_empty()) {
392       // If an existing PHI has users after the call, there is no need to create
393       // a new one.
394       if (isa<PHINode>(CurrentI))
395         continue;
396       PHINode *NewPN = PHINode::Create(CurrentI->getType(), Preds.size());
397       for (auto &Mapping : ValueToValueMaps)
398         NewPN->addIncoming(Mapping[CurrentI],
399                            cast<Instruction>(Mapping[CurrentI])->getParent());
400       NewPN->insertBefore(&*TailBB->begin());
401       CurrentI->replaceAllUsesWith(NewPN);
402     }
403     CurrentI->eraseFromParent();
404     // We are done once we handled the first original instruction in TailBB.
405     if (CurrentI == OriginalBegin)
406       break;
407   }
408 }
409 
410 // Return true if the call-site has an argument which is a PHI with only
411 // constant incoming values.
isPredicatedOnPHI(CallSite CS)412 static bool isPredicatedOnPHI(CallSite CS) {
413   Instruction *Instr = CS.getInstruction();
414   BasicBlock *Parent = Instr->getParent();
415   if (Instr != Parent->getFirstNonPHIOrDbg())
416     return false;
417 
418   for (auto &BI : *Parent) {
419     if (PHINode *PN = dyn_cast<PHINode>(&BI)) {
420       for (auto &I : CS.args())
421         if (&*I == PN) {
422           assert(PN->getNumIncomingValues() == 2 &&
423                  "Unexpected number of incoming values");
424           if (PN->getIncomingBlock(0) == PN->getIncomingBlock(1))
425             return false;
426           if (PN->getIncomingValue(0) == PN->getIncomingValue(1))
427             continue;
428           if (isa<Constant>(PN->getIncomingValue(0)) &&
429               isa<Constant>(PN->getIncomingValue(1)))
430             return true;
431         }
432     }
433     break;
434   }
435   return false;
436 }
437 
tryToSplitOnPHIPredicatedArgument(CallSite CS,DominatorTree * DT)438 static bool tryToSplitOnPHIPredicatedArgument(CallSite CS, DominatorTree *DT) {
439   if (!isPredicatedOnPHI(CS))
440     return false;
441 
442   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
443   SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS = {
444       {Preds[0], {}}, {Preds[1], {}}};
445   splitCallSite(CS, PredsCS, DT);
446   return true;
447 }
448 
tryToSplitOnPredicatedArgument(CallSite CS,DominatorTree * DT)449 static bool tryToSplitOnPredicatedArgument(CallSite CS, DominatorTree *DT) {
450   auto Preds = getTwoPredecessors(CS.getInstruction()->getParent());
451   if (Preds[0] == Preds[1])
452     return false;
453 
454   SmallVector<std::pair<BasicBlock *, ConditionsTy>, 2> PredsCS;
455   for (auto *Pred : make_range(Preds.rbegin(), Preds.rend())) {
456     ConditionsTy Conditions;
457     recordConditions(CS, Pred, Conditions);
458     PredsCS.push_back({Pred, Conditions});
459   }
460 
461   if (std::all_of(PredsCS.begin(), PredsCS.end(),
462                   [](const std::pair<BasicBlock *, ConditionsTy> &P) {
463                     return P.second.empty();
464                   }))
465     return false;
466 
467   splitCallSite(CS, PredsCS, DT);
468   return true;
469 }
470 
tryToSplitCallSite(CallSite CS,TargetTransformInfo & TTI,DominatorTree * DT)471 static bool tryToSplitCallSite(CallSite CS, TargetTransformInfo &TTI,
472                                DominatorTree *DT) {
473   if (!CS.arg_size() || !canSplitCallSite(CS, TTI))
474     return false;
475   return tryToSplitOnPredicatedArgument(CS, DT) ||
476          tryToSplitOnPHIPredicatedArgument(CS, DT);
477 }
478 
doCallSiteSplitting(Function & F,TargetLibraryInfo & TLI,TargetTransformInfo & TTI,DominatorTree * DT)479 static bool doCallSiteSplitting(Function &F, TargetLibraryInfo &TLI,
480                                 TargetTransformInfo &TTI, DominatorTree *DT) {
481   bool Changed = false;
482   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;) {
483     BasicBlock &BB = *BI++;
484     auto II = BB.getFirstNonPHIOrDbg()->getIterator();
485     auto IE = BB.getTerminator()->getIterator();
486     // Iterate until we reach the terminator instruction. tryToSplitCallSite
487     // can replace BB's terminator in case BB is a successor of itself. In that
488     // case, IE will be invalidated and we also have to check the current
489     // terminator.
490     while (II != IE && &*II != BB.getTerminator()) {
491       Instruction *I = &*II++;
492       CallSite CS(cast<Value>(I));
493       if (!CS || isa<IntrinsicInst>(I) || isInstructionTriviallyDead(I, &TLI))
494         continue;
495 
496       Function *Callee = CS.getCalledFunction();
497       if (!Callee || Callee->isDeclaration())
498         continue;
499 
500       // Successful musttail call-site splits result in erased CI and erased BB.
501       // Check if such path is possible before attempting the splitting.
502       bool IsMustTail = CS.isMustTailCall();
503 
504       Changed |= tryToSplitCallSite(CS, TTI, DT);
505 
506       // There're no interesting instructions after this. The call site
507       // itself might have been erased on splitting.
508       if (IsMustTail)
509         break;
510     }
511   }
512   return Changed;
513 }
514 
515 namespace {
516 struct CallSiteSplittingLegacyPass : public FunctionPass {
517   static char ID;
CallSiteSplittingLegacyPass__anon015696bc0211::CallSiteSplittingLegacyPass518   CallSiteSplittingLegacyPass() : FunctionPass(ID) {
519     initializeCallSiteSplittingLegacyPassPass(*PassRegistry::getPassRegistry());
520   }
521 
getAnalysisUsage__anon015696bc0211::CallSiteSplittingLegacyPass522   void getAnalysisUsage(AnalysisUsage &AU) const override {
523     AU.addRequired<TargetLibraryInfoWrapperPass>();
524     AU.addRequired<TargetTransformInfoWrapperPass>();
525     AU.addPreserved<DominatorTreeWrapperPass>();
526     FunctionPass::getAnalysisUsage(AU);
527   }
528 
runOnFunction__anon015696bc0211::CallSiteSplittingLegacyPass529   bool runOnFunction(Function &F) override {
530     if (skipFunction(F))
531       return false;
532 
533     auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
534     auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
535     auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>();
536     return doCallSiteSplitting(F, TLI, TTI,
537                                DTWP ? &DTWP->getDomTree() : nullptr);
538   }
539 };
540 } // namespace
541 
542 char CallSiteSplittingLegacyPass::ID = 0;
543 INITIALIZE_PASS_BEGIN(CallSiteSplittingLegacyPass, "callsite-splitting",
544                       "Call-site splitting", false, false)
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)545 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
546 INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
547 INITIALIZE_PASS_END(CallSiteSplittingLegacyPass, "callsite-splitting",
548                     "Call-site splitting", false, false)
549 FunctionPass *llvm::createCallSiteSplittingPass() {
550   return new CallSiteSplittingLegacyPass();
551 }
552 
run(Function & F,FunctionAnalysisManager & AM)553 PreservedAnalyses CallSiteSplittingPass::run(Function &F,
554                                              FunctionAnalysisManager &AM) {
555   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
556   auto &TTI = AM.getResult<TargetIRAnalysis>(F);
557   auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
558 
559   if (!doCallSiteSplitting(F, TLI, TTI, DT))
560     return PreservedAnalyses::all();
561   PreservedAnalyses PA;
562   PA.preserve<DominatorTreeAnalysis>();
563   return PA;
564 }
565