MDNode *Loop::getLoopID() const { MDNode *LoopID = nullptr; if (isLoopSimplifyForm()) { LoopID = getLoopLatch()->getTerminator()->getMetadata(LLVMContext::MD_loop); } else { // Go through each predecessor of the loop header and check the // terminator for the metadata. BasicBlock *H = getHeader(); for (BasicBlock *BB : this->blocks()) { TerminatorInst *TI = BB->getTerminator(); MDNode *MD = nullptr; // Check if this terminator branches to the loop header. for (BasicBlock *Successor : TI->successors()) { if (Successor == H) { MD = TI->getMetadata(LLVMContext::MD_loop); break; } } if (!MD) return nullptr; if (!LoopID) LoopID = MD; else if (MD != LoopID) return nullptr; } } if (!LoopID || LoopID->getNumOperands() == 0 || LoopID->getOperand(0) != LoopID) return nullptr; return LoopID; }
void MemorySSAUpdater::removeBlocks( const SmallPtrSetImpl<BasicBlock *> &DeadBlocks) { // First delete all uses of BB in MemoryPhis. for (BasicBlock *BB : DeadBlocks) { TerminatorInst *TI = BB->getTerminator(); assert(TI && "Basic block expected to have a terminator instruction"); for (BasicBlock *Succ : TI->successors()) if (!DeadBlocks.count(Succ)) if (MemoryPhi *MP = MSSA->getMemoryAccess(Succ)) { MP->unorderedDeleteIncomingBlock(BB); if (MP->getNumIncomingValues() == 1) removeMemoryAccess(MP); } // Drop all references of all accesses in BB if (MemorySSA::AccessList *Acc = MSSA->getWritableBlockAccesses(BB)) for (MemoryAccess &MA : *Acc) MA.dropAllReferences(); } // Next, delete all memory accesses in each block for (BasicBlock *BB : DeadBlocks) { MemorySSA::AccessList *Acc = MSSA->getWritableBlockAccesses(BB); if (!Acc) continue; for (auto AB = Acc->begin(), AE = Acc->end(); AB != AE;) { MemoryAccess *MA = &*AB; ++AB; MSSA->removeFromLookups(MA); MSSA->removeFromLists(MA); } } }
void Loop::setLoopID(MDNode *LoopID) const { assert(LoopID && "Loop ID should not be null"); assert(LoopID->getNumOperands() > 0 && "Loop ID needs at least one operand"); assert(LoopID->getOperand(0) == LoopID && "Loop ID should refer to itself"); if (isLoopSimplifyForm()) { getLoopLatch()->getTerminator()->setMetadata(LLVMContext::MD_loop, LoopID); return; } BasicBlock *H = getHeader(); for (BasicBlock *BB : this->blocks()) { TerminatorInst *TI = BB->getTerminator(); for (BasicBlock *Successor : TI->successors()) { if (Successor == H) TI->setMetadata(LLVMContext::MD_loop, LoopID); } } }
void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *New) { TerminatorInst *TI = getTerminator(); if (!TI) // Cope with being called on a BasicBlock that doesn't have a terminator // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this. return; for (BasicBlock *Succ : TI->successors()) { // N.B. Succ might not be a complete BasicBlock, so don't assume // that it ends with a non-phi instruction. for (iterator II = Succ->begin(), IE = Succ->end(); II != IE; ++II) { PHINode *PN = dyn_cast<PHINode>(II); if (!PN) break; int i; while ((i = PN->getBasicBlockIndex(this)) >= 0) PN->setIncomingBlock(i, New); } } }
void llvm::DeleteDeadBlock(BasicBlock *BB, DeferredDominance *DDT) { assert((pred_begin(BB) == pred_end(BB) || // Can delete self loop. BB->getSinglePredecessor() == BB) && "Block is not dead!"); TerminatorInst *BBTerm = BB->getTerminator(); std::vector<DominatorTree::UpdateType> Updates; // Loop through all of our successors and make sure they know that one // of their predecessors is going away. if (DDT) Updates.reserve(BBTerm->getNumSuccessors()); for (BasicBlock *Succ : BBTerm->successors()) { Succ->removePredecessor(BB); if (DDT) Updates.push_back({DominatorTree::Delete, BB, Succ}); } // Zap all the instructions in the block. while (!BB->empty()) { Instruction &I = BB->back(); // If this instruction is used, replace uses with an arbitrary value. // Because control flow can't get here, we don't care what we replace the // value with. Note that since this block is unreachable, and all values // contained within it must dominate their uses, that all uses will // eventually be removed (they are themselves dead). if (!I.use_empty()) I.replaceAllUsesWith(UndefValue::get(I.getType())); BB->getInstList().pop_back(); } if (DDT) { DDT->applyUpdates(Updates); DDT->deleteBB(BB); // Deferred deletion of BB. } else { BB->eraseFromParent(); // Zap the block! } }