#include "llvm/IR/CallSite.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Operator.h"
namespace llvm {
template<typename OpTy>
bool match(OpTy *V) {
- IntrinsicInst *II = dyn_cast<IntrinsicInst>(V);
- return II && II->getIntrinsicID() == ID;
+ if (const CallInst *CI = dyn_cast<CallInst>(V))
+ if (const Function *F = CI->getCalledFunction())
+ return F->getIntrinsicID() == ID;
+ return false;
}
};
AssumptionTracker::FunctionCallsMap::iterator
AssumptionTracker::scanFunction(Function *F) {
- auto IP =
- CachedAssumeCalls.insert(std::make_pair(FunctionCallbackVH(F, this),
- std::unique_ptr<CallHandleSet>(
- new CallHandleSet())));
+ auto IP = CachedAssumeCalls.insert(std::make_pair(
+ FunctionCallbackVH(F, this), llvm::make_unique<CallHandleSet>()));
assert(IP.second && "Scanning function already in the map?");
FunctionCallsMap::iterator I = IP.first;
// to our cache.
for (BasicBlock &B : *F)
for (Instruction &II : B)
- if (match(cast<Value>(&II), m_Intrinsic<Intrinsic::assume>(m_Value())))
+ if (match(&II, m_Intrinsic<Intrinsic::assume>()))
I->second->insert(CallCallbackVH(&II, this));
return I;
for (const auto &I : CachedAssumeCalls) {
for (const BasicBlock &B : cast<Function>(*I.first))
for (const Instruction &II : B) {
- Instruction *C = const_cast<Instruction*>(&II);
- if (match(C, m_Intrinsic<Intrinsic::assume>(m_Value()))) {
- assert(I.second->count(CallCallbackVH(C,
- const_cast<AssumptionTracker*>(this))) &&
+ if (match(&II, m_Intrinsic<Intrinsic::assume>())) {
+ assert(I.second->find_as(&II) != I.second->end() &&
"Assumption in scanned function not in cache");
}
}
}
void AssumptionTracker::registerAssumption(CallInst *CI) {
- assert(match(cast<Value>(CI),
- m_Intrinsic<Intrinsic::assume>(m_Value())) &&
+ assert(match(CI, m_Intrinsic<Intrinsic::assume>()) &&
"Registered call does not call @llvm.assume");
assert(CI->getParent() &&
"Cannot register @llvm.assume call not in a basic block");