1 //===- GlobalsModRef.cpp - Simple Mod/Ref Analysis for Globals ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
15 //===----------------------------------------------------------------------===//
17 #include "llvm/Analysis/Passes.h"
18 #include "llvm/ADT/SCCIterator.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/Analysis/AliasAnalysis.h"
22 #include "llvm/Analysis/CallGraph.h"
23 #include "llvm/Analysis/MemoryBuiltins.h"
24 #include "llvm/Analysis/ValueTracking.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DerivedTypes.h"
27 #include "llvm/IR/InstIterator.h"
28 #include "llvm/IR/Instructions.h"
29 #include "llvm/IR/IntrinsicInst.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/Pass.h"
32 #include "llvm/Support/CommandLine.h"
36 #define DEBUG_TYPE "globalsmodref-aa"
38 STATISTIC(NumNonAddrTakenGlobalVars,
39 "Number of global vars without address taken");
40 STATISTIC(NumNonAddrTakenFunctions,"Number of functions without address taken");
41 STATISTIC(NumNoMemFunctions, "Number of functions that do not access memory");
42 STATISTIC(NumReadMemFunctions, "Number of functions that only read memory");
43 STATISTIC(NumIndirectGlobalVars, "Number of indirect global objects");
45 // An option to enable unsafe alias results from the GlobalsModRef analysis.
46 // When enabled, GlobalsModRef will provide no-alias results which in extremely
47 // rare cases may not be conservatively correct. In particular, in the face of
48 // transforms which cause assymetry between how effective GetUnderlyingObject
49 // is for two pointers, it may produce incorrect results.
51 // These unsafe results have been returned by GMR for many years without
52 // causing significant issues in the wild and so we provide a mechanism to
53 // re-enable them for users of LLVM that have a particular performance
54 // sensitivity and no known issues. The option also makes it easy to evaluate
55 // the performance impact of these results.
56 static cl::opt<bool> EnableUnsafeGlobalsModRefAliasResults(
57 "enable-unsafe-globalsmodref-alias-results", cl::init(false), cl::Hidden);
60 /// The mod/ref information collected for a particular function.
62 /// We collect information about mod/ref behavior of a function here, both in
63 /// general and as pertains to specific globals. We only have this detailed
64 /// information when we know *something* useful about the behavior. If we
65 /// saturate to fully general mod/ref, we remove the info for the function.
67 typedef SmallDenseMap<const GlobalValue *, ModRefInfo, 16> GlobalInfoMapType;
69 /// Build a wrapper struct that has 8-byte alignment. All heap allocations
70 /// should provide this much alignment at least, but this makes it clear we
71 /// specifically rely on this amount of alignment.
72 struct LLVM_ALIGNAS(8) AlignedMap {
74 AlignedMap(const AlignedMap &Arg) : Map(Arg.Map) {}
75 GlobalInfoMapType Map;
78 /// Pointer traits for our aligned map.
79 struct AlignedMapPointerTraits {
80 static inline void *getAsVoidPointer(AlignedMap *P) { return P; }
81 static inline AlignedMap *getFromVoidPointer(void *P) {
82 return (AlignedMap *)P;
84 enum { NumLowBitsAvailable = 3 };
85 static_assert(AlignOf<AlignedMap>::Alignment >= (1 << NumLowBitsAvailable),
86 "AlignedMap insufficiently aligned to have enough low bits.");
89 /// The bit that flags that this function may read any global. This is
90 /// chosen to mix together with ModRefInfo bits.
91 enum { MayReadAnyGlobal = 4 };
93 /// Checks to document the invariants of the bit packing here.
94 static_assert((MayReadAnyGlobal & MRI_ModRef) == 0,
95 "ModRef and the MayReadAnyGlobal flag bits overlap.");
96 static_assert(((MayReadAnyGlobal | MRI_ModRef) >>
97 AlignedMapPointerTraits::NumLowBitsAvailable) == 0,
98 "Insufficient low bits to store our flag and ModRef info.");
101 FunctionInfo() : Info() {}
103 delete Info.getPointer();
105 // Spell out the copy ond move constructors and assignment operators to get
106 // deep copy semantics and correct move semantics in the face of the
108 FunctionInfo(const FunctionInfo &Arg)
109 : Info(nullptr, Arg.Info.getInt()) {
110 if (const auto *ArgPtr = Arg.Info.getPointer())
111 Info.setPointer(new AlignedMap(*ArgPtr));
113 FunctionInfo(FunctionInfo &&Arg)
114 : Info(Arg.Info.getPointer(), Arg.Info.getInt()) {
115 Arg.Info.setPointerAndInt(nullptr, 0);
117 FunctionInfo &operator=(const FunctionInfo &RHS) {
118 delete Info.getPointer();
119 Info.setPointerAndInt(nullptr, RHS.Info.getInt());
120 if (const auto *RHSPtr = RHS.Info.getPointer())
121 Info.setPointer(new AlignedMap(*RHSPtr));
124 FunctionInfo &operator=(FunctionInfo &&RHS) {
125 delete Info.getPointer();
126 Info.setPointerAndInt(RHS.Info.getPointer(), RHS.Info.getInt());
127 RHS.Info.setPointerAndInt(nullptr, 0);
131 /// Returns the \c ModRefInfo info for this function.
132 ModRefInfo getModRefInfo() const {
133 return ModRefInfo(Info.getInt() & MRI_ModRef);
136 /// Adds new \c ModRefInfo for this function to its state.
137 void addModRefInfo(ModRefInfo NewMRI) {
138 Info.setInt(Info.getInt() | NewMRI);
141 /// Returns whether this function may read any global variable, and we don't
142 /// know which global.
143 bool mayReadAnyGlobal() const { return Info.getInt() & MayReadAnyGlobal; }
145 /// Sets this function as potentially reading from any global.
146 void setMayReadAnyGlobal() { Info.setInt(Info.getInt() | MayReadAnyGlobal); }
148 /// Returns the \c ModRefInfo info for this function w.r.t. a particular
149 /// global, which may be more precise than the general information above.
150 ModRefInfo getModRefInfoForGlobal(const GlobalValue &GV) const {
151 ModRefInfo GlobalMRI = mayReadAnyGlobal() ? MRI_Ref : MRI_NoModRef;
152 if (AlignedMap *P = Info.getPointer()) {
153 auto I = P->Map.find(&GV);
154 if (I != P->Map.end())
155 GlobalMRI = ModRefInfo(GlobalMRI | I->second);
160 /// Add mod/ref info from another function into ours, saturating towards
162 void addFunctionInfo(const FunctionInfo &FI) {
163 addModRefInfo(FI.getModRefInfo());
165 if (FI.mayReadAnyGlobal())
166 setMayReadAnyGlobal();
168 if (AlignedMap *P = FI.Info.getPointer())
169 for (const auto &G : P->Map)
170 addModRefInfoForGlobal(*G.first, G.second);
173 void addModRefInfoForGlobal(const GlobalValue &GV, ModRefInfo NewMRI) {
174 AlignedMap *P = Info.getPointer();
176 P = new AlignedMap();
179 auto &GlobalMRI = P->Map[&GV];
180 GlobalMRI = ModRefInfo(GlobalMRI | NewMRI);
183 /// Clear a global's ModRef info. Should be used when a global is being
185 void eraseModRefInfoForGlobal(const GlobalValue &GV) {
186 if (AlignedMap *P = Info.getPointer())
191 /// All of the information is encoded into a single pointer, with a three bit
192 /// integer in the low three bits. The high bit provides a flag for when this
193 /// function may read any global. The low two bits are the ModRefInfo. And
194 /// the pointer, when non-null, points to a map from GlobalValue to
195 /// ModRefInfo specific to that GlobalValue.
196 PointerIntPair<AlignedMap *, 3, unsigned, AlignedMapPointerTraits> Info;
199 /// GlobalsModRef - The actual analysis pass.
200 class GlobalsModRef : public ModulePass, public AliasAnalysis {
201 /// The globals that do not have their addresses taken.
202 SmallPtrSet<const GlobalValue *, 8> NonAddressTakenGlobals;
204 /// IndirectGlobals - The memory pointed to by this global is known to be
205 /// 'owned' by the global.
206 SmallPtrSet<const GlobalValue *, 8> IndirectGlobals;
208 /// AllocsForIndirectGlobals - If an instruction allocates memory for an
209 /// indirect global, this map indicates which one.
210 DenseMap<const Value *, const GlobalValue *> AllocsForIndirectGlobals;
212 /// For each function, keep track of what globals are modified or read.
213 DenseMap<const Function *, FunctionInfo> FunctionInfos;
215 /// Handle to clear this analysis on deletion of values.
216 struct DeletionCallbackHandle final : CallbackVH {
218 std::list<DeletionCallbackHandle>::iterator I;
220 DeletionCallbackHandle(GlobalsModRef &GMR, Value *V)
221 : CallbackVH(V), GMR(GMR) {}
223 void deleted() override {
224 Value *V = getValPtr();
225 if (auto *F = dyn_cast<Function>(V))
226 GMR.FunctionInfos.erase(F);
228 if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
229 if (GMR.NonAddressTakenGlobals.erase(GV)) {
230 // This global might be an indirect global. If so, remove it and
231 // remove any AllocRelatedValues for it.
232 if (GMR.IndirectGlobals.erase(GV)) {
233 // Remove any entries in AllocsForIndirectGlobals for this global.
234 for (auto I = GMR.AllocsForIndirectGlobals.begin(),
235 E = GMR.AllocsForIndirectGlobals.end();
238 GMR.AllocsForIndirectGlobals.erase(I);
241 // Scan the function info we have collected and remove this global
243 for (auto &FIPair : GMR.FunctionInfos)
244 FIPair.second.eraseModRefInfoForGlobal(*GV);
248 // If this is an allocation related to an indirect global, remove it.
249 GMR.AllocsForIndirectGlobals.erase(V);
251 // And clear out the handle.
253 GMR.Handles.erase(I);
254 // This object is now destroyed!
258 /// List of callbacks for globals being tracked by this analysis. Note that
259 /// these objects are quite large, but we only anticipate having one per
260 /// global tracked by this analysis. There are numerous optimizations we
261 /// could perform to the memory utilization here if this becomes a problem.
262 std::list<DeletionCallbackHandle> Handles;
266 GlobalsModRef() : ModulePass(ID) {
267 initializeGlobalsModRefPass(*PassRegistry::getPassRegistry());
270 bool runOnModule(Module &M) override {
271 InitializeAliasAnalysis(this, &M.getDataLayout());
273 // Find non-addr taken globals.
277 AnalyzeCallGraph(getAnalysis<CallGraphWrapperPass>().getCallGraph(), M);
281 void getAnalysisUsage(AnalysisUsage &AU) const override {
282 AliasAnalysis::getAnalysisUsage(AU);
283 AU.addRequired<CallGraphWrapperPass>();
284 AU.setPreservesAll(); // Does not transform code
287 /// getAdjustedAnalysisPointer - This method is used when a pass implements
288 /// an analysis interface through multiple inheritance. If needed, it
289 /// should override this to adjust the this pointer as needed for the
290 /// specified pass info.
291 void *getAdjustedAnalysisPointer(AnalysisID PI) override {
292 if (PI == &AliasAnalysis::ID)
293 return (AliasAnalysis *)this;
297 //------------------------------------------------
298 // Implement the AliasAnalysis API
300 AliasResult alias(const MemoryLocation &LocA,
301 const MemoryLocation &LocB) override;
302 ModRefInfo getModRefInfo(ImmutableCallSite CS,
303 const MemoryLocation &Loc) override;
304 ModRefInfo getModRefInfo(ImmutableCallSite CS1,
305 ImmutableCallSite CS2) override {
306 return AliasAnalysis::getModRefInfo(CS1, CS2);
309 /// getModRefBehavior - Return the behavior of the specified function if
310 /// called from the specified call site. The call site may be null in which
311 /// case the most generic behavior of this function should be returned.
312 FunctionModRefBehavior getModRefBehavior(const Function *F) override {
313 FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
315 if (FunctionInfo *FI = getFunctionInfo(F)) {
316 if (FI->getModRefInfo() == MRI_NoModRef)
317 Min = FMRB_DoesNotAccessMemory;
318 else if ((FI->getModRefInfo() & MRI_Mod) == 0)
319 Min = FMRB_OnlyReadsMemory;
322 return FunctionModRefBehavior(AliasAnalysis::getModRefBehavior(F) & Min);
325 /// getModRefBehavior - Return the behavior of the specified function if
326 /// called from the specified call site. The call site may be null in which
327 /// case the most generic behavior of this function should be returned.
328 FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override {
329 FunctionModRefBehavior Min = FMRB_UnknownModRefBehavior;
331 if (const Function *F = CS.getCalledFunction())
332 if (FunctionInfo *FI = getFunctionInfo(F)) {
333 if (FI->getModRefInfo() == MRI_NoModRef)
334 Min = FMRB_DoesNotAccessMemory;
335 else if ((FI->getModRefInfo() & MRI_Mod) == 0)
336 Min = FMRB_OnlyReadsMemory;
339 return FunctionModRefBehavior(AliasAnalysis::getModRefBehavior(CS) & Min);
343 /// Returns the function info for the function, or null if we don't have
344 /// anything useful to say about it.
345 FunctionInfo *getFunctionInfo(const Function *F) {
346 auto I = FunctionInfos.find(F);
347 if (I != FunctionInfos.end())
352 void AnalyzeGlobals(Module &M);
353 void AnalyzeCallGraph(CallGraph &CG, Module &M);
354 bool AnalyzeUsesOfPointer(Value *V,
355 SmallPtrSetImpl<Function *> *Readers = nullptr,
356 SmallPtrSetImpl<Function *> *Writers = nullptr,
357 GlobalValue *OkayStoreDest = nullptr);
358 bool AnalyzeIndirectGlobalMemory(GlobalValue *GV);
362 char GlobalsModRef::ID = 0;
363 INITIALIZE_AG_PASS_BEGIN(GlobalsModRef, AliasAnalysis, "globalsmodref-aa",
364 "Simple mod/ref analysis for globals", false, true,
366 INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
367 INITIALIZE_AG_PASS_END(GlobalsModRef, AliasAnalysis, "globalsmodref-aa",
368 "Simple mod/ref analysis for globals", false, true,
371 Pass *llvm::createGlobalsModRefPass() { return new GlobalsModRef(); }
373 /// AnalyzeGlobals - Scan through the users of all of the internal
374 /// GlobalValue's in the program. If none of them have their "address taken"
375 /// (really, their address passed to something nontrivial), record this fact,
376 /// and record the functions that they are used directly in.
377 void GlobalsModRef::AnalyzeGlobals(Module &M) {
378 SmallPtrSet<Function *, 64> TrackedFunctions;
379 for (Function &F : M)
380 if (F.hasLocalLinkage())
381 if (!AnalyzeUsesOfPointer(&F)) {
382 // Remember that we are tracking this global.
383 NonAddressTakenGlobals.insert(&F);
384 TrackedFunctions.insert(&F);
385 Handles.emplace_front(*this, &F);
386 Handles.front().I = Handles.begin();
387 ++NumNonAddrTakenFunctions;
390 SmallPtrSet<Function *, 64> Readers, Writers;
391 for (GlobalVariable &GV : M.globals())
392 if (GV.hasLocalLinkage()) {
393 if (!AnalyzeUsesOfPointer(&GV, &Readers,
394 GV.isConstant() ? nullptr : &Writers)) {
395 // Remember that we are tracking this global, and the mod/ref fns
396 NonAddressTakenGlobals.insert(&GV);
397 Handles.emplace_front(*this, &GV);
398 Handles.front().I = Handles.begin();
400 for (Function *Reader : Readers) {
401 if (TrackedFunctions.insert(Reader).second) {
402 Handles.emplace_front(*this, Reader);
403 Handles.front().I = Handles.begin();
405 FunctionInfos[Reader].addModRefInfoForGlobal(GV, MRI_Ref);
408 if (!GV.isConstant()) // No need to keep track of writers to constants
409 for (Function *Writer : Writers) {
410 if (TrackedFunctions.insert(Writer).second) {
411 Handles.emplace_front(*this, Writer);
412 Handles.front().I = Handles.begin();
414 FunctionInfos[Writer].addModRefInfoForGlobal(GV, MRI_Mod);
416 ++NumNonAddrTakenGlobalVars;
418 // If this global holds a pointer type, see if it is an indirect global.
419 if (GV.getType()->getElementType()->isPointerTy() &&
420 AnalyzeIndirectGlobalMemory(&GV))
421 ++NumIndirectGlobalVars;
428 /// AnalyzeUsesOfPointer - Look at all of the users of the specified pointer.
429 /// If this is used by anything complex (i.e., the address escapes), return
430 /// true. Also, while we are at it, keep track of those functions that read and
431 /// write to the value.
433 /// If OkayStoreDest is non-null, stores into this global are allowed.
434 bool GlobalsModRef::AnalyzeUsesOfPointer(Value *V,
435 SmallPtrSetImpl<Function *> *Readers,
436 SmallPtrSetImpl<Function *> *Writers,
437 GlobalValue *OkayStoreDest) {
438 if (!V->getType()->isPointerTy())
441 for (Use &U : V->uses()) {
442 User *I = U.getUser();
443 if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
445 Readers->insert(LI->getParent()->getParent());
446 } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
447 if (V == SI->getOperand(1)) {
449 Writers->insert(SI->getParent()->getParent());
450 } else if (SI->getOperand(1) != OkayStoreDest) {
451 return true; // Storing the pointer
453 } else if (Operator::getOpcode(I) == Instruction::GetElementPtr) {
454 if (AnalyzeUsesOfPointer(I, Readers, Writers))
456 } else if (Operator::getOpcode(I) == Instruction::BitCast) {
457 if (AnalyzeUsesOfPointer(I, Readers, Writers, OkayStoreDest))
459 } else if (auto CS = CallSite(I)) {
460 // Make sure that this is just the function being called, not that it is
461 // passing into the function.
462 if (!CS.isCallee(&U)) {
463 // Detect calls to free.
464 if (isFreeCall(I, TLI)) {
466 Writers->insert(CS->getParent()->getParent());
468 return true; // Argument of an unknown call.
471 } else if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
472 if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
473 return true; // Allow comparison against null.
482 /// AnalyzeIndirectGlobalMemory - We found an non-address-taken global variable
483 /// which holds a pointer type. See if the global always points to non-aliased
484 /// heap memory: that is, all initializers of the globals are allocations, and
485 /// those allocations have no use other than initialization of the global.
486 /// Further, all loads out of GV must directly use the memory, not store the
487 /// pointer somewhere. If this is true, we consider the memory pointed to by
488 /// GV to be owned by GV and can disambiguate other pointers from it.
489 bool GlobalsModRef::AnalyzeIndirectGlobalMemory(GlobalValue *GV) {
490 // Keep track of values related to the allocation of the memory, f.e. the
491 // value produced by the malloc call and any casts.
492 std::vector<Value *> AllocRelatedValues;
494 // Walk the user list of the global. If we find anything other than a direct
495 // load or store, bail out.
496 for (User *U : GV->users()) {
497 if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
498 // The pointer loaded from the global can only be used in simple ways:
499 // we allow addressing of it and loading storing to it. We do *not* allow
500 // storing the loaded pointer somewhere else or passing to a function.
501 if (AnalyzeUsesOfPointer(LI))
502 return false; // Loaded pointer escapes.
503 // TODO: Could try some IP mod/ref of the loaded pointer.
504 } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
505 // Storing the global itself.
506 if (SI->getOperand(0) == GV)
509 // If storing the null pointer, ignore it.
510 if (isa<ConstantPointerNull>(SI->getOperand(0)))
513 // Check the value being stored.
514 Value *Ptr = GetUnderlyingObject(SI->getOperand(0),
515 GV->getParent()->getDataLayout());
517 if (!isAllocLikeFn(Ptr, TLI))
518 return false; // Too hard to analyze.
520 // Analyze all uses of the allocation. If any of them are used in a
521 // non-simple way (e.g. stored to another global) bail out.
522 if (AnalyzeUsesOfPointer(Ptr, /*Readers*/ nullptr, /*Writers*/ nullptr,
524 return false; // Loaded pointer escapes.
526 // Remember that this allocation is related to the indirect global.
527 AllocRelatedValues.push_back(Ptr);
529 // Something complex, bail out.
534 // Okay, this is an indirect global. Remember all of the allocations for
535 // this global in AllocsForIndirectGlobals.
536 while (!AllocRelatedValues.empty()) {
537 AllocsForIndirectGlobals[AllocRelatedValues.back()] = GV;
538 Handles.emplace_front(*this, AllocRelatedValues.back());
539 Handles.front().I = Handles.begin();
540 AllocRelatedValues.pop_back();
542 IndirectGlobals.insert(GV);
543 Handles.emplace_front(*this, GV);
544 Handles.front().I = Handles.begin();
548 /// AnalyzeCallGraph - At this point, we know the functions where globals are
549 /// immediately stored to and read from. Propagate this information up the call
550 /// graph to all callers and compute the mod/ref info for all memory for each
552 void GlobalsModRef::AnalyzeCallGraph(CallGraph &CG, Module &M) {
553 // We do a bottom-up SCC traversal of the call graph. In other words, we
554 // visit all callees before callers (leaf-first).
555 for (scc_iterator<CallGraph *> I = scc_begin(&CG); !I.isAtEnd(); ++I) {
556 const std::vector<CallGraphNode *> &SCC = *I;
557 assert(!SCC.empty() && "SCC with no functions?");
559 if (!SCC[0]->getFunction()) {
560 // Calls externally - can't say anything useful. Remove any existing
561 // function records (may have been created when scanning globals).
562 for (auto *Node : SCC)
563 FunctionInfos.erase(Node->getFunction());
567 FunctionInfo &FI = FunctionInfos[SCC[0]->getFunction()];
568 bool KnowNothing = false;
570 // Collect the mod/ref properties due to called functions. We only compute
572 for (unsigned i = 0, e = SCC.size(); i != e && !KnowNothing; ++i) {
573 Function *F = SCC[i]->getFunction();
579 if (F->isDeclaration()) {
580 // Try to get mod/ref behaviour from function attributes.
581 if (F->doesNotAccessMemory()) {
582 // Can't do better than that!
583 } else if (F->onlyReadsMemory()) {
584 FI.addModRefInfo(MRI_Ref);
585 if (!F->isIntrinsic())
586 // This function might call back into the module and read a global -
587 // consider every global as possibly being read by this function.
588 FI.setMayReadAnyGlobal();
590 FI.addModRefInfo(MRI_ModRef);
591 // Can't say anything useful unless it's an intrinsic - they don't
592 // read or write global variables of the kind considered here.
593 KnowNothing = !F->isIntrinsic();
598 for (CallGraphNode::iterator CI = SCC[i]->begin(), E = SCC[i]->end();
599 CI != E && !KnowNothing; ++CI)
600 if (Function *Callee = CI->second->getFunction()) {
601 if (FunctionInfo *CalleeFI = getFunctionInfo(Callee)) {
602 // Propagate function effect up.
603 FI.addFunctionInfo(*CalleeFI);
605 // Can't say anything about it. However, if it is inside our SCC,
606 // then nothing needs to be done.
607 CallGraphNode *CalleeNode = CG[Callee];
608 if (std::find(SCC.begin(), SCC.end(), CalleeNode) == SCC.end())
616 // If we can't say anything useful about this SCC, remove all SCC functions
617 // from the FunctionInfos map.
619 for (auto *Node : SCC)
620 FunctionInfos.erase(Node->getFunction());
624 // Scan the function bodies for explicit loads or stores.
625 for (auto *Node : SCC) {
626 if (FI.getModRefInfo() == MRI_ModRef)
627 break; // The mod/ref lattice saturates here.
628 for (Instruction &I : inst_range(Node->getFunction())) {
629 if (FI.getModRefInfo() == MRI_ModRef)
630 break; // The mod/ref lattice saturates here.
632 // We handle calls specially because the graph-relevant aspects are
634 if (auto CS = CallSite(&I)) {
635 if (isAllocationFn(&I, TLI) || isFreeCall(&I, TLI)) {
636 // FIXME: It is completely unclear why this is necessary and not
637 // handled by the above graph code.
638 FI.addModRefInfo(MRI_ModRef);
639 } else if (Function *Callee = CS.getCalledFunction()) {
640 // The callgraph doesn't include intrinsic calls.
641 if (Callee->isIntrinsic()) {
642 FunctionModRefBehavior Behaviour =
643 AliasAnalysis::getModRefBehavior(Callee);
644 FI.addModRefInfo(ModRefInfo(Behaviour & MRI_ModRef));
650 // All non-call instructions we use the primary predicates for whether
651 // thay read or write memory.
652 if (I.mayReadFromMemory())
653 FI.addModRefInfo(MRI_Ref);
654 if (I.mayWriteToMemory())
655 FI.addModRefInfo(MRI_Mod);
659 if ((FI.getModRefInfo() & MRI_Mod) == 0)
660 ++NumReadMemFunctions;
661 if (FI.getModRefInfo() == MRI_NoModRef)
664 // Finally, now that we know the full effect on this SCC, clone the
665 // information to each function in the SCC.
666 for (unsigned i = 1, e = SCC.size(); i != e; ++i)
667 FunctionInfos[SCC[i]->getFunction()] = FI;
671 /// alias - If one of the pointers is to a global that we are tracking, and the
672 /// other is some random pointer, we know there cannot be an alias, because the
673 /// address of the global isn't taken.
674 AliasResult GlobalsModRef::alias(const MemoryLocation &LocA,
675 const MemoryLocation &LocB) {
676 // Get the base object these pointers point to.
677 const Value *UV1 = GetUnderlyingObject(LocA.Ptr, *DL);
678 const Value *UV2 = GetUnderlyingObject(LocB.Ptr, *DL);
680 // If either of the underlying values is a global, they may be non-addr-taken
681 // globals, which we can answer queries about.
682 const GlobalValue *GV1 = dyn_cast<GlobalValue>(UV1);
683 const GlobalValue *GV2 = dyn_cast<GlobalValue>(UV2);
685 // If the global's address is taken, pretend we don't know it's a pointer to
687 if (GV1 && !NonAddressTakenGlobals.count(GV1))
689 if (GV2 && !NonAddressTakenGlobals.count(GV2))
692 // If the two pointers are derived from two different non-addr-taken
693 // globals we know these can't alias.
694 if (GV1 && GV2 && GV1 != GV2)
697 // If one is and the other isn't, it isn't strictly safe but we can fake
698 // this result if necessary for performance. This does not appear to be
699 // a common problem in practice.
700 if (EnableUnsafeGlobalsModRefAliasResults)
701 if ((GV1 || GV2) && GV1 != GV2)
704 // Otherwise if they are both derived from the same addr-taken global, we
705 // can't know the two accesses don't overlap.
708 // These pointers may be based on the memory owned by an indirect global. If
709 // so, we may be able to handle this. First check to see if the base pointer
710 // is a direct load from an indirect global.
712 if (const LoadInst *LI = dyn_cast<LoadInst>(UV1))
713 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
714 if (IndirectGlobals.count(GV))
716 if (const LoadInst *LI = dyn_cast<LoadInst>(UV2))
717 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(LI->getOperand(0)))
718 if (IndirectGlobals.count(GV))
721 // These pointers may also be from an allocation for the indirect global. If
722 // so, also handle them.
724 GV1 = AllocsForIndirectGlobals.lookup(UV1);
726 GV2 = AllocsForIndirectGlobals.lookup(UV2);
728 // Now that we know whether the two pointers are related to indirect globals,
729 // use this to disambiguate the pointers. If the pointers are based on
730 // different indirect globals they cannot alias.
731 if (GV1 && GV2 && GV1 != GV2)
734 // If one is based on an indirect global and the other isn't, it isn't
735 // strictly safe but we can fake this result if necessary for performance.
736 // This does not appear to be a common problem in practice.
737 if (EnableUnsafeGlobalsModRefAliasResults)
738 if ((GV1 || GV2) && GV1 != GV2)
741 return AliasAnalysis::alias(LocA, LocB);
744 ModRefInfo GlobalsModRef::getModRefInfo(ImmutableCallSite CS,
745 const MemoryLocation &Loc) {
746 unsigned Known = MRI_ModRef;
748 // If we are asking for mod/ref info of a direct call with a pointer to a
749 // global we are tracking, return information if we have it.
750 const DataLayout &DL = CS.getCaller()->getParent()->getDataLayout();
751 if (const GlobalValue *GV =
752 dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))
753 if (GV->hasLocalLinkage())
754 if (const Function *F = CS.getCalledFunction())
755 if (NonAddressTakenGlobals.count(GV))
756 if (const FunctionInfo *FI = getFunctionInfo(F))
757 Known = FI->getModRefInfoForGlobal(*GV);
759 if (Known == MRI_NoModRef)
760 return MRI_NoModRef; // No need to query other mod/ref analyses
761 return ModRefInfo(Known & AliasAnalysis::getModRefInfo(CS, Loc));