LLVM  3.7.0
IVUsers.cpp
Go to the documentation of this file.
1 //===- IVUsers.cpp - Induction Variable Users -------------------*- C++ -*-===//
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 file implements bookkeeping for "interesting" users of expressions
11 // computed from induction variables.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/Analysis/IVUsers.h"
19 #include "llvm/Analysis/LoopPass.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DataLayout.h"
24 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/Dominators.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/Module.h"
28 #include "llvm/IR/Type.h"
29 #include "llvm/Support/Debug.h"
31 #include <algorithm>
32 using namespace llvm;
33 
34 #define DEBUG_TYPE "iv-users"
35 
36 char IVUsers::ID = 0;
37 INITIALIZE_PASS_BEGIN(IVUsers, "iv-users",
38  "Induction Variable Users", false, true)
44  "Induction Variable Users", false, true)
45 
47  return new IVUsers();
48 }
49 
50 /// isInteresting - Test whether the given expression is "interesting" when
51 /// used by the given expression, within the context of analyzing the
52 /// given loop.
53 static bool isInteresting(const SCEV *S, const Instruction *I, const Loop *L,
54  ScalarEvolution *SE, LoopInfo *LI) {
55  // An addrec is interesting if it's affine or if it has an interesting start.
56  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S)) {
57  // Keep things simple. Don't touch loop-variant strides unless they're
58  // only used outside the loop and we can simplify them.
59  if (AR->getLoop() == L)
60  return AR->isAffine() ||
61  (!L->contains(I) &&
62  SE->getSCEVAtScope(AR, LI->getLoopFor(I->getParent())) != AR);
63  // Otherwise recurse to see if the start value is interesting, and that
64  // the step value is not interesting, since we don't yet know how to
65  // do effective SCEV expansions for addrecs with interesting steps.
66  return isInteresting(AR->getStart(), I, L, SE, LI) &&
67  !isInteresting(AR->getStepRecurrence(*SE), I, L, SE, LI);
68  }
69 
70  // An add is interesting if exactly one of its operands is interesting.
71  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
72  bool AnyInterestingYet = false;
73  for (SCEVAddExpr::op_iterator OI = Add->op_begin(), OE = Add->op_end();
74  OI != OE; ++OI)
75  if (isInteresting(*OI, I, L, SE, LI)) {
76  if (AnyInterestingYet)
77  return false;
78  AnyInterestingYet = true;
79  }
80  return AnyInterestingYet;
81  }
82 
83  // Nothing else is interesting here.
84  return false;
85 }
86 
87 /// Return true if all loop headers that dominate this block are in simplified
88 /// form.
89 static bool isSimplifiedLoopNest(BasicBlock *BB, const DominatorTree *DT,
90  const LoopInfo *LI,
91  SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
92  Loop *NearestLoop = nullptr;
93  for (DomTreeNode *Rung = DT->getNode(BB);
94  Rung; Rung = Rung->getIDom()) {
95  BasicBlock *DomBB = Rung->getBlock();
96  Loop *DomLoop = LI->getLoopFor(DomBB);
97  if (DomLoop && DomLoop->getHeader() == DomBB) {
98  // If the domtree walk reaches a loop with no preheader, return false.
99  if (!DomLoop->isLoopSimplifyForm())
100  return false;
101  // If we have already checked this loop nest, stop checking.
102  if (SimpleLoopNests.count(DomLoop))
103  break;
104  // If we have not already checked this loop nest, remember the loop
105  // header nearest to BB. The nearest loop may not contain BB.
106  if (!NearestLoop)
107  NearestLoop = DomLoop;
108  }
109  }
110  if (NearestLoop)
111  SimpleLoopNests.insert(NearestLoop);
112  return true;
113 }
114 
115 /// AddUsersImpl - Inspect the specified instruction. If it is a
116 /// reducible SCEV, recursively add its users to the IVUsesByStride set and
117 /// return true. Otherwise, return false.
119  SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
120  const DataLayout &DL = I->getModule()->getDataLayout();
121 
122  // Add this IV user to the Processed set before returning false to ensure that
123  // all IV users are members of the set. See IVUsers::isIVUserOrOperand.
124  if (!Processed.insert(I).second)
125  return true; // Instruction already handled.
126 
127  if (!SE->isSCEVable(I->getType()))
128  return false; // Void and FP expressions cannot be reduced.
129 
130  // IVUsers is used by LSR which assumes that all SCEV expressions are safe to
131  // pass to SCEVExpander. Expressions are not safe to expand if they represent
132  // operations that are not safe to speculate, namely integer division.
133  if (!isa<PHINode>(I) && !isSafeToSpeculativelyExecute(I))
134  return false;
135 
136  // LSR is not APInt clean, do not touch integers bigger than 64-bits.
137  // Also avoid creating IVs of non-native types. For example, we don't want a
138  // 64-bit IV in 32-bit code just because the loop has one 64-bit cast.
139  uint64_t Width = SE->getTypeSizeInBits(I->getType());
140  if (Width > 64 || !DL.isLegalInteger(Width))
141  return false;
142 
143  // Don't attempt to promote ephemeral values to indvars. They will be removed
144  // later anyway.
145  if (EphValues.count(I))
146  return false;
147 
148  // Get the symbolic expression for this instruction.
149  const SCEV *ISE = SE->getSCEV(I);
150 
151  // If we've come to an uninteresting expression, stop the traversal and
152  // call this a user.
153  if (!isInteresting(ISE, I, L, SE, LI))
154  return false;
155 
156  SmallPtrSet<Instruction *, 4> UniqueUsers;
157  for (Use &U : I->uses()) {
158  Instruction *User = cast<Instruction>(U.getUser());
159  if (!UniqueUsers.insert(User).second)
160  continue;
161 
162  // Do not infinitely recurse on PHI nodes.
163  if (isa<PHINode>(User) && Processed.count(User))
164  continue;
165 
166  // Only consider IVUsers that are dominated by simplified loop
167  // headers. Otherwise, SCEVExpander will crash.
168  BasicBlock *UseBB = User->getParent();
169  // A phi's use is live out of its predecessor block.
170  if (PHINode *PHI = dyn_cast<PHINode>(User)) {
171  unsigned OperandNo = U.getOperandNo();
172  unsigned ValNo = PHINode::getIncomingValueNumForOperand(OperandNo);
173  UseBB = PHI->getIncomingBlock(ValNo);
174  }
175  if (!isSimplifiedLoopNest(UseBB, DT, LI, SimpleLoopNests))
176  return false;
177 
178  // Descend recursively, but not into PHI nodes outside the current loop.
179  // It's important to see the entire expression outside the loop to get
180  // choices that depend on addressing mode use right, although we won't
181  // consider references outside the loop in all cases.
182  // If User is already in Processed, we don't want to recurse into it again,
183  // but do want to record a second reference in the same instruction.
184  bool AddUserToIVUsers = false;
185  if (LI->getLoopFor(User->getParent()) != L) {
186  if (isa<PHINode>(User) || Processed.count(User) ||
187  !AddUsersImpl(User, SimpleLoopNests)) {
188  DEBUG(dbgs() << "FOUND USER in other loop: " << *User << '\n'
189  << " OF SCEV: " << *ISE << '\n');
190  AddUserToIVUsers = true;
191  }
192  } else if (Processed.count(User) || !AddUsersImpl(User, SimpleLoopNests)) {
193  DEBUG(dbgs() << "FOUND USER: " << *User << '\n'
194  << " OF SCEV: " << *ISE << '\n');
195  AddUserToIVUsers = true;
196  }
197 
198  if (AddUserToIVUsers) {
199  // Okay, we found a user that we cannot reduce.
200  IVStrideUse &NewUse = AddUser(User, I);
201  // Autodetect the post-inc loop set, populating NewUse.PostIncLoops.
202  // The regular return value here is discarded; instead of recording
203  // it, we just recompute it when we need it.
204  const SCEV *OriginalISE = ISE;
206  ISE, User, I,
207  NewUse.PostIncLoops,
208  *SE, *DT);
209 
210  // PostIncNormalization effectively simplifies the expression under
211  // pre-increment assumptions. Those assumptions (no wrapping) might not
212  // hold for the post-inc value. Catch such cases by making sure the
213  // transformation is invertible.
214  if (OriginalISE != ISE) {
215  const SCEV *DenormalizedISE =
216  TransformForPostIncUse(Denormalize, ISE, User, I,
217  NewUse.PostIncLoops, *SE, *DT);
218 
219  // If we normalized the expression, but denormalization doesn't give the
220  // original one, discard this user.
221  if (OriginalISE != DenormalizedISE) {
222  DEBUG(dbgs() << " DISCARDING (NORMALIZATION ISN'T INVERTIBLE): "
223  << *ISE << '\n');
224  IVUses.pop_back();
225  return false;
226  }
227  }
228  DEBUG(if (SE->getSCEV(I) != ISE)
229  dbgs() << " NORMALIZED TO: " << *ISE << '\n');
230  }
231  }
232  return true;
233 }
234 
236  // SCEVExpander can only handle users that are dominated by simplified loop
237  // entries. Keep track of all loops that are only dominated by other simple
238  // loops so we don't traverse the domtree for each user.
239  SmallPtrSet<Loop*,16> SimpleLoopNests;
240 
241  return AddUsersImpl(I, SimpleLoopNests);
242 }
243 
245  IVUses.push_back(new IVStrideUse(this, User, Operand));
246  return IVUses.back();
247 }
248 
250  : LoopPass(ID) {
252 }
253 
254 void IVUsers::getAnalysisUsage(AnalysisUsage &AU) const {
259  AU.setPreservesAll();
260 }
261 
262 bool IVUsers::runOnLoop(Loop *l, LPPassManager &LPM) {
263 
264  L = l;
265  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
266  *L->getHeader()->getParent());
267  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
268  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
269  SE = &getAnalysis<ScalarEvolution>();
270 
271  // Collect ephemeral values so that AddUsersIfInteresting skips them.
272  EphValues.clear();
273  CodeMetrics::collectEphemeralValues(L, AC, EphValues);
274 
275  // Find all uses of induction variables in this loop, and categorize
276  // them by stride. Start by finding all of the PHI nodes in the header for
277  // this loop. If they are induction variables, inspect their uses.
278  for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ++I)
279  (void)AddUsersIfInteresting(I);
280 
281  return false;
282 }
283 
284 void IVUsers::print(raw_ostream &OS, const Module *M) const {
285  OS << "IV Users for loop ";
286  L->getHeader()->printAsOperand(OS, false);
288  OS << " with backedge-taken count "
289  << *SE->getBackedgeTakenCount(L);
290  }
291  OS << ":\n";
292 
293  for (ilist<IVStrideUse>::const_iterator UI = IVUses.begin(),
294  E = IVUses.end(); UI != E; ++UI) {
295  OS << " ";
296  UI->getOperandValToReplace()->printAsOperand(OS, false);
297  OS << " = " << *getReplacementExpr(*UI);
299  I = UI->PostIncLoops.begin(),
300  E = UI->PostIncLoops.end(); I != E; ++I) {
301  OS << " (post-inc with loop ";
302  (*I)->getHeader()->printAsOperand(OS, false);
303  OS << ")";
304  }
305  OS << " in ";
306  if (UI->getUser())
307  UI->getUser()->print(OS);
308  else
309  OS << "Printing <null> User";
310  OS << '\n';
311  }
312 }
313 
314 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
315 void IVUsers::dump() const {
316  print(dbgs());
317 }
318 #endif
319 
320 void IVUsers::releaseMemory() {
321  Processed.clear();
322  IVUses.clear();
323 }
324 
325 /// getReplacementExpr - Return a SCEV expression which computes the
326 /// value of the OperandValToReplace.
328  return SE->getSCEV(IU.getOperandValToReplace());
329 }
330 
331 /// getExpr - Return the expression for the use.
332 const SCEV *IVUsers::getExpr(const IVStrideUse &IU) const {
333  return
335  IU.getUser(), IU.getOperandValToReplace(),
336  const_cast<PostIncLoopSet &>(IU.getPostIncLoops()),
337  *SE, *DT);
338 }
339 
340 static const SCEVAddRecExpr *findAddRecForLoop(const SCEV *S, const Loop *L) {
341  if (const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(S)) {
342  if (AR->getLoop() == L)
343  return AR;
344  return findAddRecForLoop(AR->getStart(), L);
345  }
346 
347  if (const SCEVAddExpr *Add = dyn_cast<SCEVAddExpr>(S)) {
348  for (SCEVAddExpr::op_iterator I = Add->op_begin(), E = Add->op_end();
349  I != E; ++I)
350  if (const SCEVAddRecExpr *AR = findAddRecForLoop(*I, L))
351  return AR;
352  return nullptr;
353  }
354 
355  return nullptr;
356 }
357 
358 const SCEV *IVUsers::getStride(const IVStrideUse &IU, const Loop *L) const {
359  if (const SCEVAddRecExpr *AR = findAddRecForLoop(getExpr(IU), L))
360  return AR->getStepRecurrence(*SE);
361  return nullptr;
362 }
363 
365  PostIncLoops.insert(L);
366 }
367 
368 void IVStrideUse::deleted() {
369  // Remove this user from the list.
370  Parent->Processed.erase(this->getUser());
371  Parent->IVUses.erase(this);
372  // this now dangles!
373 }
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:82
const SCEV * getExpr(const IVStrideUse &IU) const
getExpr - Return the expression for the use.
Definition: IVUsers.cpp:332
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
friend class IVStrideUse
Definition: IVUsers.h:121
iterator_range< use_iterator > uses()
Definition: Value.h:283
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
const PostIncLoopSet & getPostIncLoops() const
getPostIncLoops - Return the set of loops for which the expression has been adjusted to use post-inc ...
Definition: IVUsers.h:68
const SCEV * TransformForPostIncUse(TransformKind Kind, const SCEV *S, Instruction *User, Value *OperandValToReplace, PostIncLoopSet &Loops, ScalarEvolution &SE, DominatorTree &DT)
TransformForPostIncUse - Transform the given expression according to the given transformation kind...
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
Pass * createIVUsersPass()
Definition: IVUsers.cpp:46
ScalarEvolution - This class is the main scalar evolution driver.
Denormalize - Perform the inverse transform on the expression with the given loop set...
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:276
An immutable pass that tracks lazily created AssumptionCache objects.
void print(raw_ostream &OS, const Module *=nullptr) const override
print - Print out the internal state of the pass.
Definition: IVUsers.cpp:284
LoopT * getLoopFor(const BlockT *BB) const
getLoopFor - Return the inner most loop that BB lives in.
Definition: LoopInfo.h:540
iv Induction Variable Users
Definition: IVUsers.cpp:43
BlockT * getHeader() const
Definition: LoopInfo.h:96
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:242
bool AddUsersIfInteresting(Instruction *I)
AddUsersIfInteresting - Inspect the specified Instruction.
Definition: IVUsers.cpp:235
void initializeIVUsersPass(PassRegistry &)
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
const SCEV * getStride(const IVStrideUse &IU, const Loop *L) const
Definition: IVUsers.cpp:358
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
const SCEV *const * op_iterator
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
uint64_t getTypeSizeInBits(Type *Ty) const
getTypeSizeInBits - Return the size in bits of the specified type, for which isSCEVable must return t...
bool isLoopSimplifyForm() const
isLoopSimplifyForm - Return true if the Loop is in the form that the LoopSimplify form transforms loo...
Definition: LoopInfo.cpp:199
SCEVAddRecExpr - This node represents a polynomial recurrence on the trip count of the specified loop...
static bool isSimplifiedLoopNest(BasicBlock *BB, const DominatorTree *DT, const LoopInfo *LI, SmallPtrSetImpl< Loop * > &SimpleLoopNests)
Return true if all loop headers that dominate this block are in simplified form.
Definition: IVUsers.cpp:89
Base class for the actual dominator tree node.
Instruction * getUser() const
getUser - Return the user instruction for this use.
Definition: IVUsers.h:45
NormalizeAutodetect - Detect post-inc opportunities on new expressions, update the given loop set...
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
#define true
Definition: ConvertUTF.c:66
bool isSCEVable(Type *Ty) const
isSCEVable - Test if values of the given type are analyzable within the SCEV framework.
bool AddUsersImpl(Instruction *I, SmallPtrSetImpl< Loop * > &SimpleLoopNests)
AddUsersImpl - Inspect the specified instruction.
Definition: IVUsers.cpp:118
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Normalize - Normalize according to the given loops.
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:264
const SCEV * getReplacementExpr(const IVStrideUse &IU) const
getReplacementExpr - Return a SCEV expression which computes the value of the OperandValToReplace of ...
Definition: IVUsers.cpp:327
const SCEV * getSCEVAtScope(const SCEV *S, const Loop *L)
getSCEVAtScope - Return a SCEV expression for the specified value at the specified scope in the progr...
Represent the analysis usage information of a pass.
bool contains(const LoopT *L) const
contains - Return true if the specified loop is contained within in this loop.
Definition: LoopInfo.h:105
static unsigned getIncomingValueNumForOperand(unsigned i)
static bool isInteresting(const SCEV *S, const Instruction *I, const Loop *L, ScalarEvolution *SE, LoopInfo *LI)
isInteresting - Test whether the given expression is "interesting" when used by the given expression...
Definition: IVUsers.cpp:53
iv Induction Variable false
Definition: IVUsers.cpp:43
SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
Definition: SmallPtrSet.h:179
DomTreeNodeBase< NodeT > * getIDom() const
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:57
Value * getOperandValToReplace() const
getOperandValToReplace - Return the Value of the operand in the user instruction that this IVStrideUs...
Definition: IVUsers.h:56
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
static char ID
Definition: IVUsers.h:143
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
SCEVAddExpr - This node represents an addition of some number of SCEVs.
void setPreservesAll()
Set by analyses that do not transform their input at all.
void dump() const
dump - This method is used for debugging.
Definition: IVUsers.cpp:315
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
iv users
Definition: IVUsers.cpp:43
SCEV - This class represents an analyzed expression in the program.
bool isLegalInteger(unsigned Width) const
Returns true if the specified type is known to be a native integer type supported by the CPU...
Definition: DataLayout.h:239
#define I(x, y, z)
Definition: MD5.cpp:54
void transformToPostInc(const Loop *L)
transformToPostInc - Transform the expression to post-inc form for the given loop.
Definition: IVUsers.cpp:364
INITIALIZE_PASS_BEGIN(IVUsers,"iv-users","Induction Variable Users", false, true) INITIALIZE_PASS_END(IVUsers
const SCEV * getBackedgeTakenCount(const Loop *L)
getBackedgeTakenCount - If the specified loop has a predictable backedge-taken count, return it, otherwise return a SCEVCouldNotCompute object.
static const SCEVAddRecExpr * findAddRecForLoop(const SCEV *S, const Loop *L)
Definition: IVUsers.cpp:340
LLVM Value Representation.
Definition: Value.h:69
const SCEV * getSCEV(Value *V)
getSCEV - Return a SCEV expression for the full generality of the specified expression.
IVStrideUse - Keep track of one use of a strided induction variable.
Definition: IVUsers.h:37
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
#define DEBUG(X)
Definition: Debug.h:92
The legacy pass manager's analysis pass to compute loop information.
Definition: LoopInfo.h:737
bool isSafeToSpeculativelyExecute(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
isSafeToSpeculativelyExecute - Return true if the instruction does not have any effects besides calcu...
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
static void collectEphemeralValues(const Loop *L, AssumptionCache *AC, SmallPtrSetImpl< const Value * > &EphValues)
Collect a loop's ephemeral values (those used only by an assume or similar intrinsics in the loop)...
Definition: CodeMetrics.cpp:70
IVStrideUse & AddUser(Instruction *User, Value *Operand)
Definition: IVUsers.cpp:244
bool hasLoopInvariantBackedgeTakenCount(const Loop *L)
hasLoopInvariantBackedgeTakenCount - Return true if the specified loop has an analyzable loop-invaria...
const BasicBlock * getParent() const
Definition: Instruction.h:72