1 //===- AssumptionTracker.cpp - Track @llvm.assume -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains a pass that keeps track of @llvm.assume intrinsics in
11 // the functions of a module.
13 //===----------------------------------------------------------------------===//
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"
24 using namespace llvm::PatternMatch;
26 void AssumptionTracker::FunctionCallbackVH::deleted() {
27 AT->forgetCachedAssumptions(cast<Function>(getValPtr()));
28 // 'this' now dangles!
31 void AssumptionTracker::forgetCachedAssumptions(Function *F) {
32 auto I = CachedAssumeCalls.find_as(F);
33 if (I != CachedAssumeCalls.end())
34 CachedAssumeCalls.erase(I);
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?");
43 I->second->erase(*this);
44 // 'this' now dangles!
47 AssumptionTracker::FunctionCallsMap::iterator
48 AssumptionTracker::scanFunction(Function *F) {
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?");
55 FunctionCallsMap::iterator I = IP.first;
57 // Go through all instructions in all blocks, add all calls to @llvm.assume
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));
67 void AssumptionTracker::verifyAnalysis() const {
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");
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");
90 Function *F = CI->getParent()->getParent();
91 assert(F && "Cannot register @llvm.assume call not in a function");
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.
103 I->second->insert(CallCallbackVH(CI, this));
106 AssumptionTracker::AssumptionTracker() : ImmutablePass(ID) {
107 initializeAssumptionTrackerPass(*PassRegistry::getPassRegistry());
110 AssumptionTracker::~AssumptionTracker() {}
112 INITIALIZE_PASS(AssumptionTracker, "assumption-tracker", "Assumption Tracker",
114 char AssumptionTracker::ID = 0;