lib/Analysis/AssumptionTracker.cpp

   1 //===- AssumptionTracker.cpp - Track @llvm.assume -------------------------===//
   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 contains a pass that keeps track of @llvm.assume intrinsics in
  11 // the functions of a module.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Analysis/AssumptionTracker.h"
  16 #include "llvm/IR/CallSite.h"
  17 #include "llvm/IR/Dominators.h"
  18 #include "llvm/IR/Function.h"
  19 #include "llvm/IR/Instructions.h"
  20 #include "llvm/IR/IntrinsicInst.h"
  21 #include "llvm/IR/PatternMatch.h"
  22 #include "llvm/Support/Debug.h"
  23 using namespace llvm;
  24 using namespace llvm::PatternMatch;
  25
  26 void AssumptionTracker::FunctionCallbackVH::deleted() {
  27   AT->forgetCachedAssumptions(cast<Function>(getValPtr()));
  28   // 'this' now dangles!
  29 }
  30
  31 void AssumptionTracker::forgetCachedAssumptions(Function *F) {
  32   auto I = CachedAssumeCalls.find_as(F);
  33   if (I != CachedAssumeCalls.end())
  34     CachedAssumeCalls.erase(I);
  35 }
  36
  37 void AssumptionTracker::CallCallbackVH::deleted() {
  38   assert(F && "delete callback called on dummy handle");
  39   FunctionCallsMap::iterator I = AT->CachedAssumeCalls.find_as(F);
  40   assert(I != AT->CachedAssumeCalls.end() &&
  41          "Function cleared from the map without removing the values?");
  42
  43   I->second->erase(*this);
  44   // 'this' now dangles!
  45 }
  46
  47 AssumptionTracker::FunctionCallsMap::iterator
  48 AssumptionTracker::scanFunction(Function *F) {
  49   auto IP =
  50     CachedAssumeCalls.insert(std::make_pair(FunctionCallbackVH(F, this),
  51                                             std::unique_ptr<CallHandleSet>(
  52                                               new CallHandleSet())));
  53   assert(IP.second && "Scanning function already in the map?");
  54
  55   FunctionCallsMap::iterator I = IP.first;
  56
  57   // Go through all instructions in all blocks, add all calls to @llvm.assume
  58   // to our cache.
  59   for (BasicBlock &B : *F)
  60     for (Instruction &II : B)
  61       if (match(cast<Value>(&II), m_Intrinsic<Intrinsic::assume>(m_Value())))
  62         I->second->insert(CallCallbackVH(&II, this));
  63
  64   return I;
  65 }
  66
  67 void AssumptionTracker::verifyAnalysis() const {
  68 #ifndef NDEBUG
  69   for (const auto &I : CachedAssumeCalls) {
  70     for (const BasicBlock &B : cast<Function>(*I.first))
  71       for (const Instruction &II : B) {
  72         Instruction *C = const_cast<Instruction*>(&II);
  73         if (match(C, m_Intrinsic<Intrinsic::assume>(m_Value()))) {
  74           assert(I.second->count(CallCallbackVH(C,
  75                    const_cast<AssumptionTracker*>(this))) &&
  76                  "Assumption in scanned function not in cache");
  77         }
  78     }
  79   }
  80 #endif
  81 }
  82
  83 void AssumptionTracker::registerAssumption(CallInst *CI) {
  84   assert(match(cast<Value>(CI),
  85                m_Intrinsic<Intrinsic::assume>(m_Value())) &&
  86          "Registered call does not call @llvm.assume");
  87   assert(CI->getParent() &&
  88          "Cannot register @llvm.assume call not in a basic block");
  89
  90   Function *F = CI->getParent()->getParent();
  91   assert(F && "Cannot register @llvm.assume call not in a function");
  92
  93   FunctionCallsMap::iterator I = CachedAssumeCalls.find_as(F);
  94   if (I == CachedAssumeCalls.end()) {
  95     // If this function has not already been scanned, then don't do anything
  96     // here. This intrinsic will be found, if it still exists, if the list of
  97     // assumptions in this function is requested at some later point. This
  98     // maintains the following invariant: if a function is present in the
  99     // cache, then its list of assumption intrinsic calls is complete.
 100     return;
 101   }
 102
 103   I->second->insert(CallCallbackVH(CI, this));
 104 }
 105
 106 AssumptionTracker::AssumptionTracker() : ImmutablePass(ID) {
 107   initializeAssumptionTrackerPass(*PassRegistry::getPassRegistry());
 108 }
 109
 110 AssumptionTracker::~AssumptionTracker() {}
 111
 112 INITIALIZE_PASS(AssumptionTracker, "assumption-tracker", "Assumption Tracker",
 113                 false, true)
 114 char AssumptionTracker::ID = 0;
 115