LLVM  4.0.0
SparsePropagation.cpp
Go to the documentation of this file.
1 //===- SparsePropagation.cpp - Sparse Conditional Property Propagation ----===//
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 an abstract sparse conditional propagation algorithm,
11 // modeled after SCCP, but with a customizable lattice function.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/Support/Debug.h"
21 using namespace llvm;
22 
23 #define DEBUG_TYPE "sparseprop"
24 
25 //===----------------------------------------------------------------------===//
26 // AbstractLatticeFunction Implementation
27 //===----------------------------------------------------------------------===//
28 
30 
31 /// PrintValue - Render the specified lattice value to the specified stream.
33  if (V == UndefVal)
34  OS << "undefined";
35  else if (V == OverdefinedVal)
36  OS << "overdefined";
37  else if (V == UntrackedVal)
38  OS << "untracked";
39  else
40  OS << "unknown lattice value";
41 }
42 
43 //===----------------------------------------------------------------------===//
44 // SparseSolver Implementation
45 //===----------------------------------------------------------------------===//
46 
47 /// getOrInitValueState - Return the LatticeVal object that corresponds to the
48 /// value, initializing the value's state if it hasn't been entered into the
49 /// map yet. This function is necessary because not all values should start
50 /// out in the underdefined state... Arguments should be overdefined, and
51 /// constants should be marked as constants.
52 ///
53 SparseSolver::LatticeVal SparseSolver::getOrInitValueState(Value *V) {
54  DenseMap<Value*, LatticeVal>::iterator I = ValueState.find(V);
55  if (I != ValueState.end()) return I->second; // Common case, in the map
56 
57  LatticeVal LV;
58  if (LatticeFunc->IsUntrackedValue(V))
59  return LatticeFunc->getUntrackedVal();
60  else if (Constant *C = dyn_cast<Constant>(V))
61  LV = LatticeFunc->ComputeConstant(C);
62  else if (Argument *A = dyn_cast<Argument>(V))
63  LV = LatticeFunc->ComputeArgument(A);
64  else if (!isa<Instruction>(V))
65  // All other non-instructions are overdefined.
66  LV = LatticeFunc->getOverdefinedVal();
67  else
68  // All instructions are underdefined by default.
69  LV = LatticeFunc->getUndefVal();
70 
71  // If this value is untracked, don't add it to the map.
72  if (LV == LatticeFunc->getUntrackedVal())
73  return LV;
74  return ValueState[V] = LV;
75 }
76 
77 /// UpdateState - When the state for some instruction is potentially updated,
78 /// this function notices and adds I to the worklist if needed.
79 void SparseSolver::UpdateState(Instruction &Inst, LatticeVal V) {
80  DenseMap<Value*, LatticeVal>::iterator I = ValueState.find(&Inst);
81  if (I != ValueState.end() && I->second == V)
82  return; // No change.
83 
84  // An update. Visit uses of I.
85  ValueState[&Inst] = V;
86  InstWorkList.push_back(&Inst);
87 }
88 
89 /// MarkBlockExecutable - This method can be used by clients to mark all of
90 /// the blocks that are known to be intrinsically live in the processed unit.
91 void SparseSolver::MarkBlockExecutable(BasicBlock *BB) {
92  DEBUG(dbgs() << "Marking Block Executable: " << BB->getName() << "\n");
93  BBExecutable.insert(BB); // Basic block is executable!
94  BBWorkList.push_back(BB); // Add the block to the work list!
95 }
96 
97 /// markEdgeExecutable - Mark a basic block as executable, adding it to the BB
98 /// work list if it is not already executable...
99 void SparseSolver::markEdgeExecutable(BasicBlock *Source, BasicBlock *Dest) {
100  if (!KnownFeasibleEdges.insert(Edge(Source, Dest)).second)
101  return; // This edge is already known to be executable!
102 
103  DEBUG(dbgs() << "Marking Edge Executable: " << Source->getName()
104  << " -> " << Dest->getName() << "\n");
105 
106  if (BBExecutable.count(Dest)) {
107  // The destination is already executable, but we just made an edge
108  // feasible that wasn't before. Revisit the PHI nodes in the block
109  // because they have potentially new operands.
110  for (BasicBlock::iterator I = Dest->begin(); isa<PHINode>(I); ++I)
111  visitPHINode(*cast<PHINode>(I));
112 
113  } else {
114  MarkBlockExecutable(Dest);
115  }
116 }
117 
118 
119 /// getFeasibleSuccessors - Return a vector of booleans to indicate which
120 /// successors are reachable from a given terminator instruction.
121 void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
122  SmallVectorImpl<bool> &Succs,
123  bool AggressiveUndef) {
124  Succs.resize(TI.getNumSuccessors());
125  if (TI.getNumSuccessors() == 0) return;
126 
127  if (BranchInst *BI = dyn_cast<BranchInst>(&TI)) {
128  if (BI->isUnconditional()) {
129  Succs[0] = true;
130  return;
131  }
132 
133  LatticeVal BCValue;
134  if (AggressiveUndef)
135  BCValue = getOrInitValueState(BI->getCondition());
136  else
137  BCValue = getLatticeState(BI->getCondition());
138 
139  if (BCValue == LatticeFunc->getOverdefinedVal() ||
140  BCValue == LatticeFunc->getUntrackedVal()) {
141  // Overdefined condition variables can branch either way.
142  Succs[0] = Succs[1] = true;
143  return;
144  }
145 
146  // If undefined, neither is feasible yet.
147  if (BCValue == LatticeFunc->getUndefVal())
148  return;
149 
150  Constant *C = LatticeFunc->GetConstant(BCValue, BI->getCondition(), *this);
151  if (!C || !isa<ConstantInt>(C)) {
152  // Non-constant values can go either way.
153  Succs[0] = Succs[1] = true;
154  return;
155  }
156 
157  // Constant condition variables mean the branch can only go a single way
158  Succs[C->isNullValue()] = true;
159  return;
160  }
161 
162  if (isa<InvokeInst>(TI)) {
163  // Invoke instructions successors are always executable.
164  // TODO: Could ask the lattice function if the value can throw.
165  Succs[0] = Succs[1] = true;
166  return;
167  }
168 
169  if (isa<IndirectBrInst>(TI)) {
170  Succs.assign(Succs.size(), true);
171  return;
172  }
173 
174  SwitchInst &SI = cast<SwitchInst>(TI);
175  LatticeVal SCValue;
176  if (AggressiveUndef)
177  SCValue = getOrInitValueState(SI.getCondition());
178  else
179  SCValue = getLatticeState(SI.getCondition());
180 
181  if (SCValue == LatticeFunc->getOverdefinedVal() ||
182  SCValue == LatticeFunc->getUntrackedVal()) {
183  // All destinations are executable!
184  Succs.assign(TI.getNumSuccessors(), true);
185  return;
186  }
187 
188  // If undefined, neither is feasible yet.
189  if (SCValue == LatticeFunc->getUndefVal())
190  return;
191 
192  Constant *C = LatticeFunc->GetConstant(SCValue, SI.getCondition(), *this);
193  if (!C || !isa<ConstantInt>(C)) {
194  // All destinations are executable!
195  Succs.assign(TI.getNumSuccessors(), true);
196  return;
197  }
198  SwitchInst::CaseIt Case = SI.findCaseValue(cast<ConstantInt>(C));
199  Succs[Case.getSuccessorIndex()] = true;
200 }
201 
202 
203 /// isEdgeFeasible - Return true if the control flow edge from the 'From'
204 /// basic block to the 'To' basic block is currently feasible...
206  bool AggressiveUndef) {
207  SmallVector<bool, 16> SuccFeasible;
208  TerminatorInst *TI = From->getTerminator();
209  getFeasibleSuccessors(*TI, SuccFeasible, AggressiveUndef);
210 
211  for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
212  if (TI->getSuccessor(i) == To && SuccFeasible[i])
213  return true;
214 
215  return false;
216 }
217 
218 void SparseSolver::visitTerminatorInst(TerminatorInst &TI) {
219  SmallVector<bool, 16> SuccFeasible;
220  getFeasibleSuccessors(TI, SuccFeasible, true);
221 
222  BasicBlock *BB = TI.getParent();
223 
224  // Mark all feasible successors executable...
225  for (unsigned i = 0, e = SuccFeasible.size(); i != e; ++i)
226  if (SuccFeasible[i])
227  markEdgeExecutable(BB, TI.getSuccessor(i));
228 }
229 
230 void SparseSolver::visitPHINode(PHINode &PN) {
231  // The lattice function may store more information on a PHINode than could be
232  // computed from its incoming values. For example, SSI form stores its sigma
233  // functions as PHINodes with a single incoming value.
234  if (LatticeFunc->IsSpecialCasedPHI(&PN)) {
235  LatticeVal IV = LatticeFunc->ComputeInstructionState(PN, *this);
236  if (IV != LatticeFunc->getUntrackedVal())
237  UpdateState(PN, IV);
238  return;
239  }
240 
241  LatticeVal PNIV = getOrInitValueState(&PN);
242  LatticeVal Overdefined = LatticeFunc->getOverdefinedVal();
243 
244  // If this value is already overdefined (common) just return.
245  if (PNIV == Overdefined || PNIV == LatticeFunc->getUntrackedVal())
246  return; // Quick exit
247 
248  // Super-extra-high-degree PHI nodes are unlikely to ever be interesting,
249  // and slow us down a lot. Just mark them overdefined.
250  if (PN.getNumIncomingValues() > 64) {
251  UpdateState(PN, Overdefined);
252  return;
253  }
254 
255  // Look at all of the executable operands of the PHI node. If any of them
256  // are overdefined, the PHI becomes overdefined as well. Otherwise, ask the
257  // transfer function to give us the merge of the incoming values.
258  for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
259  // If the edge is not yet known to be feasible, it doesn't impact the PHI.
260  if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent(), true))
261  continue;
262 
263  // Merge in this value.
264  LatticeVal OpVal = getOrInitValueState(PN.getIncomingValue(i));
265  if (OpVal != PNIV)
266  PNIV = LatticeFunc->MergeValues(PNIV, OpVal);
267 
268  if (PNIV == Overdefined)
269  break; // Rest of input values don't matter.
270  }
271 
272  // Update the PHI with the compute value, which is the merge of the inputs.
273  UpdateState(PN, PNIV);
274 }
275 
276 
277 void SparseSolver::visitInst(Instruction &I) {
278  // PHIs are handled by the propagation logic, they are never passed into the
279  // transfer functions.
280  if (PHINode *PN = dyn_cast<PHINode>(&I))
281  return visitPHINode(*PN);
282 
283  // Otherwise, ask the transfer function what the result is. If this is
284  // something that we care about, remember it.
285  LatticeVal IV = LatticeFunc->ComputeInstructionState(I, *this);
286  if (IV != LatticeFunc->getUntrackedVal())
287  UpdateState(I, IV);
288 
289  if (TerminatorInst *TI = dyn_cast<TerminatorInst>(&I))
290  visitTerminatorInst(*TI);
291 }
292 
294  MarkBlockExecutable(&F.getEntryBlock());
295 
296  // Process the work lists until they are empty!
297  while (!BBWorkList.empty() || !InstWorkList.empty()) {
298  // Process the instruction work list.
299  while (!InstWorkList.empty()) {
300  Instruction *I = InstWorkList.back();
301  InstWorkList.pop_back();
302 
303  DEBUG(dbgs() << "\nPopped off I-WL: " << *I << "\n");
304 
305  // "I" got into the work list because it made a transition. See if any
306  // users are both live and in need of updating.
307  for (User *U : I->users()) {
308  Instruction *UI = cast<Instruction>(U);
309  if (BBExecutable.count(UI->getParent())) // Inst is executable?
310  visitInst(*UI);
311  }
312  }
313 
314  // Process the basic block work list.
315  while (!BBWorkList.empty()) {
316  BasicBlock *BB = BBWorkList.back();
317  BBWorkList.pop_back();
318 
319  DEBUG(dbgs() << "\nPopped off BBWL: " << *BB);
320 
321  // Notify all instructions in this basic block that they are newly
322  // executable.
323  for (Instruction &I : *BB)
324  visitInst(I);
325  }
326  }
327 }
328 
330  OS << "\nFUNCTION: " << F.getName() << "\n";
331  for (auto &BB : F) {
332  if (!BBExecutable.count(&BB))
333  OS << "INFEASIBLE: ";
334  OS << "\t";
335  if (BB.hasName())
336  OS << BB.getName() << ":\n";
337  else
338  OS << "; anon bb\n";
339  for (auto &I : BB) {
340  LatticeFunc->PrintValue(getLatticeState(&I), OS);
341  OS << I << "\n";
342  }
343 
344  OS << "\n";
345  }
346 }
347 
LatticeVal getOrInitValueState(Value *V)
getOrInitValueState - Return the LatticeVal object that corresponds to the value, initializing the va...
LLVM Argument representation.
Definition: Argument.h:34
void Solve(Function &F)
Solve - Solve for constants and executable blocks.
LatticeVal getUndefVal() const
bool hasName() const
Definition: Value.h:236
size_t i
virtual LatticeVal ComputeInstructionState(Instruction &I, SparseSolver &SS)
ComputeInstructionState - Given an instruction and a vector of its operand values, compute the result value of the instruction.
bool isEdgeFeasible(BasicBlock *From, BasicBlock *To, bool AggressiveUndef=false)
isEdgeFeasible - Return true if the control flow edge from the 'From' basic block to the 'To' basic b...
unsigned getSuccessorIndex() const
Returns TerminatorInst's successor index for current case successor.
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
virtual bool IsSpecialCasedPHI(PHINode *PN)
IsSpecialCasedPHI - Given a PHI node, determine whether this PHI node is one that the we want to hand...
virtual bool IsUntrackedValue(Value *V)
IsUntrackedValue - If the specified Value is something that is obviously uninteresting to the analysi...
void assign(size_type NumElts, const T &Elt)
Definition: SmallVector.h:418
#define F(x, y, z)
Definition: MD5.cpp:51
virtual LatticeVal ComputeConstant(Constant *C)
ComputeConstant - Given a constant value, compute and return a lattice value corresponding to the spe...
unsigned getNumIncomingValues() const
Return the number of incoming edges.
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
LatticeVal getUntrackedVal() const
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:79
Conditional or Unconditional Branch instruction.
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
LatticeVal getLatticeState(Value *V) const
getLatticeState - Return the LatticeVal object that corresponds to the value.
virtual Constant * GetConstant(LatticeVal LV, Value *Val, SparseSolver &SS)
GetConstant - If the specified lattice value is representable as an LLVM constant value...
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
virtual LatticeVal ComputeArgument(Argument *I)
ComputeArgument - Given a formal argument value, compute and return a lattice value corresponding to ...
void Print(Function &F, raw_ostream &OS) const
Iterator for intrusive lists based on ilist_node.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
CaseIt findCaseValue(const ConstantInt *C)
Search all of the case values for the specified constant.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
virtual void PrintValue(LatticeVal V, raw_ostream &OS)
PrintValue - Render the specified lattice value to the specified stream.
iterator_range< user_iterator > users()
Definition: Value.h:370
Value * getCondition() const
virtual LatticeVal MergeValues(LatticeVal X, LatticeVal Y)
MergeValues - Compute and return the merge of the two specified lattice values.
#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
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
Multiway switch.
LLVM Value Representation.
Definition: Value.h:71
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
#define DEBUG(X)
Definition: Debug.h:100
LatticeVal getOverdefinedVal() const
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
const BasicBlock * getParent() const
Definition: Instruction.h:62
void resize(size_type N)
Definition: SmallVector.h:352