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.
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.
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.
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.
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.
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
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.
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