LLVM  7.0.0svn
AliasAnalysisEvaluator.cpp
Go to the documentation of this file.
1 //===- AliasAnalysisEvaluator.cpp - Alias Analysis Accuracy Evaluator -----===//
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 
11 #include "llvm/ADT/SetVector.h"
13 #include "llvm/IR/Constants.h"
14 #include "llvm/IR/DataLayout.h"
15 #include "llvm/IR/DerivedTypes.h"
16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/InstIterator.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Pass.h"
22 #include "llvm/Support/Debug.h"
24 using namespace llvm;
25 
26 static cl::opt<bool> PrintAll("print-all-alias-modref-info", cl::ReallyHidden);
27 
28 static cl::opt<bool> PrintNoAlias("print-no-aliases", cl::ReallyHidden);
29 static cl::opt<bool> PrintMayAlias("print-may-aliases", cl::ReallyHidden);
30 static cl::opt<bool> PrintPartialAlias("print-partial-aliases", cl::ReallyHidden);
31 static cl::opt<bool> PrintMustAlias("print-must-aliases", cl::ReallyHidden);
32 
33 static cl::opt<bool> PrintNoModRef("print-no-modref", cl::ReallyHidden);
34 static cl::opt<bool> PrintRef("print-ref", cl::ReallyHidden);
35 static cl::opt<bool> PrintMod("print-mod", cl::ReallyHidden);
36 static cl::opt<bool> PrintModRef("print-modref", cl::ReallyHidden);
37 static cl::opt<bool> PrintMust("print-must", cl::ReallyHidden);
38 static cl::opt<bool> PrintMustRef("print-mustref", cl::ReallyHidden);
39 static cl::opt<bool> PrintMustMod("print-mustmod", cl::ReallyHidden);
40 static cl::opt<bool> PrintMustModRef("print-mustmodref", cl::ReallyHidden);
41 
42 static cl::opt<bool> EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden);
43 
44 static void PrintResults(AliasResult AR, bool P, const Value *V1,
45  const Value *V2, const Module *M) {
46  if (PrintAll || P) {
47  std::string o1, o2;
48  {
49  raw_string_ostream os1(o1), os2(o2);
50  V1->printAsOperand(os1, true, M);
51  V2->printAsOperand(os2, true, M);
52  }
53 
54  if (o2 < o1)
55  std::swap(o1, o2);
56  errs() << " " << AR << ":\t" << o1 << ", " << o2 << "\n";
57  }
58 }
59 
60 static inline void PrintModRefResults(const char *Msg, bool P, Instruction *I,
61  Value *Ptr, Module *M) {
62  if (PrintAll || P) {
63  errs() << " " << Msg << ": Ptr: ";
64  Ptr->printAsOperand(errs(), true, M);
65  errs() << "\t<->" << *I << '\n';
66  }
67 }
68 
69 static inline void PrintModRefResults(const char *Msg, bool P, CallSite CSA,
70  CallSite CSB, Module *M) {
71  if (PrintAll || P) {
72  errs() << " " << Msg << ": " << *CSA.getInstruction() << " <-> "
73  << *CSB.getInstruction() << '\n';
74  }
75 }
76 
77 static inline void PrintLoadStoreResults(AliasResult AR, bool P,
78  const Value *V1, const Value *V2,
79  const Module *M) {
80  if (PrintAll || P) {
81  errs() << " " << AR << ": " << *V1 << " <-> " << *V2 << '\n';
82  }
83 }
84 
85 static inline bool isInterestingPointer(Value *V) {
86  return V->getType()->isPointerTy()
87  && !isa<ConstantPointerNull>(V);
88 }
89 
91  runInternal(F, AM.getResult<AAManager>(F));
92  return PreservedAnalyses::all();
93 }
94 
95 void AAEvaluator::runInternal(Function &F, AAResults &AA) {
96  const DataLayout &DL = F.getParent()->getDataLayout();
97 
98  ++FunctionCount;
99 
100  SetVector<Value *> Pointers;
102  SetVector<Value *> Loads;
103  SetVector<Value *> Stores;
104 
105  for (auto &I : F.args())
106  if (I.getType()->isPointerTy()) // Add all pointer arguments.
107  Pointers.insert(&I);
108 
109  for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
110  if (I->getType()->isPointerTy()) // Add all pointer instructions.
111  Pointers.insert(&*I);
112  if (EvalAAMD && isa<LoadInst>(&*I))
113  Loads.insert(&*I);
114  if (EvalAAMD && isa<StoreInst>(&*I))
115  Stores.insert(&*I);
116  Instruction &Inst = *I;
117  if (auto CS = CallSite(&Inst)) {
118  Value *Callee = CS.getCalledValue();
119  // Skip actual functions for direct function calls.
120  if (!isa<Function>(Callee) && isInterestingPointer(Callee))
121  Pointers.insert(Callee);
122  // Consider formals.
123  for (Use &DataOp : CS.data_ops())
124  if (isInterestingPointer(DataOp))
125  Pointers.insert(DataOp);
126  CallSites.insert(CS);
127  } else {
128  // Consider all operands.
129  for (Instruction::op_iterator OI = Inst.op_begin(), OE = Inst.op_end();
130  OI != OE; ++OI)
131  if (isInterestingPointer(*OI))
132  Pointers.insert(*OI);
133  }
134  }
135 
138  errs() << "Function: " << F.getName() << ": " << Pointers.size()
139  << " pointers, " << CallSites.size() << " call sites\n";
140 
141  // iterate over the worklist, and run the full (n^2)/2 disambiguations
142  for (SetVector<Value *>::iterator I1 = Pointers.begin(), E = Pointers.end();
143  I1 != E; ++I1) {
144  uint64_t I1Size = MemoryLocation::UnknownSize;
145  Type *I1ElTy = cast<PointerType>((*I1)->getType())->getElementType();
146  if (I1ElTy->isSized()) I1Size = DL.getTypeStoreSize(I1ElTy);
147 
148  for (SetVector<Value *>::iterator I2 = Pointers.begin(); I2 != I1; ++I2) {
149  uint64_t I2Size = MemoryLocation::UnknownSize;
150  Type *I2ElTy =cast<PointerType>((*I2)->getType())->getElementType();
151  if (I2ElTy->isSized()) I2Size = DL.getTypeStoreSize(I2ElTy);
152 
153  AliasResult AR = AA.alias(*I1, I1Size, *I2, I2Size);
154  switch (AR) {
155  case NoAlias:
156  PrintResults(AR, PrintNoAlias, *I1, *I2, F.getParent());
157  ++NoAliasCount;
158  break;
159  case MayAlias:
160  PrintResults(AR, PrintMayAlias, *I1, *I2, F.getParent());
161  ++MayAliasCount;
162  break;
163  case PartialAlias:
164  PrintResults(AR, PrintPartialAlias, *I1, *I2, F.getParent());
165  ++PartialAliasCount;
166  break;
167  case MustAlias:
168  PrintResults(AR, PrintMustAlias, *I1, *I2, F.getParent());
169  ++MustAliasCount;
170  break;
171  }
172  }
173  }
174 
175  if (EvalAAMD) {
176  // iterate over all pairs of load, store
177  for (Value *Load : Loads) {
178  for (Value *Store : Stores) {
179  AliasResult AR = AA.alias(MemoryLocation::get(cast<LoadInst>(Load)),
180  MemoryLocation::get(cast<StoreInst>(Store)));
181  switch (AR) {
182  case NoAlias:
184  ++NoAliasCount;
185  break;
186  case MayAlias:
188  ++MayAliasCount;
189  break;
190  case PartialAlias:
192  ++PartialAliasCount;
193  break;
194  case MustAlias:
196  ++MustAliasCount;
197  break;
198  }
199  }
200  }
201 
202  // iterate over all pairs of store, store
203  for (SetVector<Value *>::iterator I1 = Stores.begin(), E = Stores.end();
204  I1 != E; ++I1) {
205  for (SetVector<Value *>::iterator I2 = Stores.begin(); I2 != I1; ++I2) {
206  AliasResult AR = AA.alias(MemoryLocation::get(cast<StoreInst>(*I1)),
207  MemoryLocation::get(cast<StoreInst>(*I2)));
208  switch (AR) {
209  case NoAlias:
210  PrintLoadStoreResults(AR, PrintNoAlias, *I1, *I2, F.getParent());
211  ++NoAliasCount;
212  break;
213  case MayAlias:
214  PrintLoadStoreResults(AR, PrintMayAlias, *I1, *I2, F.getParent());
215  ++MayAliasCount;
216  break;
217  case PartialAlias:
219  ++PartialAliasCount;
220  break;
221  case MustAlias:
222  PrintLoadStoreResults(AR, PrintMustAlias, *I1, *I2, F.getParent());
223  ++MustAliasCount;
224  break;
225  }
226  }
227  }
228  }
229 
230  // Mod/ref alias analysis: compare all pairs of calls and values
231  for (CallSite C : CallSites) {
232  Instruction *I = C.getInstruction();
233 
234  for (auto Pointer : Pointers) {
236  Type *ElTy = cast<PointerType>(Pointer->getType())->getElementType();
237  if (ElTy->isSized()) Size = DL.getTypeStoreSize(ElTy);
238 
239  switch (AA.getModRefInfo(C, Pointer, Size)) {
241  PrintModRefResults("NoModRef", PrintNoModRef, I, Pointer,
242  F.getParent());
243  ++NoModRefCount;
244  break;
245  case ModRefInfo::Mod:
246  PrintModRefResults("Just Mod", PrintMod, I, Pointer, F.getParent());
247  ++ModCount;
248  break;
249  case ModRefInfo::Ref:
250  PrintModRefResults("Just Ref", PrintRef, I, Pointer, F.getParent());
251  ++RefCount;
252  break;
253  case ModRefInfo::ModRef:
254  PrintModRefResults("Both ModRef", PrintModRef, I, Pointer,
255  F.getParent());
256  ++ModRefCount;
257  break;
258  case ModRefInfo::Must:
259  PrintModRefResults("Must", PrintMust, I, Pointer, F.getParent());
260  ++MustCount;
261  break;
262  case ModRefInfo::MustMod:
263  PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, I, Pointer,
264  F.getParent());
265  ++MustModCount;
266  break;
267  case ModRefInfo::MustRef:
268  PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, I, Pointer,
269  F.getParent());
270  ++MustRefCount;
271  break;
273  PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, I,
274  Pointer, F.getParent());
275  ++MustModRefCount;
276  break;
277  }
278  }
279  }
280 
281  // Mod/ref alias analysis: compare all pairs of calls
282  for (auto C = CallSites.begin(), Ce = CallSites.end(); C != Ce; ++C) {
283  for (auto D = CallSites.begin(); D != Ce; ++D) {
284  if (D == C)
285  continue;
286  switch (AA.getModRefInfo(*C, *D)) {
288  PrintModRefResults("NoModRef", PrintNoModRef, *C, *D, F.getParent());
289  ++NoModRefCount;
290  break;
291  case ModRefInfo::Mod:
292  PrintModRefResults("Just Mod", PrintMod, *C, *D, F.getParent());
293  ++ModCount;
294  break;
295  case ModRefInfo::Ref:
296  PrintModRefResults("Just Ref", PrintRef, *C, *D, F.getParent());
297  ++RefCount;
298  break;
299  case ModRefInfo::ModRef:
300  PrintModRefResults("Both ModRef", PrintModRef, *C, *D, F.getParent());
301  ++ModRefCount;
302  break;
303  case ModRefInfo::Must:
304  PrintModRefResults("Must", PrintMust, *C, *D, F.getParent());
305  ++MustCount;
306  break;
307  case ModRefInfo::MustMod:
308  PrintModRefResults("Just Mod (MustAlias)", PrintMustMod, *C, *D,
309  F.getParent());
310  ++MustModCount;
311  break;
312  case ModRefInfo::MustRef:
313  PrintModRefResults("Just Ref (MustAlias)", PrintMustRef, *C, *D,
314  F.getParent());
315  ++MustRefCount;
316  break;
318  PrintModRefResults("Both ModRef (MustAlias)", PrintMustModRef, *C, *D,
319  F.getParent());
320  ++MustModRefCount;
321  break;
322  }
323  }
324  }
325 }
326 
327 static void PrintPercent(int64_t Num, int64_t Sum) {
328  errs() << "(" << Num * 100LL / Sum << "." << ((Num * 1000LL / Sum) % 10)
329  << "%)\n";
330 }
331 
333  if (FunctionCount == 0)
334  return;
335 
336  int64_t AliasSum =
337  NoAliasCount + MayAliasCount + PartialAliasCount + MustAliasCount;
338  errs() << "===== Alias Analysis Evaluator Report =====\n";
339  if (AliasSum == 0) {
340  errs() << " Alias Analysis Evaluator Summary: No pointers!\n";
341  } else {
342  errs() << " " << AliasSum << " Total Alias Queries Performed\n";
343  errs() << " " << NoAliasCount << " no alias responses ";
344  PrintPercent(NoAliasCount, AliasSum);
345  errs() << " " << MayAliasCount << " may alias responses ";
346  PrintPercent(MayAliasCount, AliasSum);
347  errs() << " " << PartialAliasCount << " partial alias responses ";
348  PrintPercent(PartialAliasCount, AliasSum);
349  errs() << " " << MustAliasCount << " must alias responses ";
350  PrintPercent(MustAliasCount, AliasSum);
351  errs() << " Alias Analysis Evaluator Pointer Alias Summary: "
352  << NoAliasCount * 100 / AliasSum << "%/"
353  << MayAliasCount * 100 / AliasSum << "%/"
354  << PartialAliasCount * 100 / AliasSum << "%/"
355  << MustAliasCount * 100 / AliasSum << "%\n";
356  }
357 
358  // Display the summary for mod/ref analysis
359  int64_t ModRefSum = NoModRefCount + RefCount + ModCount + ModRefCount +
360  MustCount + MustRefCount + MustModCount + MustModRefCount;
361  if (ModRefSum == 0) {
362  errs() << " Alias Analysis Mod/Ref Evaluator Summary: no "
363  "mod/ref!\n";
364  } else {
365  errs() << " " << ModRefSum << " Total ModRef Queries Performed\n";
366  errs() << " " << NoModRefCount << " no mod/ref responses ";
367  PrintPercent(NoModRefCount, ModRefSum);
368  errs() << " " << ModCount << " mod responses ";
369  PrintPercent(ModCount, ModRefSum);
370  errs() << " " << RefCount << " ref responses ";
371  PrintPercent(RefCount, ModRefSum);
372  errs() << " " << ModRefCount << " mod & ref responses ";
373  PrintPercent(ModRefCount, ModRefSum);
374  errs() << " " << MustCount << " must responses ";
375  PrintPercent(MustCount, ModRefSum);
376  errs() << " " << MustModCount << " must mod responses ";
377  PrintPercent(MustModCount, ModRefSum);
378  errs() << " " << MustRefCount << " must ref responses ";
379  PrintPercent(MustRefCount, ModRefSum);
380  errs() << " " << MustModRefCount << " must mod & ref responses ";
381  PrintPercent(MustModRefCount, ModRefSum);
382  errs() << " Alias Analysis Evaluator Mod/Ref Summary: "
383  << NoModRefCount * 100 / ModRefSum << "%/"
384  << ModCount * 100 / ModRefSum << "%/" << RefCount * 100 / ModRefSum
385  << "%/" << ModRefCount * 100 / ModRefSum << "%/"
386  << MustCount * 100 / ModRefSum << "%/"
387  << MustRefCount * 100 / ModRefSum << "%/"
388  << MustModCount * 100 / ModRefSum << "%/"
389  << MustModRefCount * 100 / ModRefSum << "%\n";
390  }
391 }
392 
393 namespace llvm {
395  std::unique_ptr<AAEvaluator> P;
396 
397 public:
398  static char ID; // Pass identification, replacement for typeid
401  }
402 
403  void getAnalysisUsage(AnalysisUsage &AU) const override {
405  AU.setPreservesAll();
406  }
407 
408  bool doInitialization(Module &M) override {
409  P.reset(new AAEvaluator());
410  return false;
411  }
412 
413  bool runOnFunction(Function &F) override {
414  P->runInternal(F, getAnalysis<AAResultsWrapperPass>().getAAResults());
415  return false;
416  }
417  bool doFinalization(Module &M) override {
418  P.reset();
419  return false;
420  }
421 };
422 }
423 
424 char AAEvalLegacyPass::ID = 0;
426  "Exhaustive Alias Analysis Precision Evaluator", false,
427  true)
430  "Exhaustive Alias Analysis Precision Evaluator", false,
431  true)
432 
The access may reference and may modify the value stored in memory.
static cl::opt< bool > PrintPartialAlias("print-partial-aliases", cl::ReallyHidden)
uint64_t CallInst * C
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
The access neither references nor modifies the value stored in memory.
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:687
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:78
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
bool isSized(SmallPtrSetImpl< Type *> *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:262
void initializeAAEvalLegacyPassPass(PassRegistry &)
This file implements a simple N^2 alias analysis accuracy evaluator.
static void PrintModRefResults(const char *Msg, bool P, Instruction *I, Value *Ptr, Module *M)
static cl::opt< bool > PrintMod("print-mod", cl::ReallyHidden)
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
static cl::opt< bool > PrintModRef("print-modref", cl::ReallyHidden)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Run the pass over the function.
FunctionPass * createAAEvalPass()
Create a wrapper of the above for the legacy pass manager.
F(f)
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:93
op_iterator op_begin()
Definition: User.h:230
static cl::opt< bool > PrintMustAlias("print-must-aliases", cl::ReallyHidden)
static void PrintResults(AliasResult AR, bool P, const Value *V1, const Value *V2, const Module *M)
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
The main low level interface to the alias analysis implementation.
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
inst_iterator inst_begin(Function *F)
Definition: InstIterator.h:132
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:361
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
Must is provided for completeness, but no routines will return only Must today.
The access may reference the value stored in memory, a mustAlias relation was found, and no mayAlias or partialAlias found.
The access may reference the value stored in memory.
InstrTy * getInstruction() const
Definition: CallSite.h:92
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:142
The access may reference, modify or both the value stored in memory, a mustAlias relation was found...
The access may modify the value stored in memory, a mustAlias relation was found, and no mayAlias or ...
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:83
INITIALIZE_PASS_BEGIN(AAEvalLegacyPass, "aa-eval", "Exhaustive Alias Analysis Precision Evaluator", false, true) INITIALIZE_PASS_END(AAEvalLegacyPass
static bool isInterestingPointer(Value *V)
amdgpu Simplify well known AMD library false Value * Callee
AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:79
static cl::opt< bool > PrintRef("print-ref", cl::ReallyHidden)
#define P(N)
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static cl::opt< bool > PrintMayAlias("print-may-aliases", cl::ReallyHidden)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:221
A manager for alias analyses.
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
Represent the analysis usage information of a pass.
op_iterator op_end()
Definition: User.h:232
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:159
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:4112
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
The two locations may or may not alias. This is the least precise result.
Definition: AliasAnalysis.h:87
This class evaluates LLVM IR, producing the Constant representing each SSA instruction.
Definition: Evaluator.h:38
The two locations precisely alias each other.
Definition: AliasAnalysis.h:91
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:298
Module.h This file contains the declarations for the Module class.
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
The access may modify the value stored in memory.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:924
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
getModRefInfo (for call sites) - Return information about whether a particular call site modifies or ...
void setPreservesAll()
Set by analyses that do not transform their input at all.
static cl::opt< bool > PrintMust("print-must", cl::ReallyHidden)
static cl::opt< bool > PrintMustMod("print-mustmod", cl::ReallyHidden)
static void PrintPercent(int64_t Num, int64_t Sum)
static void PrintLoadStoreResults(AliasResult AR, bool P, const Value *V1, const Value *V2, const Module *M)
Basic Alias true
block Block Frequency Analysis
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
static cl::opt< bool > EvalAAMD("evaluate-aa-metadata", cl::ReallyHidden)
#define I(x, y, z)
Definition: MD5.cpp:58
static cl::opt< bool > PrintNoModRef("print-no-modref", cl::ReallyHidden)
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:477
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:73
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:411
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
static cl::opt< bool > PrintMustRef("print-mustref", cl::ReallyHidden)
inst_iterator inst_end(Function *F)
Definition: InstIterator.h:133
A container for analyses that lazily runs them and caches their results.
static cl::opt< bool > PrintAll("print-all-alias-modref-info", cl::ReallyHidden)
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object...
The two locations alias, but only due to a partial overlap.
Definition: AliasAnalysis.h:89
static cl::opt< bool > PrintNoAlias("print-no-aliases", cl::ReallyHidden)
static cl::opt< bool > PrintMustModRef("print-mustmodref", cl::ReallyHidden)
iterator_range< arg_iterator > args()
Definition: Function.h:675
bool doInitialization(Module &M) override
doInitialization - Virtual method overridden by subclasses to do any necessary initialization before ...