LLVM  3.7.0
LazyValueInfo.cpp
Go to the documentation of this file.
1 //===- LazyValueInfo.cpp - Value constraint analysis ------------*- 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 defines the interface for lazy computation of value constraint
11 // information.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/IR/CFG.h"
23 #include "llvm/IR/ConstantRange.h"
24 #include "llvm/IR/Constants.h"
25 #include "llvm/IR/DataLayout.h"
26 #include "llvm/IR/Dominators.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/IntrinsicInst.h"
29 #include "llvm/IR/PatternMatch.h"
30 #include "llvm/IR/ValueHandle.h"
31 #include "llvm/Support/Debug.h"
33 #include <map>
34 #include <stack>
35 using namespace llvm;
36 using namespace PatternMatch;
37 
38 #define DEBUG_TYPE "lazy-value-info"
39 
40 char LazyValueInfo::ID = 0;
41 INITIALIZE_PASS_BEGIN(LazyValueInfo, "lazy-value-info",
42  "Lazy Value Information Analysis", false, true)
47 
48 namespace llvm {
49  FunctionPass *createLazyValueInfoPass() { return new LazyValueInfo(); }
50 }
51 
52 
53 //===----------------------------------------------------------------------===//
54 // LVILatticeVal
55 //===----------------------------------------------------------------------===//
56 
57 /// This is the information tracked by LazyValueInfo for each value.
58 ///
59 /// FIXME: This is basically just for bringup, this can be made a lot more rich
60 /// in the future.
61 ///
62 namespace {
63 class LVILatticeVal {
64  enum LatticeValueTy {
65  /// This Value has no known value yet.
66  undefined,
67 
68  /// This Value has a specific constant value.
69  constant,
70 
71  /// This Value is known to not have the specified value.
72  notconstant,
73 
74  /// The Value falls within this range.
75  constantrange,
76 
77  /// This value is not known to be constant, and we know that it has a value.
78  overdefined
79  };
80 
81  /// Val: This stores the current lattice value along with the Constant* for
82  /// the constant if this is a 'constant' or 'notconstant' value.
83  LatticeValueTy Tag;
84  Constant *Val;
85  ConstantRange Range;
86 
87 public:
88  LVILatticeVal() : Tag(undefined), Val(nullptr), Range(1, true) {}
89 
90  static LVILatticeVal get(Constant *C) {
91  LVILatticeVal Res;
92  if (!isa<UndefValue>(C))
93  Res.markConstant(C);
94  return Res;
95  }
96  static LVILatticeVal getNot(Constant *C) {
97  LVILatticeVal Res;
98  if (!isa<UndefValue>(C))
99  Res.markNotConstant(C);
100  return Res;
101  }
102  static LVILatticeVal getRange(ConstantRange CR) {
103  LVILatticeVal Res;
104  Res.markConstantRange(CR);
105  return Res;
106  }
107 
108  bool isUndefined() const { return Tag == undefined; }
109  bool isConstant() const { return Tag == constant; }
110  bool isNotConstant() const { return Tag == notconstant; }
111  bool isConstantRange() const { return Tag == constantrange; }
112  bool isOverdefined() const { return Tag == overdefined; }
113 
114  Constant *getConstant() const {
115  assert(isConstant() && "Cannot get the constant of a non-constant!");
116  return Val;
117  }
118 
119  Constant *getNotConstant() const {
120  assert(isNotConstant() && "Cannot get the constant of a non-notconstant!");
121  return Val;
122  }
123 
124  ConstantRange getConstantRange() const {
125  assert(isConstantRange() &&
126  "Cannot get the constant-range of a non-constant-range!");
127  return Range;
128  }
129 
130  /// Return true if this is a change in status.
131  bool markOverdefined() {
132  if (isOverdefined())
133  return false;
134  Tag = overdefined;
135  return true;
136  }
137 
138  /// Return true if this is a change in status.
139  bool markConstant(Constant *V) {
140  assert(V && "Marking constant with NULL");
141  if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
142  return markConstantRange(ConstantRange(CI->getValue()));
143  if (isa<UndefValue>(V))
144  return false;
145 
146  assert((!isConstant() || getConstant() == V) &&
147  "Marking constant with different value");
148  assert(isUndefined());
149  Tag = constant;
150  Val = V;
151  return true;
152  }
153 
154  /// Return true if this is a change in status.
155  bool markNotConstant(Constant *V) {
156  assert(V && "Marking constant with NULL");
157  if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
158  return markConstantRange(ConstantRange(CI->getValue()+1, CI->getValue()));
159  if (isa<UndefValue>(V))
160  return false;
161 
162  assert((!isConstant() || getConstant() != V) &&
163  "Marking constant !constant with same value");
164  assert((!isNotConstant() || getNotConstant() == V) &&
165  "Marking !constant with different value");
166  assert(isUndefined() || isConstant());
167  Tag = notconstant;
168  Val = V;
169  return true;
170  }
171 
172  /// Return true if this is a change in status.
173  bool markConstantRange(const ConstantRange NewR) {
174  if (isConstantRange()) {
175  if (NewR.isEmptySet())
176  return markOverdefined();
177 
178  bool changed = Range != NewR;
179  Range = NewR;
180  return changed;
181  }
182 
183  assert(isUndefined());
184  if (NewR.isEmptySet())
185  return markOverdefined();
186 
187  Tag = constantrange;
188  Range = NewR;
189  return true;
190  }
191 
192  /// Merge the specified lattice value into this one, updating this
193  /// one and returning true if anything changed.
194  bool mergeIn(const LVILatticeVal &RHS, const DataLayout &DL) {
195  if (RHS.isUndefined() || isOverdefined()) return false;
196  if (RHS.isOverdefined()) return markOverdefined();
197 
198  if (isUndefined()) {
199  Tag = RHS.Tag;
200  Val = RHS.Val;
201  Range = RHS.Range;
202  return true;
203  }
204 
205  if (isConstant()) {
206  if (RHS.isConstant()) {
207  if (Val == RHS.Val)
208  return false;
209  return markOverdefined();
210  }
211 
212  if (RHS.isNotConstant()) {
213  if (Val == RHS.Val)
214  return markOverdefined();
215 
216  // Unless we can prove that the two Constants are different, we must
217  // move to overdefined.
218  if (ConstantInt *Res =
219  dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
220  CmpInst::ICMP_NE, getConstant(), RHS.getNotConstant(), DL)))
221  if (Res->isOne())
222  return markNotConstant(RHS.getNotConstant());
223 
224  return markOverdefined();
225  }
226 
227  // RHS is a ConstantRange, LHS is a non-integer Constant.
228 
229  // FIXME: consider the case where RHS is a range [1, 0) and LHS is
230  // a function. The correct result is to pick up RHS.
231 
232  return markOverdefined();
233  }
234 
235  if (isNotConstant()) {
236  if (RHS.isConstant()) {
237  if (Val == RHS.Val)
238  return markOverdefined();
239 
240  // Unless we can prove that the two Constants are different, we must
241  // move to overdefined.
242  if (ConstantInt *Res =
243  dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
244  CmpInst::ICMP_NE, getNotConstant(), RHS.getConstant(), DL)))
245  if (Res->isOne())
246  return false;
247 
248  return markOverdefined();
249  }
250 
251  if (RHS.isNotConstant()) {
252  if (Val == RHS.Val)
253  return false;
254  return markOverdefined();
255  }
256 
257  return markOverdefined();
258  }
259 
260  assert(isConstantRange() && "New LVILattice type?");
261  if (!RHS.isConstantRange())
262  return markOverdefined();
263 
264  ConstantRange NewR = Range.unionWith(RHS.getConstantRange());
265  if (NewR.isFullSet())
266  return markOverdefined();
267  return markConstantRange(NewR);
268  }
269 };
270 
271 } // end anonymous namespace.
272 
273 namespace llvm {
274 raw_ostream &operator<<(raw_ostream &OS, const LVILatticeVal &Val)
276 raw_ostream &operator<<(raw_ostream &OS, const LVILatticeVal &Val) {
277  if (Val.isUndefined())
278  return OS << "undefined";
279  if (Val.isOverdefined())
280  return OS << "overdefined";
281 
282  if (Val.isNotConstant())
283  return OS << "notconstant<" << *Val.getNotConstant() << '>';
284  else if (Val.isConstantRange())
285  return OS << "constantrange<" << Val.getConstantRange().getLower() << ", "
286  << Val.getConstantRange().getUpper() << '>';
287  return OS << "constant<" << *Val.getConstant() << '>';
288 }
289 }
290 
291 //===----------------------------------------------------------------------===//
292 // LazyValueInfoCache Decl
293 //===----------------------------------------------------------------------===//
294 
295 namespace {
296  /// A callback value handle updates the cache when values are erased.
297  class LazyValueInfoCache;
298  struct LVIValueHandle : public CallbackVH {
299  LazyValueInfoCache *Parent;
300 
301  LVIValueHandle(Value *V, LazyValueInfoCache *P)
302  : CallbackVH(V), Parent(P) { }
303 
304  void deleted() override;
305  void allUsesReplacedWith(Value *V) override {
306  deleted();
307  }
308  };
309 }
310 
311 namespace {
312  /// This is the cache kept by LazyValueInfo which
313  /// maintains information about queries across the clients' queries.
314  class LazyValueInfoCache {
315  /// This is all of the cached block information for exactly one Value*.
316  /// The entries are sorted by the BasicBlock* of the
317  /// entries, allowing us to do a lookup with a binary search.
318  typedef std::map<AssertingVH<BasicBlock>, LVILatticeVal> ValueCacheEntryTy;
319 
320  /// This is all of the cached information for all values,
321  /// mapped from Value* to key information.
322  std::map<LVIValueHandle, ValueCacheEntryTy> ValueCache;
323 
324  /// This tracks, on a per-block basis, the set of values that are
325  /// over-defined at the end of that block. This is required
326  /// for cache updating.
327  typedef std::pair<AssertingVH<BasicBlock>, Value*> OverDefinedPairTy;
328  DenseSet<OverDefinedPairTy> OverDefinedCache;
329 
330  /// Keep track of all blocks that we have ever seen, so we
331  /// don't spend time removing unused blocks from our caches.
333 
334  /// This stack holds the state of the value solver during a query.
335  /// It basically emulates the callstack of the naive
336  /// recursive value lookup process.
337  std::stack<std::pair<BasicBlock*, Value*> > BlockValueStack;
338 
339  /// Keeps track of which block-value pairs are in BlockValueStack.
341 
342  /// Push BV onto BlockValueStack unless it's already in there.
343  /// Returns true on success.
344  bool pushBlockValue(const std::pair<BasicBlock *, Value *> &BV) {
345  if (!BlockValueSet.insert(BV).second)
346  return false; // It's already in the stack.
347 
348  BlockValueStack.push(BV);
349  return true;
350  }
351 
352  AssumptionCache *AC; ///< A pointer to the cache of @llvm.assume calls.
353  const DataLayout &DL; ///< A mandatory DataLayout
354  DominatorTree *DT; ///< An optional DT pointer.
355 
356  friend struct LVIValueHandle;
357 
358  void insertResult(Value *Val, BasicBlock *BB, const LVILatticeVal &Result) {
359  SeenBlocks.insert(BB);
360  lookup(Val)[BB] = Result;
361  if (Result.isOverdefined())
362  OverDefinedCache.insert(std::make_pair(BB, Val));
363  }
364 
365  LVILatticeVal getBlockValue(Value *Val, BasicBlock *BB);
366  bool getEdgeValue(Value *V, BasicBlock *F, BasicBlock *T,
367  LVILatticeVal &Result,
368  Instruction *CxtI = nullptr);
369  bool hasBlockValue(Value *Val, BasicBlock *BB);
370 
371  // These methods process one work item and may add more. A false value
372  // returned means that the work item was not completely processed and must
373  // be revisited after going through the new items.
374  bool solveBlockValue(Value *Val, BasicBlock *BB);
375  bool solveBlockValueNonLocal(LVILatticeVal &BBLV,
376  Value *Val, BasicBlock *BB);
377  bool solveBlockValuePHINode(LVILatticeVal &BBLV,
378  PHINode *PN, BasicBlock *BB);
379  bool solveBlockValueConstantRange(LVILatticeVal &BBLV,
380  Instruction *BBI, BasicBlock *BB);
381  void mergeAssumeBlockValueConstantRange(Value *Val, LVILatticeVal &BBLV,
382  Instruction *BBI);
383 
384  void solve();
385 
386  ValueCacheEntryTy &lookup(Value *V) {
387  return ValueCache[LVIValueHandle(V, this)];
388  }
389 
390  public:
391  /// This is the query interface to determine the lattice
392  /// value for the specified Value* at the end of the specified block.
393  LVILatticeVal getValueInBlock(Value *V, BasicBlock *BB,
394  Instruction *CxtI = nullptr);
395 
396  /// This is the query interface to determine the lattice
397  /// value for the specified Value* at the specified instruction (generally
398  /// from an assume intrinsic).
399  LVILatticeVal getValueAt(Value *V, Instruction *CxtI);
400 
401  /// This is the query interface to determine the lattice
402  /// value for the specified Value* that is true on the specified edge.
403  LVILatticeVal getValueOnEdge(Value *V, BasicBlock *FromBB,BasicBlock *ToBB,
404  Instruction *CxtI = nullptr);
405 
406  /// This is the update interface to inform the cache that an edge from
407  /// PredBB to OldSucc has been threaded to be from PredBB to NewSucc.
408  void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc);
409 
410  /// This is part of the update interface to inform the cache
411  /// that a block has been deleted.
412  void eraseBlock(BasicBlock *BB);
413 
414  /// clear - Empty the cache.
415  void clear() {
416  SeenBlocks.clear();
417  ValueCache.clear();
418  OverDefinedCache.clear();
419  }
420 
421  LazyValueInfoCache(AssumptionCache *AC, const DataLayout &DL,
422  DominatorTree *DT = nullptr)
423  : AC(AC), DL(DL), DT(DT) {}
424  };
425 } // end anonymous namespace
426 
427 void LVIValueHandle::deleted() {
428  typedef std::pair<AssertingVH<BasicBlock>, Value*> OverDefinedPairTy;
429 
431  for (const OverDefinedPairTy &P : Parent->OverDefinedCache)
432  if (P.second == getValPtr())
433  ToErase.push_back(P);
434  for (const OverDefinedPairTy &P : ToErase)
435  Parent->OverDefinedCache.erase(P);
436 
437  // This erasure deallocates *this, so it MUST happen after we're done
438  // using any and all members of *this.
439  Parent->ValueCache.erase(*this);
440 }
441 
442 void LazyValueInfoCache::eraseBlock(BasicBlock *BB) {
443  // Shortcut if we have never seen this block.
444  DenseSet<AssertingVH<BasicBlock> >::iterator I = SeenBlocks.find(BB);
445  if (I == SeenBlocks.end())
446  return;
447  SeenBlocks.erase(I);
448 
450  for (const OverDefinedPairTy& P : OverDefinedCache)
451  if (P.first == BB)
452  ToErase.push_back(P);
453  for (const OverDefinedPairTy &P : ToErase)
454  OverDefinedCache.erase(P);
455 
456  for (std::map<LVIValueHandle, ValueCacheEntryTy>::iterator
457  I = ValueCache.begin(), E = ValueCache.end(); I != E; ++I)
458  I->second.erase(BB);
459 }
460 
462  while (!BlockValueStack.empty()) {
463  std::pair<BasicBlock*, Value*> &e = BlockValueStack.top();
464  assert(BlockValueSet.count(e) && "Stack value should be in BlockValueSet!");
465 
466  if (solveBlockValue(e.second, e.first)) {
467  // The work item was completely processed.
468  assert(BlockValueStack.top() == e && "Nothing should have been pushed!");
469  assert(lookup(e.second).count(e.first) && "Result should be in cache!");
470 
471  BlockValueStack.pop();
472  BlockValueSet.erase(e);
473  } else {
474  // More work needs to be done before revisiting.
475  assert(BlockValueStack.top() != e && "Stack should have been pushed!");
476  }
477  }
478 }
479 
480 bool LazyValueInfoCache::hasBlockValue(Value *Val, BasicBlock *BB) {
481  // If already a constant, there is nothing to compute.
482  if (isa<Constant>(Val))
483  return true;
484 
485  LVIValueHandle ValHandle(Val, this);
486  std::map<LVIValueHandle, ValueCacheEntryTy>::iterator I =
487  ValueCache.find(ValHandle);
488  if (I == ValueCache.end()) return false;
489  return I->second.count(BB);
490 }
491 
492 LVILatticeVal LazyValueInfoCache::getBlockValue(Value *Val, BasicBlock *BB) {
493  // If already a constant, there is nothing to compute.
494  if (Constant *VC = dyn_cast<Constant>(Val))
495  return LVILatticeVal::get(VC);
496 
497  SeenBlocks.insert(BB);
498  return lookup(Val)[BB];
499 }
500 
501 bool LazyValueInfoCache::solveBlockValue(Value *Val, BasicBlock *BB) {
502  if (isa<Constant>(Val))
503  return true;
504 
505  if (lookup(Val).count(BB)) {
506  // If we have a cached value, use that.
507  DEBUG(dbgs() << " reuse BB '" << BB->getName()
508  << "' val=" << lookup(Val)[BB] << '\n');
509 
510  // Since we're reusing a cached value, we don't need to update the
511  // OverDefinedCache. The cache will have been properly updated whenever the
512  // cached value was inserted.
513  return true;
514  }
515 
516  // Hold off inserting this value into the Cache in case we have to return
517  // false and come back later.
518  LVILatticeVal Res;
519 
520  Instruction *BBI = dyn_cast<Instruction>(Val);
521  if (!BBI || BBI->getParent() != BB) {
522  if (!solveBlockValueNonLocal(Res, Val, BB))
523  return false;
524  insertResult(Val, BB, Res);
525  return true;
526  }
527 
528  if (PHINode *PN = dyn_cast<PHINode>(BBI)) {
529  if (!solveBlockValuePHINode(Res, PN, BB))
530  return false;
531  insertResult(Val, BB, Res);
532  return true;
533  }
534 
535  if (AllocaInst *AI = dyn_cast<AllocaInst>(BBI)) {
536  Res = LVILatticeVal::getNot(ConstantPointerNull::get(AI->getType()));
537  insertResult(Val, BB, Res);
538  return true;
539  }
540 
541  // We can only analyze the definitions of certain classes of instructions
542  // (integral binops and casts at the moment), so bail if this isn't one.
543  LVILatticeVal Result;
544  if ((!isa<BinaryOperator>(BBI) && !isa<CastInst>(BBI)) ||
545  !BBI->getType()->isIntegerTy()) {
546  DEBUG(dbgs() << " compute BB '" << BB->getName()
547  << "' - overdefined because inst def found.\n");
548  Res.markOverdefined();
549  insertResult(Val, BB, Res);
550  return true;
551  }
552 
553  // FIXME: We're currently limited to binops with a constant RHS. This should
554  // be improved.
556  if (BO && !isa<ConstantInt>(BO->getOperand(1))) {
557  DEBUG(dbgs() << " compute BB '" << BB->getName()
558  << "' - overdefined because inst def found.\n");
559 
560  Res.markOverdefined();
561  insertResult(Val, BB, Res);
562  return true;
563  }
564 
565  if (!solveBlockValueConstantRange(Res, BBI, BB))
566  return false;
567  insertResult(Val, BB, Res);
568  return true;
569 }
570 
572  if (LoadInst *L = dyn_cast<LoadInst>(I)) {
573  return L->getPointerAddressSpace() == 0 &&
574  GetUnderlyingObject(L->getPointerOperand(),
575  L->getModule()->getDataLayout()) == Ptr;
576  }
577  if (StoreInst *S = dyn_cast<StoreInst>(I)) {
578  return S->getPointerAddressSpace() == 0 &&
579  GetUnderlyingObject(S->getPointerOperand(),
580  S->getModule()->getDataLayout()) == Ptr;
581  }
582  if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
583  if (MI->isVolatile()) return false;
584 
585  // FIXME: check whether it has a valuerange that excludes zero?
586  ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
587  if (!Len || Len->isZero()) return false;
588 
589  if (MI->getDestAddressSpace() == 0)
590  if (GetUnderlyingObject(MI->getRawDest(),
591  MI->getModule()->getDataLayout()) == Ptr)
592  return true;
593  if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
594  if (MTI->getSourceAddressSpace() == 0)
595  if (GetUnderlyingObject(MTI->getRawSource(),
596  MTI->getModule()->getDataLayout()) == Ptr)
597  return true;
598  }
599  return false;
600 }
601 
602 bool LazyValueInfoCache::solveBlockValueNonLocal(LVILatticeVal &BBLV,
603  Value *Val, BasicBlock *BB) {
604  LVILatticeVal Result; // Start Undefined.
605 
606  // If this is a pointer, and there's a load from that pointer in this BB,
607  // then we know that the pointer can't be NULL.
608  bool NotNull = false;
609  if (Val->getType()->isPointerTy()) {
610  if (isKnownNonNull(Val)) {
611  NotNull = true;
612  } else {
613  const DataLayout &DL = BB->getModule()->getDataLayout();
614  Value *UnderlyingVal = GetUnderlyingObject(Val, DL);
615  // If 'GetUnderlyingObject' didn't converge, skip it. It won't converge
616  // inside InstructionDereferencesPointer either.
617  if (UnderlyingVal == GetUnderlyingObject(UnderlyingVal, DL, 1)) {
618  for (Instruction &I : *BB) {
619  if (InstructionDereferencesPointer(&I, UnderlyingVal)) {
620  NotNull = true;
621  break;
622  }
623  }
624  }
625  }
626  }
627 
628  // If this is the entry block, we must be asking about an argument. The
629  // value is overdefined.
630  if (BB == &BB->getParent()->getEntryBlock()) {
631  assert(isa<Argument>(Val) && "Unknown live-in to the entry block");
632  if (NotNull) {
633  PointerType *PTy = cast<PointerType>(Val->getType());
634  Result = LVILatticeVal::getNot(ConstantPointerNull::get(PTy));
635  } else {
636  Result.markOverdefined();
637  }
638  BBLV = Result;
639  return true;
640  }
641 
642  // Loop over all of our predecessors, merging what we know from them into
643  // result.
644  bool EdgesMissing = false;
645  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
646  LVILatticeVal EdgeResult;
647  EdgesMissing |= !getEdgeValue(Val, *PI, BB, EdgeResult);
648  if (EdgesMissing)
649  continue;
650 
651  Result.mergeIn(EdgeResult, DL);
652 
653  // If we hit overdefined, exit early. The BlockVals entry is already set
654  // to overdefined.
655  if (Result.isOverdefined()) {
656  DEBUG(dbgs() << " compute BB '" << BB->getName()
657  << "' - overdefined because of pred.\n");
658  // If we previously determined that this is a pointer that can't be null
659  // then return that rather than giving up entirely.
660  if (NotNull) {
661  PointerType *PTy = cast<PointerType>(Val->getType());
662  Result = LVILatticeVal::getNot(ConstantPointerNull::get(PTy));
663  }
664 
665  BBLV = Result;
666  return true;
667  }
668  }
669  if (EdgesMissing)
670  return false;
671 
672  // Return the merged value, which is more precise than 'overdefined'.
673  assert(!Result.isOverdefined());
674  BBLV = Result;
675  return true;
676 }
677 
678 bool LazyValueInfoCache::solveBlockValuePHINode(LVILatticeVal &BBLV,
679  PHINode *PN, BasicBlock *BB) {
680  LVILatticeVal Result; // Start Undefined.
681 
682  // Loop over all of our predecessors, merging what we know from them into
683  // result.
684  bool EdgesMissing = false;
685  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
686  BasicBlock *PhiBB = PN->getIncomingBlock(i);
687  Value *PhiVal = PN->getIncomingValue(i);
688  LVILatticeVal EdgeResult;
689  // Note that we can provide PN as the context value to getEdgeValue, even
690  // though the results will be cached, because PN is the value being used as
691  // the cache key in the caller.
692  EdgesMissing |= !getEdgeValue(PhiVal, PhiBB, BB, EdgeResult, PN);
693  if (EdgesMissing)
694  continue;
695 
696  Result.mergeIn(EdgeResult, DL);
697 
698  // If we hit overdefined, exit early. The BlockVals entry is already set
699  // to overdefined.
700  if (Result.isOverdefined()) {
701  DEBUG(dbgs() << " compute BB '" << BB->getName()
702  << "' - overdefined because of pred.\n");
703 
704  BBLV = Result;
705  return true;
706  }
707  }
708  if (EdgesMissing)
709  return false;
710 
711  // Return the merged value, which is more precise than 'overdefined'.
712  assert(!Result.isOverdefined() && "Possible PHI in entry block?");
713  BBLV = Result;
714  return true;
715 }
716 
717 static bool getValueFromFromCondition(Value *Val, ICmpInst *ICI,
718  LVILatticeVal &Result,
719  bool isTrueDest = true);
720 
721 // If we can determine a constant range for the value Val in the context
722 // provided by the instruction BBI, then merge it into BBLV. If we did find a
723 // constant range, return true.
724 void LazyValueInfoCache::mergeAssumeBlockValueConstantRange(Value *Val,
725  LVILatticeVal &BBLV,
726  Instruction *BBI) {
727  BBI = BBI ? BBI : dyn_cast<Instruction>(Val);
728  if (!BBI)
729  return;
730 
731  for (auto &AssumeVH : AC->assumptions()) {
732  if (!AssumeVH)
733  continue;
734  auto *I = cast<CallInst>(AssumeVH);
735  if (!isValidAssumeForContext(I, BBI, DT))
736  continue;
737 
738  Value *C = I->getArgOperand(0);
739  if (ICmpInst *ICI = dyn_cast<ICmpInst>(C)) {
740  LVILatticeVal Result;
741  if (getValueFromFromCondition(Val, ICI, Result)) {
742  if (BBLV.isOverdefined())
743  BBLV = Result;
744  else
745  BBLV.mergeIn(Result, DL);
746  }
747  }
748  }
749 }
750 
751 bool LazyValueInfoCache::solveBlockValueConstantRange(LVILatticeVal &BBLV,
752  Instruction *BBI,
753  BasicBlock *BB) {
754  // Figure out the range of the LHS. If that fails, bail.
755  if (!hasBlockValue(BBI->getOperand(0), BB)) {
756  if (pushBlockValue(std::make_pair(BB, BBI->getOperand(0))))
757  return false;
758  BBLV.markOverdefined();
759  return true;
760  }
761 
762  LVILatticeVal LHSVal = getBlockValue(BBI->getOperand(0), BB);
763  mergeAssumeBlockValueConstantRange(BBI->getOperand(0), LHSVal, BBI);
764  if (!LHSVal.isConstantRange()) {
765  BBLV.markOverdefined();
766  return true;
767  }
768 
769  ConstantRange LHSRange = LHSVal.getConstantRange();
770  ConstantRange RHSRange(1);
771  IntegerType *ResultTy = cast<IntegerType>(BBI->getType());
772  if (isa<BinaryOperator>(BBI)) {
773  if (ConstantInt *RHS = dyn_cast<ConstantInt>(BBI->getOperand(1))) {
774  RHSRange = ConstantRange(RHS->getValue());
775  } else {
776  BBLV.markOverdefined();
777  return true;
778  }
779  }
780 
781  // NOTE: We're currently limited by the set of operations that ConstantRange
782  // can evaluate symbolically. Enhancing that set will allows us to analyze
783  // more definitions.
784  LVILatticeVal Result;
785  switch (BBI->getOpcode()) {
786  case Instruction::Add:
787  Result.markConstantRange(LHSRange.add(RHSRange));
788  break;
789  case Instruction::Sub:
790  Result.markConstantRange(LHSRange.sub(RHSRange));
791  break;
792  case Instruction::Mul:
793  Result.markConstantRange(LHSRange.multiply(RHSRange));
794  break;
795  case Instruction::UDiv:
796  Result.markConstantRange(LHSRange.udiv(RHSRange));
797  break;
798  case Instruction::Shl:
799  Result.markConstantRange(LHSRange.shl(RHSRange));
800  break;
801  case Instruction::LShr:
802  Result.markConstantRange(LHSRange.lshr(RHSRange));
803  break;
804  case Instruction::Trunc:
805  Result.markConstantRange(LHSRange.truncate(ResultTy->getBitWidth()));
806  break;
807  case Instruction::SExt:
808  Result.markConstantRange(LHSRange.signExtend(ResultTy->getBitWidth()));
809  break;
810  case Instruction::ZExt:
811  Result.markConstantRange(LHSRange.zeroExtend(ResultTy->getBitWidth()));
812  break;
813  case Instruction::BitCast:
814  Result.markConstantRange(LHSRange);
815  break;
816  case Instruction::And:
817  Result.markConstantRange(LHSRange.binaryAnd(RHSRange));
818  break;
819  case Instruction::Or:
820  Result.markConstantRange(LHSRange.binaryOr(RHSRange));
821  break;
822 
823  // Unhandled instructions are overdefined.
824  default:
825  DEBUG(dbgs() << " compute BB '" << BB->getName()
826  << "' - overdefined because inst def found.\n");
827  Result.markOverdefined();
828  break;
829  }
830 
831  BBLV = Result;
832  return true;
833 }
834 
836  LVILatticeVal &Result, bool isTrueDest) {
837  if (ICI && isa<Constant>(ICI->getOperand(1))) {
838  if (ICI->isEquality() && ICI->getOperand(0) == Val) {
839  // We know that V has the RHS constant if this is a true SETEQ or
840  // false SETNE.
841  if (isTrueDest == (ICI->getPredicate() == ICmpInst::ICMP_EQ))
842  Result = LVILatticeVal::get(cast<Constant>(ICI->getOperand(1)));
843  else
844  Result = LVILatticeVal::getNot(cast<Constant>(ICI->getOperand(1)));
845  return true;
846  }
847 
848  // Recognize the range checking idiom that InstCombine produces.
849  // (X-C1) u< C2 --> [C1, C1+C2)
850  ConstantInt *NegOffset = nullptr;
851  if (ICI->getPredicate() == ICmpInst::ICMP_ULT)
852  match(ICI->getOperand(0), m_Add(m_Specific(Val),
853  m_ConstantInt(NegOffset)));
854 
855  ConstantInt *CI = dyn_cast<ConstantInt>(ICI->getOperand(1));
856  if (CI && (ICI->getOperand(0) == Val || NegOffset)) {
857  // Calculate the range of values that are allowed by the comparison
858  ConstantRange CmpRange(CI->getValue());
859  ConstantRange TrueValues =
861 
862  if (NegOffset) // Apply the offset from above.
863  TrueValues = TrueValues.subtract(NegOffset->getValue());
864 
865  // If we're interested in the false dest, invert the condition.
866  if (!isTrueDest) TrueValues = TrueValues.inverse();
867 
868  Result = LVILatticeVal::getRange(TrueValues);
869  return true;
870  }
871  }
872 
873  return false;
874 }
875 
876 /// \brief Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
877 /// Val is not constrained on the edge.
878 static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom,
879  BasicBlock *BBTo, LVILatticeVal &Result) {
880  // TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
881  // know that v != 0.
882  if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
883  // If this is a conditional branch and only one successor goes to BBTo, then
884  // we may be able to infer something from the condition.
885  if (BI->isConditional() &&
886  BI->getSuccessor(0) != BI->getSuccessor(1)) {
887  bool isTrueDest = BI->getSuccessor(0) == BBTo;
888  assert(BI->getSuccessor(!isTrueDest) == BBTo &&
889  "BBTo isn't a successor of BBFrom");
890 
891  // If V is the condition of the branch itself, then we know exactly what
892  // it is.
893  if (BI->getCondition() == Val) {
894  Result = LVILatticeVal::get(ConstantInt::get(
895  Type::getInt1Ty(Val->getContext()), isTrueDest));
896  return true;
897  }
898 
899  // If the condition of the branch is an equality comparison, we may be
900  // able to infer the value.
901  if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition()))
902  if (getValueFromFromCondition(Val, ICI, Result, isTrueDest))
903  return true;
904  }
905  }
906 
907  // If the edge was formed by a switch on the value, then we may know exactly
908  // what it is.
909  if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
910  if (SI->getCondition() != Val)
911  return false;
912 
913  bool DefaultCase = SI->getDefaultDest() == BBTo;
914  unsigned BitWidth = Val->getType()->getIntegerBitWidth();
915  ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);
916 
917  for (SwitchInst::CaseIt i : SI->cases()) {
918  ConstantRange EdgeVal(i.getCaseValue()->getValue());
919  if (DefaultCase) {
920  // It is possible that the default destination is the destination of
921  // some cases. There is no need to perform difference for those cases.
922  if (i.getCaseSuccessor() != BBTo)
923  EdgesVals = EdgesVals.difference(EdgeVal);
924  } else if (i.getCaseSuccessor() == BBTo)
925  EdgesVals = EdgesVals.unionWith(EdgeVal);
926  }
927  Result = LVILatticeVal::getRange(EdgesVals);
928  return true;
929  }
930  return false;
931 }
932 
933 /// \brief Compute the value of Val on the edge BBFrom -> BBTo or the value at
934 /// the basic block if the edge does not constrain Val.
935 bool LazyValueInfoCache::getEdgeValue(Value *Val, BasicBlock *BBFrom,
936  BasicBlock *BBTo, LVILatticeVal &Result,
937  Instruction *CxtI) {
938  // If already a constant, there is nothing to compute.
939  if (Constant *VC = dyn_cast<Constant>(Val)) {
940  Result = LVILatticeVal::get(VC);
941  return true;
942  }
943 
944  if (getEdgeValueLocal(Val, BBFrom, BBTo, Result)) {
945  if (!Result.isConstantRange() ||
946  Result.getConstantRange().getSingleElement())
947  return true;
948 
949  // FIXME: this check should be moved to the beginning of the function when
950  // LVI better supports recursive values. Even for the single value case, we
951  // can intersect to detect dead code (an empty range).
952  if (!hasBlockValue(Val, BBFrom)) {
953  if (pushBlockValue(std::make_pair(BBFrom, Val)))
954  return false;
955  Result.markOverdefined();
956  return true;
957  }
958 
959  // Try to intersect ranges of the BB and the constraint on the edge.
960  LVILatticeVal InBlock = getBlockValue(Val, BBFrom);
961  mergeAssumeBlockValueConstantRange(Val, InBlock, BBFrom->getTerminator());
962  // See note on the use of the CxtI with mergeAssumeBlockValueConstantRange,
963  // and caching, below.
964  mergeAssumeBlockValueConstantRange(Val, InBlock, CxtI);
965  if (!InBlock.isConstantRange())
966  return true;
967 
968  ConstantRange Range =
969  Result.getConstantRange().intersectWith(InBlock.getConstantRange());
970  Result = LVILatticeVal::getRange(Range);
971  return true;
972  }
973 
974  if (!hasBlockValue(Val, BBFrom)) {
975  if (pushBlockValue(std::make_pair(BBFrom, Val)))
976  return false;
977  Result.markOverdefined();
978  return true;
979  }
980 
981  // If we couldn't compute the value on the edge, use the value from the BB.
982  Result = getBlockValue(Val, BBFrom);
983  mergeAssumeBlockValueConstantRange(Val, Result, BBFrom->getTerminator());
984  // We can use the context instruction (generically the ultimate instruction
985  // the calling pass is trying to simplify) here, even though the result of
986  // this function is generally cached when called from the solve* functions
987  // (and that cached result might be used with queries using a different
988  // context instruction), because when this function is called from the solve*
989  // functions, the context instruction is not provided. When called from
990  // LazyValueInfoCache::getValueOnEdge, the context instruction is provided,
991  // but then the result is not cached.
992  mergeAssumeBlockValueConstantRange(Val, Result, CxtI);
993  return true;
994 }
995 
996 LVILatticeVal LazyValueInfoCache::getValueInBlock(Value *V, BasicBlock *BB,
997  Instruction *CxtI) {
998  DEBUG(dbgs() << "LVI Getting block end value " << *V << " at '"
999  << BB->getName() << "'\n");
1000 
1001  assert(BlockValueStack.empty() && BlockValueSet.empty());
1002  pushBlockValue(std::make_pair(BB, V));
1003 
1004  solve();
1005  LVILatticeVal Result = getBlockValue(V, BB);
1006  mergeAssumeBlockValueConstantRange(V, Result, CxtI);
1007 
1008  DEBUG(dbgs() << " Result = " << Result << "\n");
1009  return Result;
1010 }
1011 
1012 LVILatticeVal LazyValueInfoCache::getValueAt(Value *V, Instruction *CxtI) {
1013  DEBUG(dbgs() << "LVI Getting value " << *V << " at '"
1014  << CxtI->getName() << "'\n");
1015 
1016  LVILatticeVal Result;
1017  mergeAssumeBlockValueConstantRange(V, Result, CxtI);
1018 
1019  DEBUG(dbgs() << " Result = " << Result << "\n");
1020  return Result;
1021 }
1022 
1023 LVILatticeVal LazyValueInfoCache::
1024 getValueOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
1025  Instruction *CxtI) {
1026  DEBUG(dbgs() << "LVI Getting edge value " << *V << " from '"
1027  << FromBB->getName() << "' to '" << ToBB->getName() << "'\n");
1028 
1029  LVILatticeVal Result;
1030  if (!getEdgeValue(V, FromBB, ToBB, Result, CxtI)) {
1031  solve();
1032  bool WasFastQuery = getEdgeValue(V, FromBB, ToBB, Result, CxtI);
1033  (void)WasFastQuery;
1034  assert(WasFastQuery && "More work to do after problem solved?");
1035  }
1036 
1037  DEBUG(dbgs() << " Result = " << Result << "\n");
1038  return Result;
1039 }
1040 
1041 void LazyValueInfoCache::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
1042  BasicBlock *NewSucc) {
1043  // When an edge in the graph has been threaded, values that we could not
1044  // determine a value for before (i.e. were marked overdefined) may be possible
1045  // to solve now. We do NOT try to proactively update these values. Instead,
1046  // we clear their entries from the cache, and allow lazy updating to recompute
1047  // them when needed.
1048 
1049  // The updating process is fairly simple: we need to drop cached info
1050  // for all values that were marked overdefined in OldSucc, and for those same
1051  // values in any successor of OldSucc (except NewSucc) in which they were
1052  // also marked overdefined.
1053  std::vector<BasicBlock*> worklist;
1054  worklist.push_back(OldSucc);
1055 
1056  DenseSet<Value*> ClearSet;
1057  for (OverDefinedPairTy &P : OverDefinedCache)
1058  if (P.first == OldSucc)
1059  ClearSet.insert(P.second);
1060 
1061  // Use a worklist to perform a depth-first search of OldSucc's successors.
1062  // NOTE: We do not need a visited list since any blocks we have already
1063  // visited will have had their overdefined markers cleared already, and we
1064  // thus won't loop to their successors.
1065  while (!worklist.empty()) {
1066  BasicBlock *ToUpdate = worklist.back();
1067  worklist.pop_back();
1068 
1069  // Skip blocks only accessible through NewSucc.
1070  if (ToUpdate == NewSucc) continue;
1071 
1072  bool changed = false;
1073  for (Value *V : ClearSet) {
1074  // If a value was marked overdefined in OldSucc, and is here too...
1076  OverDefinedCache.find(std::make_pair(ToUpdate, V));
1077  if (OI == OverDefinedCache.end()) continue;
1078 
1079  // Remove it from the caches.
1080  ValueCacheEntryTy &Entry = ValueCache[LVIValueHandle(V, this)];
1081  ValueCacheEntryTy::iterator CI = Entry.find(ToUpdate);
1082 
1083  assert(CI != Entry.end() && "Couldn't find entry to update?");
1084  Entry.erase(CI);
1085  OverDefinedCache.erase(OI);
1086 
1087  // If we removed anything, then we potentially need to update
1088  // blocks successors too.
1089  changed = true;
1090  }
1091 
1092  if (!changed) continue;
1093 
1094  worklist.insert(worklist.end(), succ_begin(ToUpdate), succ_end(ToUpdate));
1095  }
1096 }
1097 
1098 //===----------------------------------------------------------------------===//
1099 // LazyValueInfo Impl
1100 //===----------------------------------------------------------------------===//
1101 
1102 /// This lazily constructs the LazyValueInfoCache.
1103 static LazyValueInfoCache &getCache(void *&PImpl, AssumptionCache *AC,
1104  const DataLayout *DL,
1105  DominatorTree *DT = nullptr) {
1106  if (!PImpl) {
1107  assert(DL && "getCache() called with a null DataLayout");
1108  PImpl = new LazyValueInfoCache(AC, *DL, DT);
1109  }
1110  return *static_cast<LazyValueInfoCache*>(PImpl);
1111 }
1112 
1114  AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
1115  const DataLayout &DL = F.getParent()->getDataLayout();
1116 
1117  DominatorTreeWrapperPass *DTWP =
1118  getAnalysisIfAvailable<DominatorTreeWrapperPass>();
1119  DT = DTWP ? &DTWP->getDomTree() : nullptr;
1120 
1121  TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
1122 
1123  if (PImpl)
1124  getCache(PImpl, AC, &DL, DT).clear();
1125 
1126  // Fully lazy.
1127  return false;
1128 }
1129 
1131  AU.setPreservesAll();
1134 }
1135 
1137  // If the cache was allocated, free it.
1138  if (PImpl) {
1139  delete &getCache(PImpl, AC, nullptr);
1140  PImpl = nullptr;
1141  }
1142 }
1143 
1145  Instruction *CxtI) {
1146  const DataLayout &DL = BB->getModule()->getDataLayout();
1147  LVILatticeVal Result =
1148  getCache(PImpl, AC, &DL, DT).getValueInBlock(V, BB, CxtI);
1149 
1150  if (Result.isConstant())
1151  return Result.getConstant();
1152  if (Result.isConstantRange()) {
1153  ConstantRange CR = Result.getConstantRange();
1154  if (const APInt *SingleVal = CR.getSingleElement())
1155  return ConstantInt::get(V->getContext(), *SingleVal);
1156  }
1157  return nullptr;
1158 }
1159 
1160 /// Determine whether the specified value is known to be a
1161 /// constant on the specified edge. Return null if not.
1163  BasicBlock *ToBB,
1164  Instruction *CxtI) {
1165  const DataLayout &DL = FromBB->getModule()->getDataLayout();
1166  LVILatticeVal Result =
1167  getCache(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
1168 
1169  if (Result.isConstant())
1170  return Result.getConstant();
1171  if (Result.isConstantRange()) {
1172  ConstantRange CR = Result.getConstantRange();
1173  if (const APInt *SingleVal = CR.getSingleElement())
1174  return ConstantInt::get(V->getContext(), *SingleVal);
1175  }
1176  return nullptr;
1177 }
1178 
1180  LVILatticeVal &Result,
1181  const DataLayout &DL,
1182  TargetLibraryInfo *TLI) {
1183 
1184  // If we know the value is a constant, evaluate the conditional.
1185  Constant *Res = nullptr;
1186  if (Result.isConstant()) {
1187  Res = ConstantFoldCompareInstOperands(Pred, Result.getConstant(), C, DL,
1188  TLI);
1189  if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
1190  return ResCI->isZero() ? LazyValueInfo::False : LazyValueInfo::True;
1191  return LazyValueInfo::Unknown;
1192  }
1193 
1194  if (Result.isConstantRange()) {
1196  if (!CI) return LazyValueInfo::Unknown;
1197 
1198  ConstantRange CR = Result.getConstantRange();
1199  if (Pred == ICmpInst::ICMP_EQ) {
1200  if (!CR.contains(CI->getValue()))
1201  return LazyValueInfo::False;
1202 
1203  if (CR.isSingleElement() && CR.contains(CI->getValue()))
1204  return LazyValueInfo::True;
1205  } else if (Pred == ICmpInst::ICMP_NE) {
1206  if (!CR.contains(CI->getValue()))
1207  return LazyValueInfo::True;
1208 
1209  if (CR.isSingleElement() && CR.contains(CI->getValue()))
1210  return LazyValueInfo::False;
1211  }
1212 
1213  // Handle more complex predicates.
1214  ConstantRange TrueValues =
1216  if (TrueValues.contains(CR))
1217  return LazyValueInfo::True;
1218  if (TrueValues.inverse().contains(CR))
1219  return LazyValueInfo::False;
1220  return LazyValueInfo::Unknown;
1221  }
1222 
1223  if (Result.isNotConstant()) {
1224  // If this is an equality comparison, we can try to fold it knowing that
1225  // "V != C1".
1226  if (Pred == ICmpInst::ICMP_EQ) {
1227  // !C1 == C -> false iff C1 == C.
1229  Result.getNotConstant(), C, DL,
1230  TLI);
1231  if (Res->isNullValue())
1232  return LazyValueInfo::False;
1233  } else if (Pred == ICmpInst::ICMP_NE) {
1234  // !C1 != C -> true iff C1 == C.
1236  Result.getNotConstant(), C, DL,
1237  TLI);
1238  if (Res->isNullValue())
1239  return LazyValueInfo::True;
1240  }
1241  return LazyValueInfo::Unknown;
1242  }
1243 
1244  return LazyValueInfo::Unknown;
1245 }
1246 
1247 /// Determine whether the specified value comparison with a constant is known to
1248 /// be true or false on the specified CFG edge. Pred is a CmpInst predicate.
1251  BasicBlock *FromBB, BasicBlock *ToBB,
1252  Instruction *CxtI) {
1253  const DataLayout &DL = FromBB->getModule()->getDataLayout();
1254  LVILatticeVal Result =
1255  getCache(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
1256 
1257  return getPredicateResult(Pred, C, Result, DL, TLI);
1258 }
1259 
1262  Instruction *CxtI) {
1263  const DataLayout &DL = CxtI->getModule()->getDataLayout();
1264  LVILatticeVal Result = getCache(PImpl, AC, &DL, DT).getValueAt(V, CxtI);
1265  Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
1266  if (Ret != Unknown)
1267  return Ret;
1268 
1269  // TODO: Move this logic inside getValueAt so that it can be cached rather
1270  // than re-queried on each call. This would also allow us to merge the
1271  // underlying lattice values to get more information
1272  if (CxtI) {
1273  // For a comparison where the V is outside this block, it's possible
1274  // that we've branched on it before. Look to see if the value is known
1275  // on all incoming edges.
1276  BasicBlock *BB = CxtI->getParent();
1277  pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
1278  if (PI != PE &&
1279  (!isa<Instruction>(V) ||
1280  cast<Instruction>(V)->getParent() != BB)) {
1281  // For predecessor edge, determine if the comparison is true or false
1282  // on that edge. If they're all true or all false, we can conclude
1283  // the value of the comparison in this block.
1284  Tristate Baseline = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
1285  if (Baseline != Unknown) {
1286  // Check that all remaining incoming values match the first one.
1287  while (++PI != PE) {
1288  Tristate Ret = getPredicateOnEdge(Pred, V, C, *PI, BB, CxtI);
1289  if (Ret != Baseline) break;
1290  }
1291  // If we terminated early, then one of the values didn't match.
1292  if (PI == PE) {
1293  return Baseline;
1294  }
1295  }
1296  }
1297  }
1298  return Unknown;
1299 }
1300 
1302  BasicBlock *NewSucc) {
1303  if (PImpl) {
1304  const DataLayout &DL = PredBB->getModule()->getDataLayout();
1305  getCache(PImpl, AC, &DL, DT).threadEdge(PredBB, OldSucc, NewSucc);
1306  }
1307 }
1308 
1310  if (PImpl) {
1311  const DataLayout &DL = BB->getModule()->getDataLayout();
1312  getCache(PImpl, AC, &DL, DT).eraseBlock(BB);
1313  }
1314 }
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static bool InstructionDereferencesPointer(Instruction *I, Value *Ptr)
static IntegerType * getInt1Ty(LLVMContext &C)
Definition: Type.cpp:236
const Instruction & back() const
Definition: BasicBlock.h:245
const APInt * getSingleElement() const
If this set contains a single element, return it, otherwise return null.
DenseSet - This implements a dense probed hash-table based set.
Definition: DenseSet.h:39
An immutable pass that tracks lazily created AssumptionCache objects.
unsigned less than
Definition: InstrTypes.h:722
A cache of .assume calls within a function.
static bool isEquality(Predicate P)
isEquality - Return true if this predicate is either EQ or NE.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr)
Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control-flow identified by the context instruction, CxtI.
bool isSingleElement() const
Return true if this set contains exactly one member.
F(f)
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:61
static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the smallest range such that all values that may satisfy the given predicate with any value c...
static LazyValueInfo::Tristate getPredicateResult(unsigned Pred, Constant *C, LVILatticeVal &Result, const DataLayout &DL, TargetLibraryInfo *TLI)
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
lazy value info
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:70
Constant * getConstant(Value *V, BasicBlock *BB, Instruction *CxtI=nullptr)
Determine whether the specified value is known to be a constant at the end of the specified block...
ConstantRange truncate(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly smaller than the current typ...
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
bool erase(const ValueT &V)
Definition: DenseSet.h:69
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:75
lazy value Lazy Value Information Analysis
DominatorTree & getDomTree()
Definition: Dominators.h:213
ConstantRange signExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
ConstantRange multiply(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a multiplication of a value in thi...
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:434
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:104
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom, BasicBlock *BBTo, LVILatticeVal &Result)
Compute the value of Val on the edge BBFrom -> BBTo.
ConstantRange unionWith(const ConstantRange &CR) const
Return the range that results from the union of this range with another range.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
void releaseMemory() override
releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memo...
ConstantRange subtract(const APInt &CI) const
Subtract the specified constant from the endpoints of this constant range.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
FunctionPass * createLazyValueInfoPass()
createLazyValueInfoPass - This creates an instance of the LazyValueInfo pass.
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:107
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
static bool getValueFromFromCondition(Value *Val, ICmpInst *ICI, LVILatticeVal &Result, bool isTrueDest=true)
#define P(N)
#define true
Definition: ConvertUTF.c:66
static ConstantPointerNull * get(PointerType *T)
get() - Static factory methods - Return objects of the specified value
Definition: Constants.cpp:1455
iterator find(const ValueT &V)
Definition: DenseSet.h:128
Constant * getConstantOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value is known to be a constant on the specified edge.
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type. ...
ConstantRange lshr(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a logical right shift of a value i...
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
BranchInst - Conditional or Unconditional Branch instruction.
This is an important base class in LLVM.
Definition: Constant.h:41
This file contains the declarations for the subclasses of Constant, which represent the different fla...
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:114
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:322
Represent the analysis usage information of a pass.
ConstantRange udiv(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an unsigned division of a value in...
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
This instruction compares its operands according to the predicate given to the constructor.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:294
Value * getOperand(unsigned i) const
Definition: User.h:118
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:117
ConstantRange sub(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a subtraction of a value in this r...
Class to represent integer types.
Definition: DerivedTypes.h:37
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
ConstantRange zeroExtend(uint32_t BitWidth) const
Return a new range in the specified integer type, which must be strictly larger than the current type...
bool isEmptySet() const
Return true if this set contains no members.
ConstantRange difference(const ConstantRange &CR) const
Subtract the specified range from this range (aka relative complement of the sets).
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCompareInstOperands - Attempt to constant fold a compare instruction (icmp/fcmp) with the...
ConstantRange add(const ConstantRange &Other) const
Return a new range representing the possible values resulting from an addition of a value in this ran...
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
GetUnderlyingObject - This method strips off any GEP address adjustments and pointer casts from the s...
static LazyValueInfoCache & getCache(void *&PImpl, AssumptionCache *AC, const DataLayout *DL, DominatorTree *DT=nullptr)
This lazily constructs the LazyValueInfoCache.
Tristate
This is used to return true/false/dunno results.
Definition: LazyValueInfo.h:45
Tristate getPredicateOnEdge(unsigned Pred, Value *V, Constant *C, BasicBlock *FromBB, BasicBlock *ToBB, Instruction *CxtI=nullptr)
Determine whether the specified value comparison with a constant is known to be true or false on the ...
iterator begin()
Definition: DenseSet.h:122
Tristate getPredicateAt(unsigned Pred, Value *V, Constant *C, Instruction *CxtI)
Determine whether the specified value comparison with a constant is known to be true or false at the ...
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:147
MemIntrinsic - This is the common base class for memset/memcpy/memmove.
unsigned getIntegerBitWidth() const
Definition: Type.cpp:176
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
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
ConstantRange inverse() const
Return a new range that is the logical not of the current set.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
This class represents a range of values.
Definition: ConstantRange.h:43
INITIALIZE_PASS_BEGIN(LazyValueInfo,"lazy-value-info","Lazy Value Information Analysis", false, true) INITIALIZE_PASS_END(LazyValueInfo
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
Natural Loop Information
Definition: LoopInfo.cpp:696
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:161
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
bool isNullValue() const
isNullValue - Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:75
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
ConstantRange binaryOr(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a binary-or of a value in this ran...
Class for arbitrary precision integers.
Definition: APInt.h:73
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
void setPreservesAll()
Set by analyses that do not transform their input at all.
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
bool isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI=nullptr)
isKnownNonNull - Return true if this pointer couldn't possibly be null by its definition.
ConstantRange shl(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a left shift of a value in this ra...
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
static const uint16_t * lookup(unsigned opcode, unsigned domain)
MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
void threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, BasicBlock *NewSucc)
Inform the analysis cache that we have threaded an edge from PredBB to OldSucc to be from PredBB to N...
#define I(x, y, z)
Definition: MD5.cpp:54
ConstantRange binaryAnd(const ConstantRange &Other) const
Return a new range representing the possible values resulting from a binary-and of a value in this ra...
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 ConstantRange makeConstantRange(Predicate pred, const APInt &C)
Initialize a set of values that all satisfy the predicate with C.
Solution solve(PBQPRAGraph &G)
Definition: RegAllocPBQP.h:582
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:1738
lazy value Lazy Value Information false
void eraseBlock(BasicBlock *BB)
Inform the analysis cache that we have erased a block.
SwitchInst - Multiway switch.
This pass computes, caches, and vends lazy value constraint information.
Definition: LazyValueInfo.h:30
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
static const Function * getParent(const Value *V)
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
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:344
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:203
iterator end()
Definition: DenseSet.h:123
const BasicBlock * getParent() const
Definition: Instruction.h:72
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
static bool InBlock(const Value *V, const BasicBlock *BB)
#define LLVM_ATTRIBUTE_USED
Definition: Compiler.h:122