LLVM  15.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 
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #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/PassManager.h"
26 #include "llvm/IR/PatternMatch.h"
27 #include "llvm/InitializePasses.h"
28 #include "llvm/Pass.h"
29 #include "llvm/Support/Casting.h"
33 #include <cassert>
34 #include <utility>
35 
36 using namespace llvm;
37 using namespace llvm::PatternMatch;
38 
39 static cl::opt<bool>
40  VerifyAssumptionCache("verify-assumption-cache", cl::Hidden,
41  cl::desc("Enable verification of assumption cache"),
42  cl::init(false));
43 
45 AssumptionCache::getOrInsertAffectedValues(Value *V) {
46  // Try using find_as first to avoid creating extra value handles just for the
47  // purpose of doing the lookup.
48  auto AVI = AffectedValues.find_as(V);
49  if (AVI != AffectedValues.end())
50  return AVI->second;
51 
52  auto AVIP = AffectedValues.insert(
53  {AffectedValueCallbackVH(V, this), SmallVector<ResultElem, 1>()});
54  return AVIP.first->second;
55 }
56 
57 static void
60  // Note: This code must be kept in-sync with the code in
61  // computeKnownBitsFromAssume in ValueTracking.
62 
63  auto AddAffected = [&Affected](Value *V, unsigned Idx =
65  if (isa<Argument>(V)) {
66  Affected.push_back({V, Idx});
67  } else if (auto *I = dyn_cast<Instruction>(V)) {
68  Affected.push_back({I, Idx});
69 
70  // Peek through unary operators to find the source of the condition.
71  Value *Op;
72  if (match(I, m_BitCast(m_Value(Op))) ||
74  if (isa<Instruction>(Op) || isa<Argument>(Op))
75  Affected.push_back({Op, Idx});
76  }
77  }
78  };
79 
80  for (unsigned Idx = 0; Idx != CI->getNumOperandBundles(); Idx++) {
81  if (CI->getOperandBundleAt(Idx).Inputs.size() > ABA_WasOn &&
82  CI->getOperandBundleAt(Idx).getTagName() != IgnoreBundleTag)
83  AddAffected(CI->getOperandBundleAt(Idx).Inputs[ABA_WasOn], Idx);
84  }
85 
86  Value *Cond = CI->getArgOperand(0), *A, *B;
87  AddAffected(Cond);
88 
89  CmpInst::Predicate Pred;
90  if (match(Cond, m_ICmp(Pred, m_Value(A), m_Value(B)))) {
91  AddAffected(A);
92  AddAffected(B);
93 
94  if (Pred == ICmpInst::ICMP_EQ) {
95  // For equality comparisons, we handle the case of bit inversion.
96  auto AddAffectedFromEq = [&AddAffected](Value *V) {
97  Value *A;
98  if (match(V, m_Not(m_Value(A)))) {
99  AddAffected(A);
100  V = A;
101  }
102 
103  Value *B;
104  // (A & B) or (A | B) or (A ^ B).
105  if (match(V, m_BitwiseLogic(m_Value(A), m_Value(B)))) {
106  AddAffected(A);
107  AddAffected(B);
108  // (A << C) or (A >>_s C) or (A >>_u C) where C is some constant.
109  } else if (match(V, m_Shift(m_Value(A), m_ConstantInt()))) {
110  AddAffected(A);
111  }
112  };
113 
114  AddAffectedFromEq(A);
115  AddAffectedFromEq(B);
116  }
117 
118  Value *X;
119  // Handle (A + C1) u< C2, which is the canonical form of A > C3 && A < C4,
120  // and recognized by LVI at least.
121  if (Pred == ICmpInst::ICMP_ULT &&
122  match(A, m_Add(m_Value(X), m_ConstantInt())) &&
123  match(B, m_ConstantInt()))
124  AddAffected(X);
125  }
126 
127  if (TTI) {
128  const Value *Ptr;
129  unsigned AS;
130  std::tie(Ptr, AS) = TTI->getPredicatedAddrSpace(Cond);
131  if (Ptr)
132  AddAffected(const_cast<Value *>(Ptr->stripInBoundsOffsets()));
133  }
134 }
135 
138  findAffectedValues(CI, TTI, Affected);
139 
140  for (auto &AV : Affected) {
141  auto &AVV = getOrInsertAffectedValues(AV.Assume);
142  if (llvm::none_of(AVV, [&](ResultElem &Elem) {
143  return Elem.Assume == CI && Elem.Index == AV.Index;
144  }))
145  AVV.push_back({CI, AV.Index});
146  }
147 }
148 
151  findAffectedValues(CI, TTI, Affected);
152 
153  for (auto &AV : Affected) {
154  auto AVI = AffectedValues.find_as(AV.Assume);
155  if (AVI == AffectedValues.end())
156  continue;
157  bool Found = false;
158  bool HasNonnull = false;
159  for (ResultElem &Elem : AVI->second) {
160  if (Elem.Assume == CI) {
161  Found = true;
162  Elem.Assume = nullptr;
163  }
164  HasNonnull |= !!Elem.Assume;
165  if (HasNonnull && Found)
166  break;
167  }
168  assert(Found && "already unregistered or incorrect cache state");
169  if (!HasNonnull)
170  AffectedValues.erase(AVI);
171  }
172 
173  erase_value(AssumeHandles, CI);
174 }
175 
176 void AssumptionCache::AffectedValueCallbackVH::deleted() {
177  AC->AffectedValues.erase(getValPtr());
178  // 'this' now dangles!
179 }
180 
181 void AssumptionCache::transferAffectedValuesInCache(Value *OV, Value *NV) {
182  auto &NAVV = getOrInsertAffectedValues(NV);
183  auto AVI = AffectedValues.find(OV);
184  if (AVI == AffectedValues.end())
185  return;
186 
187  for (auto &A : AVI->second)
188  if (!llvm::is_contained(NAVV, A))
189  NAVV.push_back(A);
190  AffectedValues.erase(OV);
191 }
192 
193 void AssumptionCache::AffectedValueCallbackVH::allUsesReplacedWith(Value *NV) {
194  if (!isa<Instruction>(NV) && !isa<Argument>(NV))
195  return;
196 
197  // Any assumptions that affected this value now affect the new value.
198 
199  AC->transferAffectedValuesInCache(getValPtr(), NV);
200  // 'this' now might dangle! If the AffectedValues map was resized to add an
201  // entry for NV then this object might have been destroyed in favor of some
202  // copy in the grown map.
203 }
204 
205 void AssumptionCache::scanFunction() {
206  assert(!Scanned && "Tried to scan the function twice!");
207  assert(AssumeHandles.empty() && "Already have assumes when scanning!");
208 
209  // Go through all instructions in all blocks, add all calls to @llvm.assume
210  // to this cache.
211  for (BasicBlock &B : F)
212  for (Instruction &I : B)
213  if (isa<AssumeInst>(&I))
214  AssumeHandles.push_back({&I, ExprResultIdx});
215 
216  // Mark the scan as complete.
217  Scanned = true;
218 
219  // Update affected values.
220  for (auto &A : AssumeHandles)
221  updateAffectedValues(cast<AssumeInst>(A));
222 }
223 
225  // If we haven't scanned the function yet, just drop this assumption. It will
226  // be found when we scan later.
227  if (!Scanned)
228  return;
229 
230  AssumeHandles.push_back({CI, ExprResultIdx});
231 
232 #ifndef NDEBUG
233  assert(CI->getParent() &&
234  "Cannot register @llvm.assume call not in a basic block");
235  assert(&F == CI->getParent()->getParent() &&
236  "Cannot register @llvm.assume call not in this function");
237 
238  // We expect the number of assumptions to be small, so in an asserts build
239  // check that we don't accumulate duplicates and that all assumptions point
240  // to the same function.
241  SmallPtrSet<Value *, 16> AssumptionSet;
242  for (auto &VH : AssumeHandles) {
243  if (!VH)
244  continue;
245 
246  assert(&F == cast<Instruction>(VH)->getParent()->getParent() &&
247  "Cached assumption not inside this function!");
248  assert(match(cast<CallInst>(VH), m_Intrinsic<Intrinsic::assume>()) &&
249  "Cached something other than a call to @llvm.assume!");
250  assert(AssumptionSet.insert(VH).second &&
251  "Cache contains multiple copies of a call!");
252  }
253 #endif
254 
256 }
257 
260  auto &TTI = FAM.getResult<TargetIRAnalysis>(F);
261  return AssumptionCache(F, &TTI);
262 }
263 
264 AnalysisKey AssumptionAnalysis::Key;
265 
269 
270  OS << "Cached assumptions for function: " << F.getName() << "\n";
271  for (auto &VH : AC.assumptions())
272  if (VH)
273  OS << " " << *cast<CallInst>(VH)->getArgOperand(0) << "\n";
274 
275  return PreservedAnalyses::all();
276 }
277 
278 void AssumptionCacheTracker::FunctionCallbackVH::deleted() {
279  auto I = ACT->AssumptionCaches.find_as(cast<Function>(getValPtr()));
280  if (I != ACT->AssumptionCaches.end())
281  ACT->AssumptionCaches.erase(I);
282  // 'this' now dangles!
283 }
284 
286  // We probe the function map twice to try and avoid creating a value handle
287  // around the function in common cases. This makes insertion a bit slower,
288  // but if we have to insert we're going to scan the whole function so that
289  // shouldn't matter.
290  auto I = AssumptionCaches.find_as(&F);
291  if (I != AssumptionCaches.end())
292  return *I->second;
293 
294  auto *TTIWP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
295  auto *TTI = TTIWP ? &TTIWP->getTTI(F) : nullptr;
296 
297  // Ok, build a new cache by scanning the function, insert it and the value
298  // handle into our map, and return the newly populated cache.
299  auto IP = AssumptionCaches.insert(std::make_pair(
300  FunctionCallbackVH(&F, this), std::make_unique<AssumptionCache>(F, TTI)));
301  assert(IP.second && "Scanning function already in the map?");
302  return *IP.first->second;
303 }
304 
306  auto I = AssumptionCaches.find_as(&F);
307  if (I != AssumptionCaches.end())
308  return I->second.get();
309  return nullptr;
310 }
311 
313  // FIXME: In the long term the verifier should not be controllable with a
314  // flag. We should either fix all passes to correctly update the assumption
315  // cache and enable the verifier unconditionally or somehow arrange for the
316  // assumption list to be updated automatically by passes.
318  return;
319 
320  SmallPtrSet<const CallInst *, 4> AssumptionSet;
321  for (const auto &I : AssumptionCaches) {
322  for (auto &VH : I.second->assumptions())
323  if (VH)
324  AssumptionSet.insert(cast<CallInst>(VH));
325 
326  for (const BasicBlock &B : cast<Function>(*I.first))
327  for (const Instruction &II : B)
328  if (match(&II, m_Intrinsic<Intrinsic::assume>()) &&
329  !AssumptionSet.count(cast<CallInst>(&II)))
330  report_fatal_error("Assumption in scanned function not in cache");
331  }
332 }
333 
336 }
337 
339 
341 
342 INITIALIZE_PASS(AssumptionCacheTracker, "assumption-cache-tracker",
343  "Assumption Cache Tracker", false, true)
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
AssumptionCache.h
llvm::TargetIRAnalysis
Analysis pass providing the TargetTransformInfo.
Definition: TargetTransformInfo.h:2458
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::CmpInst::ICMP_EQ
@ ICMP_EQ
equal
Definition: InstrTypes.h:740
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:1619
llvm::AssumptionCache::registerAssumption
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
Definition: AssumptionCache.cpp:224
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:719
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:104
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:279
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:780
llvm::Function
Definition: Function.h:60
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:1185
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:167
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:139
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:304
llvm::AssumeInst
This represents the llvm.assume intrinsic.
Definition: IntrinsicInst.h:1410
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:266
VerifyAssumptionCache
static cl::opt< bool > VerifyAssumptionCache("verify-assumption-cache", cl::Hidden, cl::desc("Enable verification of assumption cache"), cl::init(false))
llvm::AssumptionCache::ExprResultIdx
@ ExprResultIdx
Definition: AssumptionCache.h:46
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:2295
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:55
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
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:167
llvm::AssumptionCacheTracker::lookupAssumptionCache
AssumptionCache * lookupAssumptionCache(Function &F)
Return the cached assumptions for a function if it has already been scanned.
Definition: AssumptionCache.cpp:305
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:42
llvm::AssumptionCacheTracker::AssumptionCacheTracker
AssumptionCacheTracker()
Definition: AssumptionCache.cpp:334
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::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::erase_value
void erase_value(Container &C, ValueType V)
Wrapper function to remove a value from a container:
Definition: STLExtras.h:1803
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:258
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:177
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:69
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
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:1670
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:152
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:383
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:178
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:744
llvm::TargetTransformInfo::getPredicatedAddrSpace
std::pair< const Value *, unsigned > getPredicatedAddrSpace(const Value *V) const
Definition: TargetTransformInfo.cpp:270
getParent
static const Function * getParent(const Value *V)
Definition: BasicAliasAnalysis.cpp:868
llvm::DenseMapBase::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:209
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:774
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::AssumptionCacheTracker::getAssumptionCache
AssumptionCache & getAssumptionCache(Function &F)
Get the cached assumptions for a function.
Definition: AssumptionCache.cpp:285
llvm::DenseMapBase::end
iterator end()
Definition: DenseMap.h:84
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:341
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
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:58
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:91
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:149
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
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:312
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::cl::desc
Definition: CommandLine.h:405
llvm::AssumptionCache::updateAffectedValues
void updateAffectedValues(AssumeInst *CI)
Update the cache of values being affected by this assumption (i.e.
Definition: AssumptionCache.cpp:136
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:365
llvm::SmallVectorImpl::insert
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:792