LLVM  4.0.0
Sink.cpp
Go to the documentation of this file.
1 //===-- Sink.cpp - Code Sinking -------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass moves instructions into successor blocks, when possible, so that
11 // they aren't executed on paths where their results aren't needed.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/Statistic.h"
18 #include "llvm/Analysis/LoopInfo.h"
20 #include "llvm/IR/CFG.h"
21 #include "llvm/IR/DataLayout.h"
22 #include "llvm/IR/Dominators.h"
23 #include "llvm/IR/IntrinsicInst.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/Support/Debug.h"
27 #include "llvm/Transforms/Scalar.h"
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "sink"
31 
32 STATISTIC(NumSunk, "Number of instructions sunk");
33 STATISTIC(NumSinkIter, "Number of sinking iterations");
34 
35 /// AllUsesDominatedByBlock - Return true if all uses of the specified value
36 /// occur in blocks dominated by the specified block.
38  DominatorTree &DT) {
39  // Ignoring debug uses is necessary so debug info doesn't affect the code.
40  // This may leave a referencing dbg_value in the original block, before
41  // the definition of the vreg. Dwarf generator handles this although the
42  // user might not get the right info at runtime.
43  for (Use &U : Inst->uses()) {
44  // Determine the block of the use.
45  Instruction *UseInst = cast<Instruction>(U.getUser());
46  BasicBlock *UseBlock = UseInst->getParent();
47  if (PHINode *PN = dyn_cast<PHINode>(UseInst)) {
48  // PHI nodes use the operand in the predecessor block, not the block with
49  // the PHI.
50  unsigned Num = PHINode::getIncomingValueNumForOperand(U.getOperandNo());
51  UseBlock = PN->getIncomingBlock(Num);
52  }
53  // Check that it dominates.
54  if (!DT.dominates(BB, UseBlock))
55  return false;
56  }
57  return true;
58 }
59 
60 static bool isSafeToMove(Instruction *Inst, AliasAnalysis &AA,
62 
63  if (Inst->mayWriteToMemory()) {
64  Stores.insert(Inst);
65  return false;
66  }
67 
68  if (LoadInst *L = dyn_cast<LoadInst>(Inst)) {
70  for (Instruction *S : Stores)
71  if (AA.getModRefInfo(S, Loc) & MRI_Mod)
72  return false;
73  }
74 
75  if (isa<TerminatorInst>(Inst) || isa<PHINode>(Inst) || Inst->isEHPad() ||
76  Inst->mayThrow())
77  return false;
78 
79  if (auto CS = CallSite(Inst)) {
80  // Convergent operations cannot be made control-dependent on additional
81  // values.
82  if (CS.hasFnAttr(Attribute::Convergent))
83  return false;
84 
85  for (Instruction *S : Stores)
86  if (AA.getModRefInfo(S, CS) & MRI_Mod)
87  return false;
88  }
89 
90  return true;
91 }
92 
93 /// IsAcceptableTarget - Return true if it is possible to sink the instruction
94 /// in the specified basic block.
95 static bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo,
96  DominatorTree &DT, LoopInfo &LI) {
97  assert(Inst && "Instruction to be sunk is null");
98  assert(SuccToSinkTo && "Candidate sink target is null");
99 
100  // It is not possible to sink an instruction into its own block. This can
101  // happen with loops.
102  if (Inst->getParent() == SuccToSinkTo)
103  return false;
104 
105  // It's never legal to sink an instruction into a block which terminates in an
106  // EH-pad.
107  if (SuccToSinkTo->getTerminator()->isExceptional())
108  return false;
109 
110  // If the block has multiple predecessors, this would introduce computation
111  // on different code paths. We could split the critical edge, but for now we
112  // just punt.
113  // FIXME: Split critical edges if not backedges.
114  if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
115  // We cannot sink a load across a critical edge - there may be stores in
116  // other code paths.
117  if (!isSafeToSpeculativelyExecute(Inst))
118  return false;
119 
120  // We don't want to sink across a critical edge if we don't dominate the
121  // successor. We could be introducing calculations to new code paths.
122  if (!DT.dominates(Inst->getParent(), SuccToSinkTo))
123  return false;
124 
125  // Don't sink instructions into a loop.
126  Loop *succ = LI.getLoopFor(SuccToSinkTo);
127  Loop *cur = LI.getLoopFor(Inst->getParent());
128  if (succ != nullptr && succ != cur)
129  return false;
130  }
131 
132  // Finally, check that all the uses of the instruction are actually
133  // dominated by the candidate
134  return AllUsesDominatedByBlock(Inst, SuccToSinkTo, DT);
135 }
136 
137 /// SinkInstruction - Determine whether it is safe to sink the specified machine
138 /// instruction out of its current block into a successor.
139 static bool SinkInstruction(Instruction *Inst,
141  DominatorTree &DT, LoopInfo &LI, AAResults &AA) {
142 
143  // Don't sink static alloca instructions. CodeGen assumes allocas outside the
144  // entry block are dynamically sized stack objects.
145  if (AllocaInst *AI = dyn_cast<AllocaInst>(Inst))
146  if (AI->isStaticAlloca())
147  return false;
148 
149  // Check if it's safe to move the instruction.
150  if (!isSafeToMove(Inst, AA, Stores))
151  return false;
152 
153  // FIXME: This should include support for sinking instructions within the
154  // block they are currently in to shorten the live ranges. We often get
155  // instructions sunk into the top of a large block, but it would be better to
156  // also sink them down before their first use in the block. This xform has to
157  // be careful not to *increase* register pressure though, e.g. sinking
158  // "x = y + z" down if it kills y and z would increase the live ranges of y
159  // and z and only shrink the live range of x.
160 
161  // SuccToSinkTo - This is the successor to sink this instruction to, once we
162  // decide.
163  BasicBlock *SuccToSinkTo = nullptr;
164 
165  // Instructions can only be sunk if all their uses are in blocks
166  // dominated by one of the successors.
167  // Look at all the postdominators and see if we can sink it in one.
168  DomTreeNode *DTN = DT.getNode(Inst->getParent());
169  for (DomTreeNode::iterator I = DTN->begin(), E = DTN->end();
170  I != E && SuccToSinkTo == nullptr; ++I) {
171  BasicBlock *Candidate = (*I)->getBlock();
172  if ((*I)->getIDom()->getBlock() == Inst->getParent() &&
173  IsAcceptableTarget(Inst, Candidate, DT, LI))
174  SuccToSinkTo = Candidate;
175  }
176 
177  // If no suitable postdominator was found, look at all the successors and
178  // decide which one we should sink to, if any.
179  for (succ_iterator I = succ_begin(Inst->getParent()),
180  E = succ_end(Inst->getParent()); I != E && !SuccToSinkTo; ++I) {
181  if (IsAcceptableTarget(Inst, *I, DT, LI))
182  SuccToSinkTo = *I;
183  }
184 
185  // If we couldn't find a block to sink to, ignore this instruction.
186  if (!SuccToSinkTo)
187  return false;
188 
189  DEBUG(dbgs() << "Sink" << *Inst << " (";
190  Inst->getParent()->printAsOperand(dbgs(), false);
191  dbgs() << " -> ";
192  SuccToSinkTo->printAsOperand(dbgs(), false);
193  dbgs() << ")\n");
194 
195  // Move the instruction.
196  Inst->moveBefore(&*SuccToSinkTo->getFirstInsertionPt());
197  return true;
198 }
199 
200 static bool ProcessBlock(BasicBlock &BB, DominatorTree &DT, LoopInfo &LI,
201  AAResults &AA) {
202  // Can't sink anything out of a block that has less than two successors.
203  if (BB.getTerminator()->getNumSuccessors() <= 1) return false;
204 
205  // Don't bother sinking code out of unreachable blocks. In addition to being
206  // unprofitable, it can also lead to infinite looping, because in an
207  // unreachable loop there may be nowhere to stop.
208  if (!DT.isReachableFromEntry(&BB)) return false;
209 
210  bool MadeChange = false;
211 
212  // Walk the basic block bottom-up. Remember if we saw a store.
213  BasicBlock::iterator I = BB.end();
214  --I;
215  bool ProcessedBegin = false;
217  do {
218  Instruction *Inst = &*I; // The instruction to sink.
219 
220  // Predecrement I (if it's not begin) so that it isn't invalidated by
221  // sinking.
222  ProcessedBegin = I == BB.begin();
223  if (!ProcessedBegin)
224  --I;
225 
226  if (isa<DbgInfoIntrinsic>(Inst))
227  continue;
228 
229  if (SinkInstruction(Inst, Stores, DT, LI, AA)) {
230  ++NumSunk;
231  MadeChange = true;
232  }
233 
234  // If we just processed the first instruction in the block, we're done.
235  } while (!ProcessedBegin);
236 
237  return MadeChange;
238 }
239 
241  LoopInfo &LI, AAResults &AA) {
242  bool MadeChange, EverMadeChange = false;
243 
244  do {
245  MadeChange = false;
246  DEBUG(dbgs() << "Sinking iteration " << NumSinkIter << "\n");
247  // Process all basic blocks.
248  for (BasicBlock &I : F)
249  MadeChange |= ProcessBlock(I, DT, LI, AA);
250  EverMadeChange |= MadeChange;
251  NumSinkIter++;
252  } while (MadeChange);
253 
254  return EverMadeChange;
255 }
256 
258  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
259  auto &LI = AM.getResult<LoopAnalysis>(F);
260  auto &AA = AM.getResult<AAManager>(F);
261 
262  if (!iterativelySinkInstructions(F, DT, LI, AA))
263  return PreservedAnalyses::all();
264 
265  auto PA = PreservedAnalyses();
266  PA.preserve<DominatorTreeAnalysis>();
267  PA.preserve<LoopAnalysis>();
268  return PA;
269 }
270 
271 namespace {
272  class SinkingLegacyPass : public FunctionPass {
273  public:
274  static char ID; // Pass identification
275  SinkingLegacyPass() : FunctionPass(ID) {
277  }
278 
279  bool runOnFunction(Function &F) override {
280  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
281  auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
282  auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
283 
284  return iterativelySinkInstructions(F, DT, LI, AA);
285  }
286 
287  void getAnalysisUsage(AnalysisUsage &AU) const override {
288  AU.setPreservesCFG();
295  }
296  };
297 } // end anonymous namespace
298 
299 char SinkingLegacyPass::ID = 0;
300 INITIALIZE_PASS_BEGIN(SinkingLegacyPass, "sink", "Code sinking", false, false)
304 INITIALIZE_PASS_END(SinkingLegacyPass, "sink", "Code sinking", false, false)
305 
306 FunctionPass *llvm::createSinkingPass() { return new SinkingLegacyPass(); }
MachineLoop * L
iterator_range< use_iterator > uses()
Definition: Value.h:326
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
BasicBlock * getUniquePredecessor()
Return the predecessor of this block if it has a unique predecessor block.
Definition: BasicBlock.cpp:239
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
static bool AllUsesDominatedByBlock(Instruction *Inst, BasicBlock *BB, DominatorTree &DT)
AllUsesDominatedByBlock - Return true if all uses of the specified value occur in blocks dominated by...
Definition: Sink.cpp:37
STATISTIC(NumFunctions,"Total number of functions")
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:84
machine Machine code sinking
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: Sink.cpp:257
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:189
An instruction for reading from memory.
Definition: Instructions.h:164
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Definition: LoopInfo.h:575
The access modifies the value stored in memory.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:53
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
FunctionPass * createSinkingPass()
Definition: Sink.cpp:306
Analysis pass that exposes the LoopInfo for a function.
Definition: LoopInfo.h:806
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:106
#define F(x, y, z)
Definition: MD5.cpp:51
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3473
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Definition: Dominators.cpp:269
static bool isSafeToMove(Instruction *Inst, AliasAnalysis &AA, SmallPtrSetImpl< Instruction * > &Stores)
Definition: Sink.cpp:60
Function Alias Analysis false
Base class for the actual dominator tree node.
static bool ProcessBlock(BasicBlock &BB, DominatorTree &DT, LoopInfo &LI, AAResults &AA)
Definition: Sink.cpp:200
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:109
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs...ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:653
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
A manager for alias analyses.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:368
Represent the analysis usage information of a pass.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
void initializeSinkingLegacyPassPass(PassRegistry &)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
static unsigned getIncomingValueNumForOperand(unsigned i)
bool mayWriteToMemory() const
Return true if this instruction may modify memory.
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:218
Representation for a specific memory location.
Iterator for intrusive lists based on ilist_node.
static bool SinkInstruction(Instruction *Inst, SmallPtrSetImpl< Instruction * > &Stores, DominatorTree &DT, LoopInfo &LI, AAResults &AA)
SinkInstruction - Determine whether it is safe to sink the specified machine instruction out of its c...
Definition: Sink.cpp:139
iterator end()
Definition: BasicBlock.h:230
Module.h This file contains the declarations for the Module class.
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:50
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:276
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
getModRefInfo (for call sites) - Return information about whether a particular call site modifies or ...
bool mayThrow() const
Return true if this instruction may throw an exception.
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:453
static bool IsAcceptableTarget(Instruction *Inst, BasicBlock *SuccToSinkTo, DominatorTree &DT, LoopInfo &LI)
IsAcceptableTarget - Return true if it is possible to sink the instruction in the specified basic blo...
Definition: Sink.cpp:95
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:368
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
static bool iterativelySinkInstructions(Function &F, DominatorTree &DT, LoopInfo &LI, AAResults &AA)
Definition: Sink.cpp:240
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::vector< DomTreeNodeBase< NodeT > * >::iterator iterator
bool isSafeToSpeculativelyExecute(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
void moveBefore(Instruction *MovePos)
Unlink this instruction from its current basic block and insert it into the basic block that MovePos ...
Definition: Instruction.cpp:95
#define DEBUG(X)
Definition: Debug.h:100
bool isExceptional() const
Definition: InstrTypes.h:97
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:831
A container for analyses that lazily runs them and caches their results.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:217
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object...
machine sink
When an instruction is found to only be used outside of the loop, this function moves it to the exit ...
const BasicBlock * getParent() const
Definition: Instruction.h:62
an instruction to allocate memory on the stack
Definition: Instructions.h:60