Searched defs:PredBB (Results 1 - 16 of 16) sorted by relevance

/external/llvm/lib/Transforms/ObjCARC/
H A DDependencyAnalysis.cpp231 BasicBlock *PredBB = *PI; local
232 if (Visited.insert(PredBB))
233 Worklist.push_back(std::make_pair(PredBB, PredBB->end()));
/external/llvm/lib/Analysis/
H A DPHITransAddr.cpp146 BasicBlock *PredBB,
171 return AddAsInput(PN->getIncomingValueForBlock(PredBB));
191 Value *PHIIn = PHITranslateSubExpr(Cast->getOperand(0), CurBB, PredBB, DT);
209 (!DT || DT->dominates(CastI->getParent(), PredBB)))
220 Value *GEPOp = PHITranslateSubExpr(GEP->getOperand(i), CurBB, PredBB, DT);
245 (!DT || DT->dominates(GEPI->getParent(), PredBB))) {
267 Value *LHS = PHITranslateSubExpr(Inst->getOperand(0), CurBB, PredBB, DT);
303 (!DT || DT->dominates(BO->getParent(), PredBB)))
318 /// PredBB. This returns true on failure and sets Addr to null.
319 bool PHITransAddr::PHITranslateValue(BasicBlock *CurBB, BasicBlock *PredBB, argument
145 PHITranslateSubExpr(Value *V, BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree *DT) argument
343 PHITranslateWithInsertion(BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree &DT, SmallVectorImpl<Instruction*> &NewInsts) argument
367 InsertPHITranslatedSubExpr(Value *InVal, BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree &DT, SmallVectorImpl<Instruction*> &NewInsts) argument
[all...]
H A DLazyValueInfo.cpp397 /// edge from PredBB to OldSucc has been threaded to be from PredBB to
399 void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc);
942 void LazyValueInfoCache::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, argument
1138 void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, argument
1140 if (PImpl) getCache(PImpl).threadEdge(PredBB, OldSucc, NewSucc);
/external/llvm/lib/Target/XCore/
H A DXCoreLowerThreadLocal.cpp138 BasicBlock *PredBB = PN->getIncomingBlock(I); local
139 if (PredBB->getTerminator()->getNumSuccessors() > 1)
140 PredBB = SplitEdge(PredBB, PN->getParent(), P);
141 Instruction *InsertPos = PredBB->getTerminator();
/external/llvm/include/llvm/Analysis/
H A DLoopInfoImpl.h357 BlockT *PredBB = ReverseCFGWorklist.back(); local
360 LoopT *Subloop = LI->getLoopFor(PredBB);
362 if (!DomTree.isReachableFromEntry(PredBB))
366 LI->changeLoopFor(PredBB, L);
368 if (PredBB == L->getHeader())
372 InvBlockTraits::child_begin(PredBB),
373 InvBlockTraits::child_end(PredBB));
388 PredBB = Subloop->getHeader();
394 InvBlockTraits::child_begin(PredBB),
395 PE = InvBlockTraits::child_end(PredBB); P
[all...]
/external/llvm/lib/CodeGen/
H A DMachineSSAUpdater.cpp165 MachineBasicBlock *PredBB = *PI; local
166 unsigned PredVal = GetValueAtEndOfBlockInternal(PredBB);
167 PredValues.push_back(std::make_pair(PredBB, PredVal));
H A DTailDuplication.cpp91 MachineBasicBlock *PredBB,
98 MachineBasicBlock *PredBB,
172 MachineBasicBlock *PredBB = *PI; local
176 if (PHIBB == PredBB) {
184 << PredBB->getNumber() << '\n';
392 /// ProcessPHI - Process PHI node in TailBB by turning it into a copy in PredBB.
393 /// Remember the source register that's contributed by PredBB and update SSA
396 MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB,
401 unsigned SrcOpIdx = getPHISrcRegOpIdx(MI, PredBB);
412 AddSSAUpdateEntry(DefReg, NewDef, PredBB);
395 ProcessPHI( MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB, DenseMap<unsigned, unsigned> &LocalVRMap, SmallVectorImpl<std::pair<unsigned, unsigned> > &Copies, const DenseSet<unsigned> &RegsUsedByPhi, bool Remove) argument
426 DuplicateInstruction(MachineInstr *MI, MachineBasicBlock *TailBB, MachineBasicBlock *PredBB, MachineFunction &MF, DenseMap<unsigned, unsigned> &LocalVRMap, const DenseSet<unsigned> &UsedByPhi) argument
653 MachineBasicBlock *PredBB = *PI; local
681 MachineBasicBlock *PredBB = *PI; local
770 MachineBasicBlock *PredBB = *PI; local
936 MachineBasicBlock *PredBB = *PI; local
[all...]
H A DBranchFolding.cpp537 MachineBasicBlock *PredBB) {
547 if (MBB1 == PredBB || MBB2 == PredBB) {
549 unsigned NumTerms = CountTerminators(MBB1 == PredBB ? MBB2 : MBB1, I);
567 if (SuccBB && MBB1 != PredBB && MBB2 != PredBB &&
603 MachineBasicBlock *PredBB) {
616 SuccBB, PredBB)) {
638 MachineBasicBlock *PredBB) {
645 if (SuccBB && CurMBB != PredBB)
530 ProfitableToMerge(MachineBasicBlock *MBB1, MachineBasicBlock *MBB2, unsigned minCommonTailLength, unsigned &CommonTailLen, MachineBasicBlock::iterator &I1, MachineBasicBlock::iterator &I2, MachineBasicBlock *SuccBB, MachineBasicBlock *PredBB) argument
600 ComputeSameTails(unsigned CurHash, unsigned minCommonTailLength, MachineBasicBlock *SuccBB, MachineBasicBlock *PredBB) argument
636 RemoveBlocksWithHash(unsigned CurHash, MachineBasicBlock *SuccBB, MachineBasicBlock *PredBB) argument
657 CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB, MachineBasicBlock *SuccBB, unsigned maxCommonTailLength, unsigned &commonTailIndex) argument
717 TryTailMergeBlocks(MachineBasicBlock *SuccBB, MachineBasicBlock *PredBB) argument
879 MachineBasicBlock *PredBB = std::prev(I); local
1382 MachineBasicBlock *PredBB = *PI; local
[all...]
H A DMachineBasicBlock.cpp913 MachineBasicBlock *PredBB = *PI; local
914 if (PredBB == NMBB)
916 if (!MDT->dominates(SucccDTNode, MDT->getNode(PredBB))) {
/external/llvm/lib/IR/
H A DValue.cpp558 /// return the value in the PHI node corresponding to PredBB. If not, return
562 const BasicBlock *PredBB) {
565 return PN->getIncomingValueForBlock(PredBB);
561 DoPHITranslation(const BasicBlock *CurBB, const BasicBlock *PredBB) argument
/external/llvm/lib/Transforms/Utils/
H A DSSAUpdater.cpp101 BasicBlock *PredBB = SomePhi->getIncomingBlock(i); local
102 Value *PredVal = GetValueAtEndOfBlock(PredBB);
103 PredValues.push_back(std::make_pair(PredBB, PredVal));
114 BasicBlock *PredBB = *PI; local
115 Value *PredVal = GetValueAtEndOfBlock(PredBB);
116 PredValues.push_back(std::make_pair(PredBB, PredVal));
H A DLocal.cpp491 BasicBlock *PredBB = DestBB->getSinglePredecessor(); local
492 assert(PredBB && "Block doesn't have a single predecessor!");
505 // Anything that branched to PredBB now branches to DestBB.
506 PredBB->replaceAllUsesWith(DestBB);
508 // Splice all the instructions from PredBB to DestBB.
509 PredBB->getTerminator()->eraseFromParent();
510 DestBB->getInstList().splice(DestBB->begin(), PredBB->getInstList());
516 BasicBlock *PredBBIDom = DT.getNode(PredBB)->getIDom()->getBlock();
518 DT.eraseNode(PredBB);
522 PredBB
699 BasicBlock *PredBB = OldValPN->getIncomingBlock(i); local
712 BasicBlock *PredBB = BBPreds[i]; local
[all...]
H A DSimplifyCFG.cpp1632 // Okay, we now know that all edges from PredBB should be revectored to
1634 BasicBlock *PredBB = PN->getIncomingBlock(i); local
1639 if (isa<IndirectBrInst>(PredBB->getTerminator())) continue;
1660 TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB);
1687 // Loop over all of the edges from PredBB to BB, changing them to branch
1689 TerminatorInst *PredBBTI = PredBB->getTerminator();
1692 BB->removePredecessor(PredBB);
/external/llvm/lib/Transforms/Scalar/
H A DJumpThreading.cpp503 BasicBlock *PredBB = PN->getIncomingBlock(i); local
505 Value *RHS = Cmp->getOperand(1)->DoPHITranslation(BB, PredBB);
514 cast<Constant>(RHS), PredBB, BB);
521 Result.push_back(std::make_pair(KC, PredBB));
909 BasicBlock *PredBB = *PI; local
912 if (!PredsScanned.insert(PredBB))
916 BBIt = PredBB->end();
918 Value *PredAvailable = FindAvailableLoadedValue(LoadedPtr, PredBB, BBIt, 6,
921 OneUnavailablePred = PredBB;
930 AvailablePreds.push_back(std::make_pair(PredBB, PredAvailabl
1209 BasicBlock *PredBB = PN->getIncomingBlock(i); local
1382 BasicBlock *PredBB; local
1525 BasicBlock *PredBB; local
[all...]
/external/llvm/include/llvm/IR/
H A DIRBuilder.h109 BasicBlock *PredBB = Phi->getIncomingBlock(U); local
110 assert(U != PredBB->getTerminator() && "critical edge not split");
111 SetInsertPoint(PredBB, PredBB->getTerminator());
/external/llvm/lib/Transforms/InstCombine/
H A DInstructionCombining.cpp1860 BasicBlock *PredBB = FreeInstrBB->getSinglePredecessor(); local
1866 if (!PredBB)
1880 TerminatorInst *TI = PredBB->getTerminator();

Completed in 1647 milliseconds