Transforms/Scalar/JumpThreading.cpp

70   typedef SmallVectorImpl<std::pair<Constant*, BasicBlock*> > PredValueInfo;
71   typedef SmallVector<std::pair<Constant*, BasicBlock*>, 8> PredValueInfoTy;
103     SmallPtrSet<const BasicBlock *, 16> LoopHeaders;
105     SmallSet<AssertingVH<const BasicBlock>, 16> LoopHeaders;
107     DenseSet<std::pair<Value*, BasicBlock*> > RecursionSet;
113       DenseSet<std::pair<Value*, BasicBlock*> > &TheSet;
114       std::pair<Value*, BasicBlock*> ThePair;
116       RecursionSetRemover(DenseSet<std::pair<Value*, BasicBlock*> > &S,
117                           std::pair<Value*, BasicBlock*> P)
146     bool ProcessBlock(BasicBlock *BB);
147     bool ThreadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock*> &PredBBs,
148                     BasicBlock *SuccBB);
149     bool DuplicateCondBranchOnPHIIntoPred(BasicBlock *BB,
150                                   const SmallVectorImpl<BasicBlock *> &PredBBs);
152     bool ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB,
156     bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
162     bool ProcessImpliedCondition(BasicBlock *BB);
165     bool TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB);
166     bool TryToUnfoldSelectInCurrBB(BasicBlock *BB);
169     BasicBlock *SplitBlockPreds(BasicBlock *BB, ArrayRef<BasicBlock *> Preds,
171     void UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB,
172                                       BasicBlock *NewBB, BasicBlock *SuccBB);
223       BasicBlock *BB = &*I;
256         BasicBlock *Succ = BI->getSuccessor(0);
283 static unsigned getJumpThreadDuplicationCost(const BasicBlock *BB,
286   BasicBlock::const_iterator I(BB->getFirstNonPHI());
365   SmallVector<std::pair<const BasicBlock*,const BasicBlock*>, 32> Edges;
399 ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, PredValueInfo &Result,
415     for (BasicBlock *Pred : predecessors(BB))
439     for (BasicBlock *P : predecessors(BB)) {
491       SmallPtrSet<BasicBlock*, 4> LHSKnownBBs;
558         BasicBlock *PredBB = PN->getIncomingBlock(i);
590         for (BasicBlock *P : predecessors(BB)) {
663     for (BasicBlock *Pred : predecessors(BB))
678 static unsigned GetBestDestForJumpOnUndef(BasicBlock *BB) {
681   BasicBlock *TestBB = BBTerm->getSuccessor(MinSucc);
696 static bool hasAddressTakenAndUsed(BasicBlock *BB) {
708 bool JumpThreading::ProcessBlock(BasicBlock *BB) {
719   if (BasicBlock *SinglePred = BB->getSinglePredecessor()) {
892 bool JumpThreading::ProcessImpliedCondition(BasicBlock *BB) {
898   BasicBlock *CurrentBB = BB;
899   BasicBlock *CurrentPred = BB->getSinglePredecessor();
932   BasicBlock *LoadBB = LI->getParent();
952   BasicBlock::iterator BBIt(LI);
982   SmallPtrSet<BasicBlock*, 8> PredsScanned;
983   typedef SmallVector<std::pair<BasicBlock*, Value*>, 8> AvailablePredsTy;
985   BasicBlock *OneUnavailablePred = nullptr;
989   for (BasicBlock *PredBB : predecessors(LoadBB)) {
1022   BasicBlock *UnavailablePred = nullptr;
1033     SmallVector<BasicBlock*, 8> PredsToSplit;
1034     SmallPtrSet<BasicBlock*, 8> AvailablePredSet;
1040     for (BasicBlock *P : predecessors(LoadBB)) {
1083     BasicBlock *P = *PI;
1114 static BasicBlock *
1115 FindMostPopularDest(BasicBlock *BB,
1116                     const SmallVectorImpl<std::pair<BasicBlock*,
1117                                   BasicBlock*> > &PredToDestList) {
1124   DenseMap<BasicBlock*, unsigned> DestPopularity;
1130   DenseMap<BasicBlock*, unsigned>::iterator DPI = DestPopularity.begin();
1131   BasicBlock *MostPopularDest = DPI->first;
1133   SmallVector<BasicBlock*, 4> SamePopularity;
1174 bool JumpThreading::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
1200   SmallPtrSet<BasicBlock*, 16> SeenPreds;
1201   SmallVector<std::pair<BasicBlock*, BasicBlock*>, 16> PredToDestList;
1203   BasicBlock *OnlyDest = nullptr;
1204   BasicBlock *MultipleDestSentinel = (BasicBlock*)(intptr_t)~0ULL;
1207     BasicBlock *Pred = PredValue.second;
1218     BasicBlock *DestBB;
1248   BasicBlock *MostPopularDest = OnlyDest;
1255   SmallVector<BasicBlock*, 16> PredsToFactor;
1258       BasicBlock *Pred = PredToDest.first;
1263       for (BasicBlock *Succ : successors(Pred))
1283   BasicBlock *BB = PN->getParent();
1287   SmallVector<BasicBlock*, 1> PredBBs;
1295     BasicBlock *PredBB = PN->getIncomingBlock(i);
1313   BasicBlock *BB = BO->getParent();
1380   SmallVector<BasicBlock*, 8> BlocksToFoldInto;
1416 static void AddPHINodeEntriesForMappedBlock(BasicBlock *PHIBB,
1417                                             BasicBlock *OldPred,
1418                                             BasicBlock *NewPred,
1420   for (BasicBlock::iterator PNI = PHIBB->begin();
1440 bool JumpThreading::ThreadEdge(BasicBlock *BB,
1441                                const SmallVectorImpl<BasicBlock*> &PredBBs,
1442                                BasicBlock *SuccBB) {
1467   BasicBlock *PredBB;
1489   BasicBlock *NewBB = BasicBlock::Create(BB->getContext(),
1501   BasicBlock::iterator BI = BB->begin();
1596 BasicBlock *JumpThreading::SplitBlockPreds(BasicBlock *BB,
1597                                            ArrayRef<BasicBlock *> Preds,
1606   BasicBlock *PredBB = SplitBlockPredecessors(BB, Preds, Suffix);
1618 void JumpThreading::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB,
1619                                                  BasicBlock *BB,
1620                                                  BasicBlock *NewBB,
1621                                                  BasicBlock *SuccBB) {
1638   for (BasicBlock *Succ : successors(BB)) {
1682 bool JumpThreading::DuplicateCondBranchOnPHIIntoPred(BasicBlock *BB,
1683                                  const SmallVectorImpl<BasicBlock *> &PredBBs) {
1704   BasicBlock *PredBB;
1732   BasicBlock::iterator BI = BB->begin();
1832 bool JumpThreading::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) {
1842     BasicBlock *Pred = CondLHS->getIncomingBlock(I);
1875       BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "select.unfold",
1888       for (BasicBlock::iterator BI = BB->begin();
1910 bool JumpThreading::TryToUnfoldSelectInCurrBB(BasicBlock *BB) {
1919   for (BasicBlock::iterator BI = BB->begin();