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
22using 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.
29static 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.
40unsigned 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.
51void 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.
61void 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/// Return true if the SSAUpdater already has a value for the specified variable
69/// in the specified block.
70bool SSAUpdaterBulk::HasValueForBlock(unsigned Var, BasicBlock *BB) {
71  return (Var < Rewrites.size()) ? Rewrites[Var].Defines.count(BB) : false;
72}
73
74// Compute value at the given block BB. We either should already know it, or we
75// should be able to recursively reach it going up dominator tree.
76Value *SSAUpdaterBulk::computeValueAt(BasicBlock *BB, RewriteInfo &R,
77                                      DominatorTree *DT) {
78  if (!R.Defines.count(BB)) {
79    if (DT->isReachableFromEntry(BB) && PredCache.get(BB).size()) {
80      BasicBlock *IDom = DT->getNode(BB)->getIDom()->getBlock();
81      Value *V = computeValueAt(IDom, R, DT);
82      R.Defines[BB] = V;
83    } else
84      R.Defines[BB] = UndefValue::get(R.Ty);
85  }
86  return R.Defines[BB];
87}
88
89/// Given sets of UsingBlocks and DefBlocks, compute the set of LiveInBlocks.
90/// This is basically a subgraph limited by DefBlocks and UsingBlocks.
91static void
92ComputeLiveInBlocks(const SmallPtrSetImpl<BasicBlock *> &UsingBlocks,
93                    const SmallPtrSetImpl<BasicBlock *> &DefBlocks,
94                    SmallPtrSetImpl<BasicBlock *> &LiveInBlocks,
95                    PredIteratorCache &PredCache) {
96  // To determine liveness, we must iterate through the predecessors of blocks
97  // where the def is live.  Blocks are added to the worklist if we need to
98  // check their predecessors.  Start with all the using blocks.
99  SmallVector<BasicBlock *, 64> LiveInBlockWorklist(UsingBlocks.begin(),
100                                                    UsingBlocks.end());
101
102  // Now that we have a set of blocks where the phi is live-in, recursively add
103  // their predecessors until we find the full region the value is live.
104  while (!LiveInBlockWorklist.empty()) {
105    BasicBlock *BB = LiveInBlockWorklist.pop_back_val();
106
107    // The block really is live in here, insert it into the set.  If already in
108    // the set, then it has already been processed.
109    if (!LiveInBlocks.insert(BB).second)
110      continue;
111
112    // Since the value is live into BB, it is either defined in a predecessor or
113    // live into it to.  Add the preds to the worklist unless they are a
114    // defining block.
115    for (BasicBlock *P : PredCache.get(BB)) {
116      // The value is not live into a predecessor if it defines the value.
117      if (DefBlocks.count(P))
118        continue;
119
120      // Otherwise it is, add to the worklist.
121      LiveInBlockWorklist.push_back(P);
122    }
123  }
124}
125
126/// Perform all the necessary updates, including new PHI-nodes insertion and the
127/// requested uses update.
128void SSAUpdaterBulk::RewriteAllUses(DominatorTree *DT,
129                                    SmallVectorImpl<PHINode *> *InsertedPHIs) {
130  for (auto &R : Rewrites) {
131    // Compute locations for new phi-nodes.
132    // For that we need to initialize DefBlocks from definitions in R.Defines,
133    // UsingBlocks from uses in R.Uses, then compute LiveInBlocks, and then use
134    // this set for computing iterated dominance frontier (IDF).
135    // The IDF blocks are the blocks where we need to insert new phi-nodes.
136    ForwardIDFCalculator IDF(*DT);
137    LLVM_DEBUG(dbgs() << "SSAUpdater: rewriting " << R.Uses.size()
138                      << " use(s)\n");
139
140    SmallPtrSet<BasicBlock *, 2> DefBlocks;
141    for (auto &Def : R.Defines)
142      DefBlocks.insert(Def.first);
143    IDF.setDefiningBlocks(DefBlocks);
144
145    SmallPtrSet<BasicBlock *, 2> UsingBlocks;
146    for (Use *U : R.Uses)
147      UsingBlocks.insert(getUserBB(U));
148
149    SmallVector<BasicBlock *, 32> IDFBlocks;
150    SmallPtrSet<BasicBlock *, 32> LiveInBlocks;
151    ComputeLiveInBlocks(UsingBlocks, DefBlocks, LiveInBlocks, PredCache);
152    IDF.resetLiveInBlocks();
153    IDF.setLiveInBlocks(LiveInBlocks);
154    IDF.calculate(IDFBlocks);
155
156    // We've computed IDF, now insert new phi-nodes there.
157    SmallVector<PHINode *, 4> InsertedPHIsForVar;
158    for (auto *FrontierBB : IDFBlocks) {
159      IRBuilder<> B(FrontierBB, FrontierBB->begin());
160      PHINode *PN = B.CreatePHI(R.Ty, 0, R.Name);
161      R.Defines[FrontierBB] = PN;
162      InsertedPHIsForVar.push_back(PN);
163      if (InsertedPHIs)
164        InsertedPHIs->push_back(PN);
165    }
166
167    // Fill in arguments of the inserted PHIs.
168    for (auto *PN : InsertedPHIsForVar) {
169      BasicBlock *PBB = PN->getParent();
170      for (BasicBlock *Pred : PredCache.get(PBB))
171        PN->addIncoming(computeValueAt(Pred, R, DT), Pred);
172    }
173
174    // Rewrite actual uses with the inserted definitions.
175    SmallPtrSet<Use *, 4> ProcessedUses;
176    for (Use *U : R.Uses) {
177      if (!ProcessedUses.insert(U).second)
178        continue;
179      Value *V = computeValueAt(getUserBB(U), R, DT);
180      Value *OldVal = U->get();
181      assert(OldVal && "Invalid use!");
182      // Notify that users of the existing value that it is being replaced.
183      if (OldVal != V && OldVal->hasValueHandle())
184        ValueHandleBase::ValueIsRAUWd(OldVal, V);
185      LLVM_DEBUG(dbgs() << "SSAUpdater: replacing " << *OldVal << " with " << *V
186                        << "\n");
187      U->set(V);
188    }
189  }
190}
191