lib/Transforms/Utils/SSAUpdaterBulk.cpp

   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 /// Return true if the SSAUpdater already has a value for the specified variable
  69 /// in the specified block.
  70 bool 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.
  76 Value *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.
  91 static void
  92 ComputeLiveInBlocks(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.
 128 void 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 }