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