LLVM  7.0.0svn
GlobalsModRef.cpp
Go to the documentation of this file.
1 //===- GlobalsModRef.cpp - Simple Mod/Ref Analysis for Globals ------------===//
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 //
10 // This simple pass provides alias and mod/ref information for global values
11 // that do not have their address taken, and keeps track of whether functions
12 // read or write memory (are "pure"). For this simple (but very common) case,
13 // we can provide pretty accurate and useful information.
14 //
15 //===----------------------------------------------------------------------===//
16 
18 #include "llvm/ADT/SCCIterator.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/ADT/Statistic.h"
24 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/InstIterator.h"
26 #include "llvm/IR/Instructions.h"
27 #include "llvm/IR/IntrinsicInst.h"
28 #include "llvm/IR/Module.h"
29 #include "llvm/Pass.h"
31 using namespace llvm;
32 
33 #define DEBUG_TYPE "globalsmodref-aa"
34 
35 STATISTIC(NumNonAddrTakenGlobalVars,
36  "Number of global vars without address taken");
37 STATISTIC(NumNonAddrTakenFunctions,"Number of functions without address taken");
38 STATISTIC(NumNoMemFunctions, "Number of functions that do not access memory");
39 STATISTIC(NumReadMemFunctions, "Number of functions that only read memory");
40 STATISTIC(NumIndirectGlobalVars, "Number of indirect global objects");
41 
42 // An option to enable unsafe alias results from the GlobalsModRef analysis.
43 // When enabled, GlobalsModRef will provide no-alias results which in extremely
44 // rare cases may not be conservatively correct. In particular, in the face of
45 // transforms which cause assymetry between how effective GetUnderlyingObject
46 // is for two pointers, it may produce incorrect results.
47 //
48 // These unsafe results have been returned by GMR for many years without
49 // causing significant issues in the wild and so we provide a mechanism to
50 // re-enable them for users of LLVM that have a particular performance
51 // sensitivity and no known issues. The option also makes it easy to evaluate
52 // the performance impact of these results.
54  "enable-unsafe-globalsmodref-alias-results", cl::init(false), cl::Hidden);
55 
56 /// The mod/ref information collected for a particular function.
57 ///
58 /// We collect information about mod/ref behavior of a function here, both in
59 /// general and as pertains to specific globals. We only have this detailed
60 /// information when we know *something* useful about the behavior. If we
61 /// saturate to fully general mod/ref, we remove the info for the function.
64 
65  /// Build a wrapper struct that has 8-byte alignment. All heap allocations
66  /// should provide this much alignment at least, but this makes it clear we
67  /// specifically rely on this amount of alignment.
68  struct LLVM_ALIGNAS(8) AlignedMap {
69  AlignedMap() {}
70  AlignedMap(const AlignedMap &Arg) : Map(Arg.Map) {}
71  GlobalInfoMapType Map;
72  };
73 
74  /// Pointer traits for our aligned map.
75  struct AlignedMapPointerTraits {
76  static inline void *getAsVoidPointer(AlignedMap *P) { return P; }
77  static inline AlignedMap *getFromVoidPointer(void *P) {
78  return (AlignedMap *)P;
79  }
80  enum { NumLowBitsAvailable = 3 };
81  static_assert(alignof(AlignedMap) >= (1 << NumLowBitsAvailable),
82  "AlignedMap insufficiently aligned to have enough low bits.");
83  };
84 
85  /// The bit that flags that this function may read any global. This is
86  /// chosen to mix together with ModRefInfo bits.
87  /// FIXME: This assumes ModRefInfo lattice will remain 4 bits!
88  /// It overlaps with ModRefInfo::Must bit!
89  /// FunctionInfo.getModRefInfo() masks out everything except ModRef so
90  /// this remains correct, but the Must info is lost.
91  enum { MayReadAnyGlobal = 4 };
92 
93  /// Checks to document the invariants of the bit packing here.
94  static_assert((MayReadAnyGlobal & static_cast<int>(ModRefInfo::MustModRef)) ==
95  0,
96  "ModRef and the MayReadAnyGlobal flag bits overlap.");
97  static_assert(((MayReadAnyGlobal |
98  static_cast<int>(ModRefInfo::MustModRef)) >>
99  AlignedMapPointerTraits::NumLowBitsAvailable) == 0,
100  "Insufficient low bits to store our flag and ModRef info.");
101 
102 public:
103  FunctionInfo() : Info() {}
105  delete Info.getPointer();
106  }
107  // Spell out the copy ond move constructors and assignment operators to get
108  // deep copy semantics and correct move semantics in the face of the
109  // pointer-int pair.
111  : Info(nullptr, Arg.Info.getInt()) {
112  if (const auto *ArgPtr = Arg.Info.getPointer())
113  Info.setPointer(new AlignedMap(*ArgPtr));
114  }
116  : Info(Arg.Info.getPointer(), Arg.Info.getInt()) {
117  Arg.Info.setPointerAndInt(nullptr, 0);
118  }
120  delete Info.getPointer();
121  Info.setPointerAndInt(nullptr, RHS.Info.getInt());
122  if (const auto *RHSPtr = RHS.Info.getPointer())
123  Info.setPointer(new AlignedMap(*RHSPtr));
124  return *this;
125  }
127  delete Info.getPointer();
128  Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
129  RHS.Info.setPointerAndInt(nullptr, 0);
130  return *this;
131  }
132 
133  /// This method clears MayReadAnyGlobal bit added by GlobalsAAResult to return
134  /// the corresponding ModRefInfo. It must align in functionality with
135  /// clearMust().
137  return ModRefInfo((I & static_cast<int>(ModRefInfo::ModRef)) |
138  static_cast<int>(ModRefInfo::NoModRef));
139  }
140 
141  /// Returns the \c ModRefInfo info for this function.
143  return globalClearMayReadAnyGlobal(Info.getInt());
144  }
145 
146  /// Adds new \c ModRefInfo for this function to its state.
147  void addModRefInfo(ModRefInfo NewMRI) {
148  Info.setInt(Info.getInt() | static_cast<int>(setMust(NewMRI)));
149  }
150 
151  /// Returns whether this function may read any global variable, and we don't
152  /// know which global.
153  bool mayReadAnyGlobal() const { return Info.getInt() & MayReadAnyGlobal; }
154 
155  /// Sets this function as potentially reading from any global.
156  void setMayReadAnyGlobal() { Info.setInt(Info.getInt() | MayReadAnyGlobal); }
157 
158  /// Returns the \c ModRefInfo info for this function w.r.t. a particular
159  /// global, which may be more precise than the general information above.
161  ModRefInfo GlobalMRI =
163  if (AlignedMap *P = Info.getPointer()) {
164  auto I = P->Map.find(&GV);
165  if (I != P->Map.end())
166  GlobalMRI = unionModRef(GlobalMRI, I->second);
167  }
168  return GlobalMRI;
169  }
170 
171  /// Add mod/ref info from another function into ours, saturating towards
172  /// ModRef.
173  void addFunctionInfo(const FunctionInfo &FI) {
175 
176  if (FI.mayReadAnyGlobal())
178 
179  if (AlignedMap *P = FI.Info.getPointer())
180  for (const auto &G : P->Map)
181  addModRefInfoForGlobal(*G.first, G.second);
182  }
183 
185  AlignedMap *P = Info.getPointer();
186  if (!P) {
187  P = new AlignedMap();
188  Info.setPointer(P);
189  }
190  auto &GlobalMRI = P->Map[&GV];
191  GlobalMRI = unionModRef(GlobalMRI, NewMRI);
192  }
193 
194  /// Clear a global's ModRef info. Should be used when a global is being
195  /// deleted.
197  if (AlignedMap *P = Info.getPointer())
198  P->Map.erase(&GV);
199  }
200 
201 private:
202  /// All of the information is encoded into a single pointer, with a three bit
203  /// integer in the low three bits. The high bit provides a flag for when this
204  /// function may read any global. The low two bits are the ModRefInfo. And
205  /// the pointer, when non-null, points to a map from GlobalValue to
206  /// ModRefInfo specific to that GlobalValue.
208 };
209 
210 void GlobalsAAResult::DeletionCallbackHandle::deleted() {
211  Value *V = getValPtr();
212  if (auto *F = dyn_cast<Function>(V))
213  GAR->FunctionInfos.erase(F);
214 
215  if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
216  if (GAR->NonAddressTakenGlobals.erase(GV)) {
217  // This global might be an indirect global. If so, remove it and
218  // remove any AllocRelatedValues for it.
219  if (GAR->IndirectGlobals.erase(GV)) {
220  // Remove any entries in AllocsForIndirectGlobals for this global.
221  for (auto I = GAR->AllocsForIndirectGlobals.begin(),
222  E = GAR->AllocsForIndirectGlobals.end();
223  I != E; ++I)
224  if (I->second == GV)
225  GAR->AllocsForIndirectGlobals.erase(I);
226  }
227 
228  // Scan the function info we have collected and remove this global
229  // from all of them.
230  for (auto &FIPair : GAR->FunctionInfos)
231  FIPair.second.eraseModRefInfoForGlobal(*GV);
232  }
233  }
234 
235  // If this is an allocation related to an indirect global, remove it.
236  GAR->AllocsForIndirectGlobals.erase(V);
237 
238  // And clear out the handle.
239  setValPtr(nullptr);
240  GAR->Handles.erase(I);
241  // This object is now destroyed!
242 }
243 
246 
247  if (FunctionInfo *FI = getFunctionInfo(F)) {
248  if (!isModOrRefSet(FI->getModRefInfo()))
250  else if (!isModSet(FI->getModRefInfo()))
251  Min = FMRB_OnlyReadsMemory;
252  }
253 
255 }
256 
260 
261  if (!CS.hasOperandBundles())
262  if (const Function *F = CS.getCalledFunction())
263  if (FunctionInfo *FI = getFunctionInfo(F)) {
264  if (!isModOrRefSet(FI->getModRefInfo()))
266  else if (!isModSet(FI->getModRefInfo()))
267  Min = FMRB_OnlyReadsMemory;
268  }
269 
271 }
272 
273 /// Returns the function info for the function, or null if we don't have
274 /// anything useful to say about it.
276 GlobalsAAResult::getFunctionInfo(const Function *F) {
277  auto I = FunctionInfos.find(F);
278  if (I != FunctionInfos.end())
279  return &I->second;
280  return nullptr;
281 }
282 
283 /// AnalyzeGlobals - Scan through the users of all of the internal
284 /// GlobalValue's in the program. If none of them have their "address taken"
285 /// (really, their address passed to something nontrivial), record this fact,
286 /// and record the functions that they are used directly in.
287 void GlobalsAAResult::AnalyzeGlobals(Module &M) {
288  SmallPtrSet<Function *, 32> TrackedFunctions;
289  for (Function &F : M)
290  if (F.hasLocalLinkage())
291  if (!AnalyzeUsesOfPointer(&F)) {
292  // Remember that we are tracking this global.
293  NonAddressTakenGlobals.insert(&F);
294  TrackedFunctions.insert(&F);
295  Handles.emplace_front(*this, &F);
296  Handles.front().I = Handles.begin();
297  ++NumNonAddrTakenFunctions;
298  }
299 
300  SmallPtrSet<Function *, 16> Readers, Writers;
301  for (GlobalVariable &GV : M.globals())
302  if (GV.hasLocalLinkage()) {
303  if (!AnalyzeUsesOfPointer(&GV, &Readers,
304  GV.isConstant() ? nullptr : &Writers)) {
305  // Remember that we are tracking this global, and the mod/ref fns
306  NonAddressTakenGlobals.insert(&GV);
307  Handles.emplace_front(*this, &GV);
308  Handles.front().I = Handles.begin();
309 
310  for (Function *Reader : Readers) {
311  if (TrackedFunctions.insert(Reader).second) {
312  Handles.emplace_front(*this, Reader);
313  Handles.front().I = Handles.begin();
314  }
315  FunctionInfos[Reader].addModRefInfoForGlobal(GV, ModRefInfo::Ref);
316  }
317 
318  if (!GV.isConstant()) // No need to keep track of writers to constants
319  for (Function *Writer : Writers) {
320  if (TrackedFunctions.insert(Writer).second) {
321  Handles.emplace_front(*this, Writer);
322  Handles.front().I = Handles.begin();
323  }
324  FunctionInfos[Writer].addModRefInfoForGlobal(GV, ModRefInfo::Mod);
325  }
326  ++NumNonAddrTakenGlobalVars;
327 
328  // If this global holds a pointer type, see if it is an indirect global.
329  if (GV.getValueType()->isPointerTy() &&
330  AnalyzeIndirectGlobalMemory(&GV))
331  ++NumIndirectGlobalVars;
332  }
333  Readers.clear();
334  Writers.clear();
335  }
336 }
337 
338 /// AnalyzeUsesOfPointer - Look at all of the users of the specified pointer.
339 /// If this is used by anything complex (i.e., the address escapes), return
340 /// true. Also, while we are at it, keep track of those functions that read and
341 /// write to the value.
342 ///
343 /// If OkayStoreDest is non-null, stores into this global are allowed.
344 bool GlobalsAAResult::AnalyzeUsesOfPointer(Value *V,
347  GlobalValue *OkayStoreDest) {
348  if (!V->getType()->isPointerTy())
349  return true;
350 
351  for (Use &U : V->uses()) {
352  User *I = U.getUser();
353  if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
354  if (Readers)
355  Readers->insert(LI->getParent()->getParent());
356  } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
357  if (V == SI->getOperand(1)) {
358  if (Writers)
359  Writers->insert(SI->getParent()->getParent());
360  } else if (SI->getOperand(1) != OkayStoreDest) {
361  return true; // Storing the pointer
362  }
363  } else if (Operator::getOpcode(I) == Instruction::GetElementPtr) {
364  if (AnalyzeUsesOfPointer(I, Readers, Writers))
365  return true;
366  } else if (Operator::getOpcode(I) == Instruction::BitCast) {
367  if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest))
368  return true;
369  } else if (auto CS = CallSite(I)) {
370  // Make sure that this is just the function being called, not that it is
371  // passing into the function.
372  if (CS.isDataOperand(&U)) {
373  // Detect calls to free.
374  if (CS.isArgOperand(&U) && isFreeCall(I, &TLI)) {
375  if (Writers)
376  Writers->insert(CS->getParent()->getParent());
377  } else {
378  return true; // Argument of an unknown call.
379  }
380  }
381  } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
382  if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
383  return true; // Allow comparison against null.
384  } else if (Constant *C = dyn_cast<Constant>(I)) {
385  // Ignore constants which don't have any live uses.
386  if (isa<GlobalValue>(C) || C->isConstantUsed())
387  return true;
388  } else {
389  return true;
390  }
391  }
392 
393  return false;
394 }
395 
396 /// AnalyzeIndirectGlobalMemory - We found an non-address-taken global variable
397 /// which holds a pointer type. See if the global always points to non-aliased
398 /// heap memory: that is, all initializers of the globals are allocations, and
399 /// those allocations have no use other than initialization of the global.
400 /// Further, all loads out of GV must directly use the memory, not store the
401 /// pointer somewhere. If this is true, we consider the memory pointed to by
402 /// GV to be owned by GV and can disambiguate other pointers from it.
403 bool GlobalsAAResult::AnalyzeIndirectGlobalMemory(GlobalVariable *GV) {
404  // Keep track of values related to the allocation of the memory, f.e. the
405  // value produced by the malloc call and any casts.
406  std::vector<Value *> AllocRelatedValues;
407 
408  // If the initializer is a valid pointer, bail.
409  if (Constant *C = GV->getInitializer())
410  if (!C->isNullValue())
411  return false;
412 
413  // Walk the user list of the global. If we find anything other than a direct
414  // load or store, bail out.
415  for (User *U : GV->users()) {
416  if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
417  // The pointer loaded from the global can only be used in simple ways:
418  // we allow addressing of it and loading storing to it. We do *not* allow
419  // storing the loaded pointer somewhere else or passing to a function.
420  if (AnalyzeUsesOfPointer(LI))
421  return false; // Loaded pointer escapes.
422  // TODO: Could try some IP mod/ref of the loaded pointer.
423  } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
424  // Storing the global itself.
425  if (SI->getOperand(0) == GV)
426  return false;
427 
428  // If storing the null pointer, ignore it.
429  if (isa<ConstantPointerNull>(SI->getOperand(0)))
430  continue;
431 
432  // Check the value being stored.
433  Value *Ptr = GetUnderlyingObject(SI->getOperand(0),
434  GV->getParent()->getDataLayout());
435 
436  if (!isAllocLikeFn(Ptr, &TLI))
437  return false; // Too hard to analyze.
438 
439  // Analyze all uses of the allocation. If any of them are used in a
440  // non-simple way (e.g. stored to another global) bail out.
441  if (AnalyzeUsesOfPointer(Ptr, /*Readers*/ nullptr, /*Writers*/ nullptr,
442  GV))
443  return false; // Loaded pointer escapes.
444 
445  // Remember that this allocation is related to the indirect global.
446  AllocRelatedValues.push_back(Ptr);
447  } else {
448  // Something complex, bail out.
449  return false;
450  }
451  }
452 
453  // Okay, this is an indirect global. Remember all of the allocations for
454  // this global in AllocsForIndirectGlobals.
455  while (!AllocRelatedValues.empty()) {
456  AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
457  Handles.emplace_front(*this, AllocRelatedValues.back());
458  Handles.front().I = Handles.begin();
459  AllocRelatedValues.pop_back();
460  }
461  IndirectGlobals.insert(GV);
462  Handles.emplace_front(*this, GV);
463  Handles.front().I = Handles.begin();
464  return true;
465 }
466 
467 void GlobalsAAResult::CollectSCCMembership(CallGraph &CG) {
468  // We do a bottom-up SCC traversal of the call graph. In other words, we
469  // visit all callees before callers (leaf-first).
470  unsigned SCCID = 0;
471  for (scc_iterator<CallGraph *> I = scc_begin(&CG); !I.isAtEnd(); ++I) {
472  const std::vector<CallGraphNode *> &SCC = *I;
473  assert(!SCC.empty() && "SCC with no functions?");
474 
475  for (auto *CGN : SCC)
476  if (Function *F = CGN->getFunction())
477  FunctionToSCCMap[F] = SCCID;
478  ++SCCID;
479  }
480 }
481 
482 /// AnalyzeCallGraph - At this point, we know the functions where globals are
483 /// immediately stored to and read from. Propagate this information up the call
484 /// graph to all callers and compute the mod/ref info for all memory for each
485 /// function.
486 void GlobalsAAResult::AnalyzeCallGraph(CallGraph &CG, Module &M) {
487  // We do a bottom-up SCC traversal of the call graph. In other words, we
488  // visit all callees before callers (leaf-first).
489  for (scc_iterator<CallGraph *> I = scc_begin(&CG); !I.isAtEnd(); ++I) {
490  const std::vector<CallGraphNode *> &SCC = *I;
491  assert(!SCC.empty() && "SCC with no functions?");
492 
493  Function *F = SCC[0]->getFunction();
494 
495  if (!F || !F->isDefinitionExact()) {
496  // Calls externally or not exact - can't say anything useful. Remove any
497  // existing function records (may have been created when scanning
498  // globals).
499  for (auto *Node : SCC)
500  FunctionInfos.erase(Node->getFunction());
501  continue;
502  }
503 
504  FunctionInfo &FI = FunctionInfos[F];
505  Handles.emplace_front(*this, F);
506  Handles.front().I = Handles.begin();
507  bool KnowNothing = false;
508 
509  // Collect the mod/ref properties due to called functions. We only compute
510  // one mod-ref set.
511  for (unsigned i = 0, e = SCC.size(); i != e && !KnowNothing; ++i) {
512  if (!F) {
513  KnowNothing = true;
514  break;
515  }
516 
517  if (F->isDeclaration() || F->hasFnAttribute(Attribute::OptimizeNone)) {
518  // Try to get mod/ref behaviour from function attributes.
519  if (F->doesNotAccessMemory()) {
520  // Can't do better than that!
521  } else if (F->onlyReadsMemory()) {
523  if (!F->isIntrinsic() && !F->onlyAccessesArgMemory())
524  // This function might call back into the module and read a global -
525  // consider every global as possibly being read by this function.
526  FI.setMayReadAnyGlobal();
527  } else {
529  // Can't say anything useful unless it's an intrinsic - they don't
530  // read or write global variables of the kind considered here.
531  KnowNothing = !F->isIntrinsic();
532  }
533  continue;
534  }
535 
536  for (CallGraphNode::iterator CI = SCC[i]->begin(), E = SCC[i]->end();
537  CI != E && !KnowNothing; ++CI)
538  if (Function *Callee = CI->second->getFunction()) {
539  if (FunctionInfo *CalleeFI = getFunctionInfo(Callee)) {
540  // Propagate function effect up.
541  FI.addFunctionInfo(*CalleeFI);
542  } else {
543  // Can't say anything about it. However, if it is inside our SCC,
544  // then nothing needs to be done.
545  CallGraphNode *CalleeNode = CG[Callee];
546  if (!is_contained(SCC, CalleeNode))
547  KnowNothing = true;
548  }
549  } else {
550  KnowNothing = true;
551  }
552  }
553 
554  // If we can't say anything useful about this SCC, remove all SCC functions
555  // from the FunctionInfos map.
556  if (KnowNothing) {
557  for (auto *Node : SCC)
558  FunctionInfos.erase(Node->getFunction());
559  continue;
560  }
561 
562  // Scan the function bodies for explicit loads or stores.
563  for (auto *Node : SCC) {
564  if (isModAndRefSet(FI.getModRefInfo()))
565  break; // The mod/ref lattice saturates here.
566 
567  // Don't prove any properties based on the implementation of an optnone
568  // function. Function attributes were already used as a best approximation
569  // above.
570  if (Node->getFunction()->hasFnAttribute(Attribute::OptimizeNone))
571  continue;
572 
573  for (Instruction &I : instructions(Node->getFunction())) {
574  if (isModAndRefSet(FI.getModRefInfo()))
575  break; // The mod/ref lattice saturates here.
576 
577  // We handle calls specially because the graph-relevant aspects are
578  // handled above.
579  if (auto CS = CallSite(&I)) {
580  if (isAllocationFn(&I, &TLI) || isFreeCall(&I, &TLI)) {
581  // FIXME: It is completely unclear why this is necessary and not
582  // handled by the above graph code.
584  } else if (Function *Callee = CS.getCalledFunction()) {
585  // The callgraph doesn't include intrinsic calls.
586  if (Callee->isIntrinsic()) {
587  if (isa<DbgInfoIntrinsic>(I))
588  // Don't let dbg intrinsics affect alias info.
589  continue;
590 
591  FunctionModRefBehavior Behaviour =
593  FI.addModRefInfo(createModRefInfo(Behaviour));
594  }
595  }
596  continue;
597  }
598 
599  // All non-call instructions we use the primary predicates for whether
600  // thay read or write memory.
601  if (I.mayReadFromMemory())
603  if (I.mayWriteToMemory())
605  }
606  }
607 
608  if (!isModSet(FI.getModRefInfo()))
609  ++NumReadMemFunctions;
610  if (!isModOrRefSet(FI.getModRefInfo()))
611  ++NumNoMemFunctions;
612 
613  // Finally, now that we know the full effect on this SCC, clone the
614  // information to each function in the SCC.
615  // FI is a reference into FunctionInfos, so copy it now so that it doesn't
616  // get invalidated if DenseMap decides to re-hash.
617  FunctionInfo CachedFI = FI;
618  for (unsigned i = 1, e = SCC.size(); i != e; ++i)
619  FunctionInfos[SCC[i]->getFunction()] = CachedFI;
620  }
621 }
622 
623 // GV is a non-escaping global. V is a pointer address that has been loaded from.
624 // If we can prove that V must escape, we can conclude that a load from V cannot
625 // alias GV.
627  const Value *V,
628  int &Depth,
629  const DataLayout &DL) {
632  Visited.insert(V);
633  Inputs.push_back(V);
634  do {
635  const Value *Input = Inputs.pop_back_val();
636 
637  if (isa<GlobalValue>(Input) || isa<Argument>(Input) || isa<CallInst>(Input) ||
638  isa<InvokeInst>(Input))
639  // Arguments to functions or returns from functions are inherently
640  // escaping, so we can immediately classify those as not aliasing any
641  // non-addr-taken globals.
642  //
643  // (Transitive) loads from a global are also safe - if this aliased
644  // another global, its address would escape, so no alias.
645  continue;
646 
647  // Recurse through a limited number of selects, loads and PHIs. This is an
648  // arbitrary depth of 4, lower numbers could be used to fix compile time
649  // issues if needed, but this is generally expected to be only be important
650  // for small depths.
651  if (++Depth > 4)
652  return false;
653 
654  if (auto *LI = dyn_cast<LoadInst>(Input)) {
655  Inputs.push_back(GetUnderlyingObject(LI->getPointerOperand(), DL));
656  continue;
657  }
658  if (auto *SI = dyn_cast<SelectInst>(Input)) {
659  const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
660  const Value *RHS = GetUnderlyingObject(SI->getFalseValue(), DL);
661  if (Visited.insert(LHS).second)
662  Inputs.push_back(LHS);
663  if (Visited.insert(RHS).second)
664  Inputs.push_back(RHS);
665  continue;
666  }
667  if (auto *PN = dyn_cast<PHINode>(Input)) {
668  for (const Value *Op : PN->incoming_values()) {
669  Op = GetUnderlyingObject(Op, DL);
670  if (Visited.insert(Op).second)
671  Inputs.push_back(Op);
672  }
673  continue;
674  }
675 
676  return false;
677  } while (!Inputs.empty());
678 
679  // All inputs were known to be no-alias.
680  return true;
681 }
682 
683 // There are particular cases where we can conclude no-alias between
684 // a non-addr-taken global and some other underlying object. Specifically,
685 // a non-addr-taken global is known to not be escaped from any function. It is
686 // also incorrect for a transformation to introduce an escape of a global in
687 // a way that is observable when it was not there previously. One function
688 // being transformed to introduce an escape which could possibly be observed
689 // (via loading from a global or the return value for example) within another
690 // function is never safe. If the observation is made through non-atomic
691 // operations on different threads, it is a data-race and UB. If the
692 // observation is well defined, by being observed the transformation would have
693 // changed program behavior by introducing the observed escape, making it an
694 // invalid transform.
695 //
696 // This property does require that transformations which *temporarily* escape
697 // a global that was not previously escaped, prior to restoring it, cannot rely
698 // on the results of GMR::alias. This seems a reasonable restriction, although
699 // currently there is no way to enforce it. There is also no realistic
700 // optimization pass that would make this mistake. The closest example is
701 // a transformation pass which does reg2mem of SSA values but stores them into
702 // global variables temporarily before restoring the global variable's value.
703 // This could be useful to expose "benign" races for example. However, it seems
704 // reasonable to require that a pass which introduces escapes of global
705 // variables in this way to either not trust AA results while the escape is
706 // active, or to be forced to operate as a module pass that cannot co-exist
707 // with an alias analysis such as GMR.
708 bool GlobalsAAResult::isNonEscapingGlobalNoAlias(const GlobalValue *GV,
709  const Value *V) {
710  // In order to know that the underlying object cannot alias the
711  // non-addr-taken global, we must know that it would have to be an escape.
712  // Thus if the underlying object is a function argument, a load from
713  // a global, or the return of a function, it cannot alias. We can also
714  // recurse through PHI nodes and select nodes provided all of their inputs
715  // resolve to one of these known-escaping roots.
718  Visited.insert(V);
719  Inputs.push_back(V);
720  int Depth = 0;
721  do {
722  const Value *Input = Inputs.pop_back_val();
723 
724  if (auto *InputGV = dyn_cast<GlobalValue>(Input)) {
725  // If one input is the very global we're querying against, then we can't
726  // conclude no-alias.
727  if (InputGV == GV)
728  return false;
729 
730  // Distinct GlobalVariables never alias, unless overriden or zero-sized.
731  // FIXME: The condition can be refined, but be conservative for now.
732  auto *GVar = dyn_cast<GlobalVariable>(GV);
733  auto *InputGVar = dyn_cast<GlobalVariable>(InputGV);
734  if (GVar && InputGVar &&
735  !GVar->isDeclaration() && !InputGVar->isDeclaration() &&
736  !GVar->isInterposable() && !InputGVar->isInterposable()) {
737  Type *GVType = GVar->getInitializer()->getType();
738  Type *InputGVType = InputGVar->getInitializer()->getType();
739  if (GVType->isSized() && InputGVType->isSized() &&
740  (DL.getTypeAllocSize(GVType) > 0) &&
741  (DL.getTypeAllocSize(InputGVType) > 0))
742  continue;
743  }
744 
745  // Conservatively return false, even though we could be smarter
746  // (e.g. look through GlobalAliases).
747  return false;
748  }
749 
750  if (isa<Argument>(Input) || isa<CallInst>(Input) ||
751  isa<InvokeInst>(Input)) {
752  // Arguments to functions or returns from functions are inherently
753  // escaping, so we can immediately classify those as not aliasing any
754  // non-addr-taken globals.
755  continue;
756  }
757 
758  // Recurse through a limited number of selects, loads and PHIs. This is an
759  // arbitrary depth of 4, lower numbers could be used to fix compile time
760  // issues if needed, but this is generally expected to be only be important
761  // for small depths.
762  if (++Depth > 4)
763  return false;
764 
765  if (auto *LI = dyn_cast<LoadInst>(Input)) {
766  // A pointer loaded from a global would have been captured, and we know
767  // that the global is non-escaping, so no alias.
768  const Value *Ptr = GetUnderlyingObject(LI->getPointerOperand(), DL);
769  if (isNonEscapingGlobalNoAliasWithLoad(GV, Ptr, Depth, DL))
770  // The load does not alias with GV.
771  continue;
772  // Otherwise, a load could come from anywhere, so bail.
773  return false;
774  }
775  if (auto *SI = dyn_cast<SelectInst>(Input)) {
776  const Value *LHS = GetUnderlyingObject(SI->getTrueValue(), DL);
777  const Value *RHS = GetUnderlyingObject(SI->getFalseValue(), DL);
778  if (Visited.insert(LHS).second)
779  Inputs.push_back(LHS);
780  if (Visited.insert(RHS).second)
781  Inputs.push_back(RHS);
782  continue;
783  }
784  if (auto *PN = dyn_cast<PHINode>(Input)) {
785  for (const Value *Op : PN->incoming_values()) {
786  Op = GetUnderlyingObject(Op, DL);
787  if (Visited.insert(Op).second)
788  Inputs.push_back(Op);
789  }
790  continue;
791  }
792 
793  // FIXME: It would be good to handle other obvious no-alias cases here, but
794  // it isn't clear how to do so reasonbly without building a small version
795  // of BasicAA into this code. We could recurse into AAResultBase::alias
796  // here but that seems likely to go poorly as we're inside the
797  // implementation of such a query. Until then, just conservatievly retun
798  // false.
799  return false;
800  } while (!Inputs.empty());
801 
802  // If all the inputs to V were definitively no-alias, then V is no-alias.
803  return true;
804 }
805 
806 /// alias - If one of the pointers is to a global that we are tracking, and the
807 /// other is some random pointer, we know there cannot be an alias, because the
808 /// address of the global isn't taken.
810  const MemoryLocation &LocB) {
811  // Get the base object these pointers point to.
812  const Value *UV1 = GetUnderlyingObject(LocA.Ptr, DL);
813  const Value *UV2 = GetUnderlyingObject(LocB.Ptr, DL);
814 
815  // If either of the underlying values is a global, they may be non-addr-taken
816  // globals, which we can answer queries about.
817  const GlobalValue *GV1 = dyn_cast<GlobalValue>(UV1);
818  const GlobalValue *GV2 = dyn_cast<GlobalValue>(UV2);
819  if (GV1 || GV2) {
820  // If the global's address is taken, pretend we don't know it's a pointer to
821  // the global.
822  if (GV1 && !NonAddressTakenGlobals.count(GV1))
823  GV1 = nullptr;
824  if (GV2 && !NonAddressTakenGlobals.count(GV2))
825  GV2 = nullptr;
826 
827  // If the two pointers are derived from two different non-addr-taken
828  // globals we know these can't alias.
829  if (GV1 && GV2 && GV1 != GV2)
830  return NoAlias;
831 
832  // If one is and the other isn't, it isn't strictly safe but we can fake
833  // this result if necessary for performance. This does not appear to be
834  // a common problem in practice.
836  if ((GV1 || GV2) && GV1 != GV2)
837  return NoAlias;
838 
839  // Check for a special case where a non-escaping global can be used to
840  // conclude no-alias.
841  if ((GV1 || GV2) && GV1 != GV2) {
842  const GlobalValue *GV = GV1 ? GV1 : GV2;
843  const Value *UV = GV1 ? UV2 : UV1;
844  if (isNonEscapingGlobalNoAlias(GV, UV))
845  return NoAlias;
846  }
847 
848  // Otherwise if they are both derived from the same addr-taken global, we
849  // can't know the two accesses don't overlap.
850  }
851 
852  // These pointers may be based on the memory owned by an indirect global. If
853  // so, we may be able to handle this. First check to see if the base pointer
854  // is a direct load from an indirect global.
855  GV1 = GV2 = nullptr;
856  if (const LoadInst *LI = dyn_cast<LoadInst>(UV1))
857  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
858  if (IndirectGlobals.count(GV))
859  GV1 = GV;
860  if (const LoadInst *LI = dyn_cast<LoadInst>(UV2))
861  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
862  if (IndirectGlobals.count(GV))
863  GV2 = GV;
864 
865  // These pointers may also be from an allocation for the indirect global. If
866  // so, also handle them.
867  if (!GV1)
868  GV1 = AllocsForIndirectGlobals.lookup(UV1);
869  if (!GV2)
870  GV2 = AllocsForIndirectGlobals.lookup(UV2);
871 
872  // Now that we know whether the two pointers are related to indirect globals,
873  // use this to disambiguate the pointers. If the pointers are based on
874  // different indirect globals they cannot alias.
875  if (GV1 && GV2 && GV1 != GV2)
876  return NoAlias;
877 
878  // If one is based on an indirect global and the other isn't, it isn't
879  // strictly safe but we can fake this result if necessary for performance.
880  // This does not appear to be a common problem in practice.
882  if ((GV1 || GV2) && GV1 != GV2)
883  return NoAlias;
884 
885  return AAResultBase::alias(LocA, LocB);
886 }
887 
888 ModRefInfo GlobalsAAResult::getModRefInfoForArgument(ImmutableCallSite CS,
889  const GlobalValue *GV) {
890  if (CS.doesNotAccessMemory())
891  return ModRefInfo::NoModRef;
892  ModRefInfo ConservativeResult =
894 
895  // Iterate through all the arguments to the called function. If any argument
896  // is based on GV, return the conservative result.
897  for (auto &A : CS.args()) {
898  SmallVector<Value*, 4> Objects;
899  GetUnderlyingObjects(A, Objects, DL);
900 
901  // All objects must be identified.
902  if (!all_of(Objects, isIdentifiedObject) &&
903  // Try ::alias to see if all objects are known not to alias GV.
904  !all_of(Objects, [&](Value *V) {
905  return this->alias(MemoryLocation(V), MemoryLocation(GV)) == NoAlias;
906  }))
907  return ConservativeResult;
908 
909  if (is_contained(Objects, GV))
910  return ConservativeResult;
911  }
912 
913  // We identified all objects in the argument list, and none of them were GV.
914  return ModRefInfo::NoModRef;
915 }
916 
918  const MemoryLocation &Loc) {
920 
921  // If we are asking for mod/ref info of a direct call with a pointer to a
922  // global we are tracking, return information if we have it.
923  if (const GlobalValue *GV =
924  dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))
925  if (GV->hasLocalLinkage())
926  if (const Function *F = CS.getCalledFunction())
927  if (NonAddressTakenGlobals.count(GV))
928  if (const FunctionInfo *FI = getFunctionInfo(F))
929  Known = unionModRef(FI->getModRefInfoForGlobal(*GV),
930  getModRefInfoForArgument(CS, GV));
931 
932  if (!isModOrRefSet(Known))
933  return ModRefInfo::NoModRef; // No need to query other mod/ref analyses
934  return intersectModRef(Known, AAResultBase::getModRefInfo(CS, Loc));
935 }
936 
937 GlobalsAAResult::GlobalsAAResult(const DataLayout &DL,
938  const TargetLibraryInfo &TLI)
939  : AAResultBase(), DL(DL), TLI(TLI) {}
940 
941 GlobalsAAResult::GlobalsAAResult(GlobalsAAResult &&Arg)
942  : AAResultBase(std::move(Arg)), DL(Arg.DL), TLI(Arg.TLI),
943  NonAddressTakenGlobals(std::move(Arg.NonAddressTakenGlobals)),
944  IndirectGlobals(std::move(Arg.IndirectGlobals)),
945  AllocsForIndirectGlobals(std::move(Arg.AllocsForIndirectGlobals)),
946  FunctionInfos(std::move(Arg.FunctionInfos)),
947  Handles(std::move(Arg.Handles)) {
948  // Update the parent for each DeletionCallbackHandle.
949  for (auto &H : Handles) {
950  assert(H.GAR == &Arg);
951  H.GAR = this;
952  }
953 }
954 
956 
957 /*static*/ GlobalsAAResult
959  CallGraph &CG) {
960  GlobalsAAResult Result(M.getDataLayout(), TLI);
961 
962  // Discover which functions aren't recursive, to feed into AnalyzeGlobals.
963  Result.CollectSCCMembership(CG);
964 
965  // Find non-addr taken globals.
966  Result.AnalyzeGlobals(M);
967 
968  // Propagate on CG.
969  Result.AnalyzeCallGraph(CG, M);
970 
971  return Result;
972 }
973 
974 AnalysisKey GlobalsAA::Key;
975 
980 }
981 
982 char GlobalsAAWrapperPass::ID = 0;
984  "Globals Alias Analysis", false, true)
988  "Globals Alias Analysis", false, true)
989 
991  return new GlobalsAAWrapperPass();
992 }
993 
996 }
997 
1000  M, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(),
1001  getAnalysis<CallGraphWrapperPass>().getCallGraph())));
1002  return false;
1003 }
1004 
1006  Result.reset();
1007  return false;
1008 }
1009 
1011  AU.setPreservesAll();
1014 }
Legacy wrapper pass to provide the GlobalsAAResult object.
The access may reference and may modify the value stored in memory.
const Function & getFunction() const
Definition: Function.h:134
LLVM_NODISCARD ModRefInfo unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
uint64_t CallInst * C
bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates or reallocates memory (eith...
This builds on the llvm/ADT/GraphTraits.h file to find the strongly connected components (SCCs) of a ...
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:250
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
iterator_range< use_iterator > uses()
Definition: Value.h:354
The access neither references nor modifies the value stored in memory.
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:241
void addFunctionInfo(const FunctionInfo &FI)
Add mod/ref info from another function into ours, saturating towards ModRef.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:687
void setMayReadAnyGlobal()
Sets this function as potentially reading from any global.
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
globals Globals Alias Analysis
PointerTy getPointer() const
static cl::opt< bool > EnableUnsafeGlobalsModRefAliasResults("enable-unsafe-globalsmodref-alias-results", cl::init(false), cl::Hidden)
FunctionInfo & operator=(const FunctionInfo &RHS)
ModRefInfo getModRefInfoForGlobal(const GlobalValue &GV) const
Returns the ModRefInfo info for this function w.r.t.
This is the interface for a simple mod/ref and alias analysis over globals.
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:265
iterator_range< IterTy > args() const
Definition: CallSite.h:215
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
FunctionInfo & operator=(FunctionInfo &&RHS)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:908
STATISTIC(NumFunctions, "Total number of functions")
F(f)
An instruction for reading from memory.
Definition: Instructions.h:168
A node in the call graph for a module.
Definition: CallGraph.h:165
LLVM_NODISCARD bool isModAndRefSet(const ModRefInfo MRI)
The mod/ref information collected for a particular function.
ModRefInfo globalClearMayReadAnyGlobal(int I) const
This method clears MayReadAnyGlobal bit added by GlobalsAAResult to return the corresponding ModRefIn...
void addModRefInfoForGlobal(const GlobalValue &GV, ModRefInfo NewMRI)
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
This indicates that the function could not be classified into one of the behaviors above...
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:344
bool onlyReadsMemory() const
Determine if the call does not access or only reads memory.
Definition: CallSite.h:454
AnalysisUsage & addRequired()
bool mayReadAnyGlobal() const
Returns whether this function may read any global variable, and we don&#39;t know which global...
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
Definition: BitVector.h:921
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:361
static unsigned getInt(StringRef R)
Get an unsigned integer, including error checks.
Definition: DataLayout.cpp:213
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
The access may reference the value stored in memory.
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
A CRTP-driven "mixin" base class to help implement the function alias analysis results concept...
scc_iterator< T > scc_begin(const T &G)
Construct the begin iterator for a deduced graph type T.
Definition: SCCIterator.h:226
static GlobalsAAResult analyzeModule(Module &M, const TargetLibraryInfo &TLI, CallGraph &CG)
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on...
IntType getInt() const
GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM)
The access may reference, modify or both the value stored in memory, a mustAlias relation was found...
FunctionModRefBehavior
Summary of how a function affects memory in the program.
An instruction for storing to memory.
Definition: Instructions.h:310
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
FunctionInfo(const FunctionInfo &Arg)
ModRefInfo getModRefInfo() const
Returns the ModRefInfo info for this function.
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:221
amdgpu Simplify well known AMD library false Value * Callee
AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:79
FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS)
#define P(N)
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:410
LLVM_NODISCARD ModRefInfo setMust(const ModRefInfo MRI)
The ModulePass which wraps up a CallGraph and the logic to build it.
Definition: CallGraph.h:324
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
alias - If one of the pointers is to a global that we are tracking, and the other is some random poin...
An alias analysis result set for globals.
Definition: GlobalsModRef.h:32
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:224
#define H(x, y, z)
Definition: MD5.cpp:57
FunctionModRefBehavior getModRefBehavior(const Function *F)
getModRefBehavior - Return the behavior of the specified function if called from the specified call s...
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:371
Represent the analysis usage information of a pass.
bool hasOperandBundles() const
Definition: CallSite.h:535
This instruction compares its operands according to the predicate given to the constructor.
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value...
name anon globals
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
This function does not perform any non-local loads or stores to memory.
void initializeGlobalsAAWrapperPassPass(PassRegistry &)
const Value * Ptr
The address of the start of the location.
Representation for a specific memory location.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
void eraseModRefInfoForGlobal(const GlobalValue &GV)
Clear a global&#39;s ModRef info.
const DataFlowGraph & G
Definition: RDFGraph.cpp:211
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
void addModRefInfo(ModRefInfo NewMRI)
Adds new ModRefInfo for this function to its state.
This function does not perform any non-local stores or volatile loads, but may read from any memory l...
The access may modify the value stored in memory.
#define LLVM_ALIGNAS(x)
LLVM_ALIGNAS Used to specify a minimum alignment for a structure or variable.
Definition: Compiler.h:325
void setPreservesAll()
Set by analyses that do not transform their input at all.
iterator_range< user_iterator > users()
Definition: Value.h:399
void setPointerAndInt(PointerTy PtrVal, IntType IntVal)
bool doesNotAccessMemory() const
Determine if the call does not access memory.
Definition: CallSite.h:446
amdgpu Simplify well known AMD library false Value Value * Arg
An analysis pass to compute the CallGraph for a Module.
Definition: CallGraph.h:292
Basic Alias true
LLVM_NODISCARD bool isModSet(const ModRefInfo MRI)
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:74
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:62
FunctionInfo()
Checks to document the invariants of the bit packing here.
Establish a view to a call site for examination.
Definition: CallSite.h:714
ModulePass * createGlobalsAAWrapperPass()
LLVM_NODISCARD ModRefInfo intersectModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
#define I(x, y, z)
Definition: MD5.cpp:58
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:225
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc...
INITIALIZE_PASS_BEGIN(GlobalsAAWrapperPass, "globals-aa", "Globals Alias Analysis", false, true) INITIALIZE_PASS_END(GlobalsAAWrapperPass
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
globals aa
std::vector< CallRecord >::iterator iterator
Definition: CallGraph.h:184
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
FunTy * getCalledFunction() const
Return the function being called if this is a direct call, otherwise return null (if it&#39;s an indirect...
Definition: CallSite.h:107
Analysis pass providing the TargetLibraryInfo.
void GetUnderlyingObjects(Value *V, SmallVectorImpl< Value *> &Objects, const DataLayout &DL, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to GetUnderlyingObject except that it can look through phi and select instruct...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:73
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:41
LLVM_NODISCARD ModRefInfo createModRefInfo(const FunctionModRefBehavior FMRB)
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
inst_range instructions(Function *F)
Definition: InstIterator.h:134
A container for analyses that lazily runs them and caches their results.
LLVM_NODISCARD bool isModOrRefSet(const ModRefInfo MRI)
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:70
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
static bool isNonEscapingGlobalNoAliasWithLoad(const GlobalValue *GV, const Value *V, int &Depth, const DataLayout &DL)
Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG.
Definition: SCCIterator.h:43
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:967
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...