LLVM  14.0.0git
AssumptionCache.cpp
Go to the documentation of this file.
1 //===- AssumptionCache.cpp - Cache finding @llvm.assume calls -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains a pass that keeps track of @llvm.assume intrinsics in
10 // the functions of a module.
11 //
12 //===----------------------------------------------------------------------===//
13 
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/SmallPtrSet.h"
18 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/IR/BasicBlock.h"
21 #include "llvm/IR/Function.h"
22 #include "llvm/IR/InstrTypes.h"
23 #include "llvm/IR/Instruction.h"
24 #include "llvm/IR/Instructions.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/PassManager.h"
27 #include "llvm/IR/PatternMatch.h"
28 #include "llvm/InitializePasses.h"
29 #include "llvm/Pass.h"
30 #include "llvm/Support/Casting.h"
34 #include <algorithm>
35 #include <cassert>
36 #include <utility>
37 
38 using namespace llvm;
39 using namespace llvm::PatternMatch;
40 
41 static cl::opt<bool>
42  VerifyAssumptionCache("verify-assumption-cache", cl::Hidden,
43  cl::desc("Enable verification of assumption cache"),
44  cl::init(false));
45 
47 AssumptionCache::getOrInsertAffectedValues(Value *V) {
48  // Try using find_as first to avoid creating extra value handles just for the
49  // purpose of doing the lookup.
50  auto AVI = AffectedValues.find_as(V);
51  if (AVI != AffectedValues.end())
52  return AVI->second;
53 
54  auto AVIP = AffectedValues.insert(
55  {AffectedValueCallbackVH(V, this), SmallVector<ResultElem, 1>()});
56  return AVIP.first->second;
57 }
58 
59 static void
62  // Note: This code must be kept in-sync with the code in
63  // computeKnownBitsFromAssume in ValueTracking.
64 
65  auto AddAffected = [&Affected](Value *V, unsigned Idx =
67  if (isa<Argument>(V)) {
68  Affected.push_back({V, Idx});
69  } else if (auto *I = dyn_cast<Instruction>(V)) {
70  Affected.push_back({I, Idx});
71 
72  // Peek through unary operators to find the source of the condition.
73  Value *Op;
74  if (match(I, m_BitCast(m_Value(Op))) ||
76  if (isa<Instruction>(Op) || isa<Argument>(Op))
77  Affected.push_back({Op, Idx});
78  }
79  }
80  };
81 
82  for (unsigned Idx = 0; Idx != CI->getNumOperandBundles(); Idx++) {
83  if (CI->getOperandBundleAt(Idx).Inputs.size() > ABA_WasOn &&
84  CI->getOperandBundleAt(Idx).getTagName() != IgnoreBundleTag)
85  AddAffected(CI->getOperandBundleAt(Idx).Inputs[ABA_WasOn], Idx);
86  }
87 
88  Value *Cond = CI->getArgOperand(0), *A, *B;
89  AddAffected(Cond);
90 
91  CmpInst::Predicate Pred;
92  if (match(Cond, m_ICmp(Pred, m_Value(A), m_Value(B)))) {
93  AddAffected(A);
94  AddAffected(B);
95 
96  if (Pred == ICmpInst::ICMP_EQ) {
97  // For equality comparisons, we handle the case of bit inversion.
98  auto AddAffectedFromEq = [&AddAffected](Value *V) {
99  Value *A;
100  if (match(V, m_Not(m_Value(A)))) {
101  AddAffected(A);
102  V = A;
103  }
104 
105  Value *B;
106  // (A & B) or (A | B) or (A ^ B).
107  if (match(V, m_BitwiseLogic(m_Value(A), m_Value(B)))) {
108  AddAffected(A);
109  AddAffected(B);
110  // (A << C) or (A >>_s C) or (A >>_u C) where C is some constant.
111  } else if (match(V, m_Shift(m_Value(A), m_ConstantInt()))) {
112  AddAffected(A);
113  }
114  };
115 
116  AddAffectedFromEq(A);
117  AddAffectedFromEq(B);
118  }
119 
120  Value *X;
121  // Handle (A + C1) u< C2, which is the canonical form of A > C3 && A < C4,
122  // and recognized by LVI at least.
123  if (Pred == ICmpInst::ICMP_ULT &&
124  match(A, m_Add(m_Value(X), m_ConstantInt())) &&
125  match(B, m_ConstantInt()))
126  AddAffected(X);
127  }
128 
129  if (TTI) {
130  const Value *Ptr;
131  unsigned AS;
132  std::tie(Ptr, AS) = TTI->getPredicatedAddrSpace(Cond);
133  if (Ptr)
134  AddAffected(const_cast<Value *>(Ptr->stripInBoundsOffsets()));
135  }
136 }
137 
140  findAffectedValues(CI, TTI, Affected);
141 
142  for (auto &AV : Affected) {
143  auto &AVV = getOrInsertAffectedValues(AV.Assume);
144  if (llvm::none_of(AVV, [&](ResultElem &Elem) {
145  return Elem.Assume == CI && Elem.Index == AV.Index;
146  }))
147  AVV.push_back({CI, AV.Index});
148  }
149 }
150 
153  findAffectedValues(CI, TTI, Affected);
154 
155  for (auto &AV : Affected) {
156  auto AVI = AffectedValues.find_as(AV.Assume);
157  if (AVI == AffectedValues.end())
158  continue;
159  bool Found = false;
160  bool HasNonnull = false;
161  for (ResultElem &Elem : AVI->second) {
162  if (Elem.Assume == CI) {
163  Found = true;
164  Elem.Assume = nullptr;
165  }
166  HasNonnull |= !!Elem.Assume;
167  if (HasNonnull && Found)
168  break;
169  }
170  assert(Found && "already unregistered or incorrect cache state");
171  if (!HasNonnull)
172  AffectedValues.erase(AVI);
173  }
174 
175  erase_value(AssumeHandles, CI);
176 }
177 
178 void AssumptionCache::AffectedValueCallbackVH::deleted() {
179  AC->AffectedValues.erase(getValPtr());
180  // 'this' now dangles!
181 }
182 
183 void AssumptionCache::transferAffectedValuesInCache(Value *OV, Value *NV) {
184  auto &NAVV = getOrInsertAffectedValues(NV);
185  auto AVI = AffectedValues.find(OV);
186  if (AVI == AffectedValues.end())
187  return;
188 
189  for (auto &A : AVI->second)
190  if (!llvm::is_contained(NAVV, A))
191  NAVV.push_back(A);
192  AffectedValues.erase(OV);
193 }
194 
195 void AssumptionCache::AffectedValueCallbackVH::allUsesReplacedWith(Value *NV) {
196  if (!isa<Instruction>(NV) && !isa<Argument>(NV))
197  return;
198 
199  // Any assumptions that affected this value now affect the new value.
200 
201  AC->transferAffectedValuesInCache(getValPtr(), NV);
202  // 'this' now might dangle! If the AffectedValues map was resized to add an
203  // entry for NV then this object might have been destroyed in favor of some
204  // copy in the grown map.
205 }
206 
207 void AssumptionCache::scanFunction() {
208  assert(!Scanned && "Tried to scan the function twice!");
209  assert(AssumeHandles.empty() && "Already have assumes when scanning!");
210 
211  // Go through all instructions in all blocks, add all calls to @llvm.assume
212  // to this cache.
213  for (BasicBlock &B : F)
214  for (Instruction &I : B)
215  if (isa<AssumeInst>(&I))
216  AssumeHandles.push_back({&I, ExprResultIdx});
217 
218  // Mark the scan as complete.
219  Scanned = true;
220 
221  // Update affected values.
222  for (auto &A : AssumeHandles)
223  updateAffectedValues(cast<AssumeInst>(A));
224 }
225 
227  // If we haven't scanned the function yet, just drop this assumption. It will
228  // be found when we scan later.
229  if (!Scanned)
230  return;
231 
232  AssumeHandles.push_back({CI, ExprResultIdx});
233 
234 #ifndef NDEBUG
235  assert(CI->getParent() &&
236  "Cannot register @llvm.assume call not in a basic block");
237  assert(&F == CI->getParent()->getParent() &&
238  "Cannot register @llvm.assume call not in this function");
239 
240  // We expect the number of assumptions to be small, so in an asserts build
241  // check that we don't accumulate duplicates and that all assumptions point
242  // to the same function.
243  SmallPtrSet<Value *, 16> AssumptionSet;
244  for (auto &VH : AssumeHandles) {
245  if (!VH)
246  continue;
247 
248  assert(&F == cast<Instruction>(VH)->getParent()->getParent() &&
249  "Cached assumption not inside this function!");
250  assert(match(cast<CallInst>(VH), m_Intrinsic<Intrinsic::assume>()) &&
251  "Cached something other than a call to @llvm.assume!");
252  assert(AssumptionSet.insert(VH).second &&
253  "Cache contains multiple copies of a call!");
254  }
255 #endif
256 
258 }
259 
262  auto &TTI = FAM.getResult<TargetIRAnalysis>(F);
263  return AssumptionCache(F, &TTI);
264 }
265 
266 AnalysisKey AssumptionAnalysis::Key;
267 
271 
272  OS << "Cached assumptions for function: " << F.getName() << "\n";
273  for (auto &VH : AC.assumptions())
274  if (VH)
275  OS << " " << *cast<CallInst>(VH)->getArgOperand(0) << "\n";
276 
277  return PreservedAnalyses::all();
278 }
279 
280 void AssumptionCacheTracker::FunctionCallbackVH::deleted() {
281  auto I = ACT->AssumptionCaches.find_as(cast<Function>(getValPtr()));
282  if (I != ACT->AssumptionCaches.end())
283  ACT->AssumptionCaches.erase(I);
284  // 'this' now dangles!
285 }
286 
288  // We probe the function map twice to try and avoid creating a value handle
289  // around the function in common cases. This makes insertion a bit slower,
290  // but if we have to insert we're going to scan the whole function so that
291  // shouldn't matter.
292  auto I = AssumptionCaches.find_as(&F);
293  if (I != AssumptionCaches.end())
294  return *I->second;
295 
296  auto *TTIWP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
297  auto *TTI = TTIWP ? &TTIWP->getTTI(F) : nullptr;
298 
299  // Ok, build a new cache by scanning the function, insert it and the value
300  // handle into our map, and return the newly populated cache.
301  auto IP = AssumptionCaches.insert(std::make_pair(
302  FunctionCallbackVH(&F, this), std::make_unique<AssumptionCache>(F, TTI)));
303  assert(IP.second && "Scanning function already in the map?");
304  return *IP.first->second;
305 }
306 
308  auto I = AssumptionCaches.find_as(&F);
309  if (I != AssumptionCaches.end())
310  return I->second.get();
311  return nullptr;
312 }
313 
315  // FIXME: In the long term the verifier should not be controllable with a
316  // flag. We should either fix all passes to correctly update the assumption
317  // cache and enable the verifier unconditionally or somehow arrange for the
318  // assumption list to be updated automatically by passes.
320  return;
321 
322  SmallPtrSet<const CallInst *, 4> AssumptionSet;
323  for (const auto &I : AssumptionCaches) {
324  for (auto &VH : I.second->assumptions())
325  if (VH)
326  AssumptionSet.insert(cast<CallInst>(VH));
327 
328  for (const BasicBlock &B : cast<Function>(*I.first))
329  for (const Instruction &II : B)
330  if (match(&II, m_Intrinsic<Intrinsic::assume>()) &&
331  !AssumptionSet.count(cast<CallInst>(&II)))
332  report_fatal_error("Assumption in scanned function not in cache");
333  }
334 }
335 
338 }
339 
341 
343 
344 INITIALIZE_PASS(AssumptionCacheTracker, "assumption-cache-tracker",
345  "Assumption Cache Tracker", false, true)
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
AssumptionCache.h
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2418
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:742
llvm::none_of
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1663
llvm::AssumptionCache::registerAssumption
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
Definition: AssumptionCache.cpp:226
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:721
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:107
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:269
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:783
llvm::Function
Definition: Function.h:62
Pass.h
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1177
llvm::PatternMatch::m_Add
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:988
ErrorHandling.h
llvm::TargetTransformInfo
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Definition: TargetTransformInfo.h:168
llvm::IgnoreBundleTag
constexpr StringRef IgnoreBundleTag
Tag in operand bundle indicating that this bundle should be ignored.
Definition: AssumeBundleQueries.h:135
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:143
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
llvm::AssumeInst
This represents the llvm.assume intrinsic.
Definition: IntrinsicInst.h:1371
llvm::AssumptionCache::ResultElem::Index
unsigned Index
contains either ExprResultIdx or the index of the operand bundle containing the knowledge.
Definition: AssumptionCache.h:53
llvm::AssumptionPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Definition: AssumptionCache.cpp:268
VerifyAssumptionCache
static cl::opt< bool > VerifyAssumptionCache("verify-assumption-cache", cl::Hidden, cl::desc("Enable verification of assumption cache"), cl::init(false))
llvm::AssumptionCacheTracker::ID
static char ID
Definition: AssumptionCache.h:251
llvm::SmallPtrSet< Value *, 16 >
llvm::ore::NV
DiagnosticInfoOptimizationBase::Argument NV
Definition: OptimizationRemarkEmitter.h:136
STLExtras.h
llvm::PatternMatch::m_Not
BinaryOp_match< ValTy, cst_pred_ty< is_all_ones >, Instruction::Xor, true > m_Not(const ValTy &V)
Matches a 'Not' as 'xor V, -1' or 'xor -1, V'.
Definition: PatternMatch.h:2287
llvm::PatternMatch::m_BitCast
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
Definition: PatternMatch.h:1603
llvm::AssumptionCache::ResultElem
Definition: AssumptionCache.h:48
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
Instruction.h
CommandLine.h
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::PatternMatch::match
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
llvm::ABA_WasOn
@ ABA_WasOn
Definition: AssumeBundleQueries.h:30
Intrinsics.h
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
InstrTypes.h
INITIALIZE_PASS
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:37
AssumeBundleQueries.h
llvm::initializeAssumptionCacheTrackerPass
void initializeAssumptionCacheTrackerPass(PassRegistry &)
IP
Definition: NVPTXLowerArgs.cpp:166
llvm::AssumptionCacheTracker::lookupAssumptionCache
AssumptionCache * lookupAssumptionCache(Function &F)
Return the cached assumptions for a function if it has already been scanned.
Definition: AssumptionCache.cpp:307
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::PatternMatch::m_ConstantInt
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:145
llvm::Instruction
Definition: Instruction.h:45
llvm::AssumptionCacheTracker::AssumptionCacheTracker
AssumptionCacheTracker()
Definition: AssumptionCache.cpp:336
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
SmallPtrSet.h
PatternMatch.h
llvm::PatternMatch::m_Shift
BinOpPred_match< LHS, RHS, is_shift_op > m_Shift(const LHS &L, const RHS &R)
Matches shift operations.
Definition: PatternMatch.h:1306
llvm::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1838
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
llvm::AssumptionCache::ResultElem::Assume
WeakVH Assume
Definition: AssumptionCache.h:49
BasicBlock.h
llvm::cl::opt< bool >
llvm::AssumptionAnalysis::run
AssumptionCache run(Function &F, FunctionAnalysisManager &)
Definition: AssumptionCache.cpp:260
llvm::DenseMapBase::find_as
iterator find_as(const LookupKeyT &Val)
Alternate version of find() which allows a different, and possibly less expensive,...
Definition: DenseMap.h:175
llvm::AssumptionAnalysis
A function analysis which provides an AssumptionCache.
Definition: AssumptionCache.h:173
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:441
llvm::is_contained
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1714
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:150
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:382
llvm::PatternMatch::m_Value
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:76
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:202
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:179
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:42
llvm::CmpInst::ICMP_ULT
@ ICMP_ULT
unsigned less than
Definition: InstrTypes.h:746
llvm::TargetTransformInfo::getPredicatedAddrSpace
std::pair< const Value *, unsigned > getPredicatedAddrSpace(const Value *V) const
Definition: TargetTransformInfo.cpp:272
getParent
static const Function * getParent(const Value *V)
Definition: BasicAliasAnalysis.cpp:870
llvm::DenseMapBase::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:207
llvm::Value::stripInBoundsOffsets
const Value * stripInBoundsOffsets(function_ref< void(const Value *)> Func=[](const Value *) {}) const
Strip off pointer casts and inbounds GEPs.
Definition: Value.cpp:777
llvm::PatternMatch::m_BitwiseLogic
BinOpPred_match< LHS, RHS, is_bitwiselogic_op > m_BitwiseLogic(const LHS &L, const RHS &R)
Matches bitwise logic operations.
Definition: PatternMatch.h:1328
llvm::AssumptionCache::ExprResultIdx
@ ExprResultIdx
Definition: AssumptionCache.h:46
llvm::AssumptionCacheTracker::getAssumptionCache
AssumptionCache & getAssumptionCache(Function &F)
Get the cached assumptions for a function.
Definition: AssumptionCache.cpp:287
llvm::DenseMapBase::end
iterator end()
Definition: DenseMap.h:83
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:325
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:161
Casting.h
Function.h
PassManager.h
llvm::PatternMatch::m_PtrToInt
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:1609
findAffectedValues
static void findAffectedValues(CallBase *CI, TargetTransformInfo *TTI, SmallVectorImpl< AssumptionCache::ResultElem > &Affected)
Definition: AssumptionCache.cpp:60
Instructions.h
SmallVector.h
llvm::PatternMatch::m_ICmp
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:1404
llvm::AssumptionCache::assumptions
MutableArrayRef< ResultElem > assumptions()
Access the list of assumption handles currently tracked for this function.
Definition: AssumptionCache.h:150
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:94
TargetTransformInfo.h
llvm::PatternMatch
Definition: PatternMatch.h:47
llvm::AssumptionCache::unregisterAssumption
void unregisterAssumption(AssumeInst *CI)
Remove an @llvm.assume intrinsic from this function's cache if it has been added to the cache earlier...
Definition: AssumptionCache.cpp:151
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::AssumptionCacheTracker::verifyAnalysis
void verifyAnalysis() const override
verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis infor...
Definition: AssumptionCache.cpp:314
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1176
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::cl::desc
Definition: CommandLine.h:412
llvm::AssumptionCache::updateAffectedValues
void updateAffectedValues(AssumeInst *CI)
Update the cache of values being affected by this assumption (i.e.
Definition: AssumptionCache.cpp:138
raw_ostream.h
llvm::AssumptionCacheTracker::~AssumptionCacheTracker
~AssumptionCacheTracker() override
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:782