LLVM  8.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 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:259
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:355
The access neither references nor modifies the value stored in memory.
bool hasLocalLinkage() const
Definition: GlobalValue.h:436
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:250
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:770
void setMayReadAnyGlobal()
Sets this function as potentially reading from any global.
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
This class represents lattice values for constants.
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:64
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:1180
STATISTIC(NumFunctions, "Total number of functions")
F(f)
block Block Frequency true
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:938
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:364
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:419
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:847
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:381
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.
void setPreservesAll()
Set by analyses that do not transform their input at all.
iterator_range< user_iterator > users()
Definition: Value.h:400
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
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:56
FunctionInfo()
Checks to document the invariants of the bit packing here.
Establish a view to a call site for examination.
Definition: CallSite.h:711
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:566
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:71
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:1239
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...