1 //===- SSAUpdaterBulk.cpp - Unstructured SSA Update Tool ------------------===// 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 the SSAUpdaterBulk class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Transforms/Utils/SSAUpdaterBulk.h" 14 #include "llvm/Analysis/IteratedDominanceFrontier.h" 15 #include "llvm/IR/BasicBlock.h" 16 #include "llvm/IR/Dominators.h" 17 #include "llvm/IR/IRBuilder.h" 18 #include "llvm/IR/Instructions.h" 19 #include "llvm/IR/Use.h" 20 #include "llvm/IR/Value.h" 21 22 using namespace llvm; 23 24 #define DEBUG_TYPE "ssaupdaterbulk" 25 26 /// Helper function for finding a block which should have a value for the given 27 /// user. For PHI-nodes this block is the corresponding predecessor, for other 28 /// instructions it's their parent block. getUserBB(Use * U)29 static BasicBlock *getUserBB(Use *U) { 30 auto *User = cast<Instruction>(U->getUser()); 31 32 if (auto *UserPN = dyn_cast<PHINode>(User)) 33 return UserPN->getIncomingBlock(*U); 34 else 35 return User->getParent(); 36 } 37 38 /// Add a new variable to the SSA rewriter. This needs to be called before 39 /// AddAvailableValue or AddUse calls. AddVariable(StringRef Name,Type * Ty)40 unsigned SSAUpdaterBulk::AddVariable(StringRef Name, Type *Ty) { 41 unsigned Var = Rewrites.size(); 42 LLVM_DEBUG(dbgs() << "SSAUpdater: Var=" << Var << ": initialized with Ty = " 43 << *Ty << ", Name = " << Name << "\n"); 44 RewriteInfo RI(Name, Ty); 45 Rewrites.push_back(RI); 46 return Var; 47 } 48 49 /// Indicate that a rewritten value is available in the specified block with the 50 /// specified value. AddAvailableValue(unsigned Var,BasicBlock * BB,Value * V)51 void SSAUpdaterBulk::AddAvailableValue(unsigned Var, BasicBlock *BB, Value *V) { 52 assert(Var < Rewrites.size() && "Variable not found!"); 53 LLVM_DEBUG(dbgs() << "SSAUpdater: Var=" << Var 54 << ": added new available value " << *V << " in " 55 << BB->getName() << "\n"); 56 Rewrites[Var].Defines[BB] = V; 57 } 58 59 /// Record a use of the symbolic value. This use will be updated with a 60 /// rewritten value when RewriteAllUses is called. AddUse(unsigned Var,Use * U)61 void SSAUpdaterBulk::AddUse(unsigned Var, Use *U) { 62 assert(Var < Rewrites.size() && "Variable not found!"); 63 LLVM_DEBUG(dbgs() << "SSAUpdater: Var=" << Var << ": added a use" << *U->get() 64 << " in " << getUserBB(U)->getName() << "\n"); 65 Rewrites[Var].Uses.push_back(U); 66 } 67 68 // Compute value at the given block BB. We either should already know it, or we 69 // should be able to recursively reach it going up dominator tree. computeValueAt(BasicBlock * BB,RewriteInfo & R,DominatorTree * DT)70 Value *SSAUpdaterBulk::computeValueAt(BasicBlock *BB, RewriteInfo &R, 71 DominatorTree *DT) { 72 if (!R.Defines.count(BB)) { 73 if (DT->isReachableFromEntry(BB) && PredCache.get(BB).size()) { 74 BasicBlock *IDom = DT->getNode(BB)->getIDom()->getBlock(); 75 Value *V = computeValueAt(IDom, R, DT); 76 R.Defines[BB] = V; 77 } else 78 R.Defines[BB] = UndefValue::get(R.Ty); 79 } 80 return R.Defines[BB]; 81 } 82 83 /// Given sets of UsingBlocks and DefBlocks, compute the set of LiveInBlocks. 84 /// This is basically a subgraph limited by DefBlocks and UsingBlocks. 85 static void ComputeLiveInBlocks(const SmallPtrSetImpl<BasicBlock * > & UsingBlocks,const SmallPtrSetImpl<BasicBlock * > & DefBlocks,SmallPtrSetImpl<BasicBlock * > & LiveInBlocks,PredIteratorCache & PredCache)86 ComputeLiveInBlocks(const SmallPtrSetImpl<BasicBlock *> &UsingBlocks, 87 const SmallPtrSetImpl<BasicBlock *> &DefBlocks, 88 SmallPtrSetImpl<BasicBlock *> &LiveInBlocks, 89 PredIteratorCache &PredCache) { 90 // To determine liveness, we must iterate through the predecessors of blocks 91 // where the def is live. Blocks are added to the worklist if we need to 92 // check their predecessors. Start with all the using blocks. 93 SmallVector<BasicBlock *, 64> LiveInBlockWorklist(UsingBlocks.begin(), 94 UsingBlocks.end()); 95 96 // Now that we have a set of blocks where the phi is live-in, recursively add 97 // their predecessors until we find the full region the value is live. 98 while (!LiveInBlockWorklist.empty()) { 99 BasicBlock *BB = LiveInBlockWorklist.pop_back_val(); 100 101 // The block really is live in here, insert it into the set. If already in 102 // the set, then it has already been processed. 103 if (!LiveInBlocks.insert(BB).second) 104 continue; 105 106 // Since the value is live into BB, it is either defined in a predecessor or 107 // live into it to. Add the preds to the worklist unless they are a 108 // defining block. 109 for (BasicBlock *P : PredCache.get(BB)) { 110 // The value is not live into a predecessor if it defines the value. 111 if (DefBlocks.count(P)) 112 continue; 113 114 // Otherwise it is, add to the worklist. 115 LiveInBlockWorklist.push_back(P); 116 } 117 } 118 } 119 120 /// Perform all the necessary updates, including new PHI-nodes insertion and the 121 /// requested uses update. RewriteAllUses(DominatorTree * DT,SmallVectorImpl<PHINode * > * InsertedPHIs)122 void SSAUpdaterBulk::RewriteAllUses(DominatorTree *DT, 123 SmallVectorImpl<PHINode *> *InsertedPHIs) { 124 for (auto &R : Rewrites) { 125 // Compute locations for new phi-nodes. 126 // For that we need to initialize DefBlocks from definitions in R.Defines, 127 // UsingBlocks from uses in R.Uses, then compute LiveInBlocks, and then use 128 // this set for computing iterated dominance frontier (IDF). 129 // The IDF blocks are the blocks where we need to insert new phi-nodes. 130 ForwardIDFCalculator IDF(*DT); 131 LLVM_DEBUG(dbgs() << "SSAUpdater: rewriting " << R.Uses.size() 132 << " use(s)\n"); 133 134 SmallPtrSet<BasicBlock *, 2> DefBlocks; 135 for (auto &Def : R.Defines) 136 DefBlocks.insert(Def.first); 137 IDF.setDefiningBlocks(DefBlocks); 138 139 SmallPtrSet<BasicBlock *, 2> UsingBlocks; 140 for (Use *U : R.Uses) 141 UsingBlocks.insert(getUserBB(U)); 142 143 SmallVector<BasicBlock *, 32> IDFBlocks; 144 SmallPtrSet<BasicBlock *, 32> LiveInBlocks; 145 ComputeLiveInBlocks(UsingBlocks, DefBlocks, LiveInBlocks, PredCache); 146 IDF.resetLiveInBlocks(); 147 IDF.setLiveInBlocks(LiveInBlocks); 148 IDF.calculate(IDFBlocks); 149 150 // We've computed IDF, now insert new phi-nodes there. 151 SmallVector<PHINode *, 4> InsertedPHIsForVar; 152 for (auto *FrontierBB : IDFBlocks) { 153 IRBuilder<> B(FrontierBB, FrontierBB->begin()); 154 PHINode *PN = B.CreatePHI(R.Ty, 0, R.Name); 155 R.Defines[FrontierBB] = PN; 156 InsertedPHIsForVar.push_back(PN); 157 if (InsertedPHIs) 158 InsertedPHIs->push_back(PN); 159 } 160 161 // Fill in arguments of the inserted PHIs. 162 for (auto *PN : InsertedPHIsForVar) { 163 BasicBlock *PBB = PN->getParent(); 164 for (BasicBlock *Pred : PredCache.get(PBB)) 165 PN->addIncoming(computeValueAt(Pred, R, DT), Pred); 166 } 167 168 // Rewrite actual uses with the inserted definitions. 169 SmallPtrSet<Use *, 4> ProcessedUses; 170 for (Use *U : R.Uses) { 171 if (!ProcessedUses.insert(U).second) 172 continue; 173 Value *V = computeValueAt(getUserBB(U), R, DT); 174 Value *OldVal = U->get(); 175 assert(OldVal && "Invalid use!"); 176 // Notify that users of the existing value that it is being replaced. 177 if (OldVal != V && OldVal->hasValueHandle()) 178 ValueHandleBase::ValueIsRAUWd(OldVal, V); 179 LLVM_DEBUG(dbgs() << "SSAUpdater: replacing " << *OldVal << " with " << *V 180 << "\n"); 181 U->set(V); 182 } 183 } 184 } 185