LLVM  14.0.0git
GlobalsModRef.h
Go to the documentation of this file.
1 //===- GlobalsModRef.h - Simple Mod/Ref AA for Globals ----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 /// This is the interface for a simple mod/ref and alias analysis over globals.
10 ///
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_ANALYSIS_GLOBALSMODREF_H
14 #define LLVM_ANALYSIS_GLOBALSMODREF_H
15 
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/Function.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/IR/ValueHandle.h"
21 #include "llvm/Pass.h"
22 #include <list>
23 
24 namespace llvm {
25 class CallGraph;
26 
27 /// An alias analysis result set for globals.
28 ///
29 /// This focuses on handling aliasing properties of globals and interprocedural
30 /// function call mod/ref information.
31 class GlobalsAAResult : public AAResultBase<GlobalsAAResult> {
33 
34  class FunctionInfo;
35 
36  const DataLayout &DL;
37  std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
38 
39  /// The globals that do not have their addresses taken.
40  SmallPtrSet<const GlobalValue *, 8> NonAddressTakenGlobals;
41 
42  /// Are there functions with local linkage that may modify globals.
43  bool UnknownFunctionsWithLocalLinkage = false;
44 
45  /// IndirectGlobals - The memory pointed to by this global is known to be
46  /// 'owned' by the global.
48 
49  /// AllocsForIndirectGlobals - If an instruction allocates memory for an
50  /// indirect global, this map indicates which one.
51  DenseMap<const Value *, const GlobalValue *> AllocsForIndirectGlobals;
52 
53  /// For each function, keep track of what globals are modified or read.
55 
56  /// A map of functions to SCC. The SCCs are described by a simple integer
57  /// ID that is only useful for comparing for equality (are two functions
58  /// in the same SCC or not?)
59  DenseMap<const Function *, unsigned> FunctionToSCCMap;
60 
61  /// Handle to clear this analysis on deletion of values.
62  struct DeletionCallbackHandle final : CallbackVH {
63  GlobalsAAResult *GAR;
64  std::list<DeletionCallbackHandle>::iterator I;
65 
66  DeletionCallbackHandle(GlobalsAAResult &GAR, Value *V)
67  : CallbackVH(V), GAR(&GAR) {}
68 
69  void deleted() override;
70  };
71 
72  /// List of callbacks for globals being tracked by this analysis. Note that
73  /// these objects are quite large, but we only anticipate having one per
74  /// global tracked by this analysis. There are numerous optimizations we
75  /// could perform to the memory utilization here if this becomes a problem.
76  std::list<DeletionCallbackHandle> Handles;
77 
78  explicit GlobalsAAResult(
79  const DataLayout &DL,
80  std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
81 
82 public:
85 
86  bool invalidate(Module &M, const PreservedAnalyses &PA,
88 
89  static GlobalsAAResult
91  std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
92  CallGraph &CG);
93 
94  //------------------------------------------------
95  // Implement the AliasAnalysis API
96  //
97  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
98  AAQueryInfo &AAQI);
99 
101  ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
102  AAQueryInfo &AAQI);
103 
104  /// getModRefBehavior - Return the behavior of the specified function if
105  /// called from the specified call site. The call site may be null in which
106  /// case the most generic behavior of this function should be returned.
108 
109  /// getModRefBehavior - Return the behavior of the specified function if
110  /// called from the specified call site. The call site may be null in which
111  /// case the most generic behavior of this function should be returned.
113 
114 private:
115  FunctionInfo *getFunctionInfo(const Function *F);
116 
117  void AnalyzeGlobals(Module &M);
118  void AnalyzeCallGraph(CallGraph &CG, Module &M);
119  bool AnalyzeUsesOfPointer(Value *V,
120  SmallPtrSetImpl<Function *> *Readers = nullptr,
121  SmallPtrSetImpl<Function *> *Writers = nullptr,
122  GlobalValue *OkayStoreDest = nullptr);
123  bool AnalyzeIndirectGlobalMemory(GlobalVariable *GV);
124  void CollectSCCMembership(CallGraph &CG);
125 
126  bool isNonEscapingGlobalNoAlias(const GlobalValue *GV, const Value *V);
127  ModRefInfo getModRefInfoForArgument(const CallBase *Call,
128  const GlobalValue *GV, AAQueryInfo &AAQI);
129 };
130 
131 /// Analysis pass providing a never-invalidated alias analysis result.
132 class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
134  static AnalysisKey Key;
135 
136 public:
138 
140 };
141 
142 /// Legacy wrapper pass to provide the GlobalsAAResult object.
144  std::unique_ptr<GlobalsAAResult> Result;
145 
146 public:
147  static char ID;
148 
150 
151  GlobalsAAResult &getResult() { return *Result; }
152  const GlobalsAAResult &getResult() const { return *Result; }
153 
154  bool runOnModule(Module &M) override;
155  bool doFinalization(Module &M) override;
156  void getAnalysisUsage(AnalysisUsage &AU) const override;
157 };
158 
159 //===--------------------------------------------------------------------===//
160 //
161 // createGlobalsAAWrapperPass - This pass provides alias and mod/ref info for
162 // global values that do not have their addresses taken.
163 //
164 ModulePass *createGlobalsAAWrapperPass();
165 }
166 
167 #endif
llvm::GlobalsAA
Analysis pass providing a never-invalidated alias analysis result.
Definition: GlobalsModRef.h:132
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:155
llvm::GlobalsAAResult
An alias analysis result set for globals.
Definition: GlobalsModRef.h:31
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::GlobalsAAResult::analyzeModule
static GlobalsAAResult analyzeModule(Module &M, std::function< const TargetLibraryInfo &(Function &F)> GetTLI, CallGraph &CG)
Definition: GlobalsModRef.cpp:984
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:238
llvm::Function
Definition: Function.h:61
Pass.h
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::CallGraph
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:73
Module.h
llvm::AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:81
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
F
#define F(x, y, z)
Definition: MD5.cpp:56
AliasAnalysis.h
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::AAQueryInfo
This class stores info we want to provide to or retain within an alias query.
Definition: AliasAnalysis.h:414
llvm::GlobalsAAResult::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const Function *F)
getModRefBehavior - Return the behavior of the specified function if called from the specified call s...
Definition: GlobalsModRef.cpp:246
Constants.h
llvm::GlobalsAAResult::invalidate
bool invalidate(Module &M, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &)
Definition: GlobalsModRef.cpp:815
llvm::GlobalsAAWrapperPass::ID
static char ID
Definition: GlobalsModRef.h:147
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::AnalysisManager::Invalidator
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:656
llvm::createGlobalsAAWrapperPass
ModulePass * createGlobalsAAWrapperPass()
Definition: GlobalsModRef.cpp:1021
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalsAAResult::FunctionInfo
The mod/ref information collected for a particular function.
Definition: GlobalsModRef.cpp:64
llvm::DenseMap
Definition: DenseMap.h:714
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::GlobalsAAWrapperPass::getResult
const GlobalsAAResult & getResult() const
Definition: GlobalsModRef.h:152
llvm::ModRefInfo
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: AliasAnalysis.h:148
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::GlobalsAAWrapperPass::doFinalization
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: GlobalsModRef.cpp:1038
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::AnalysisInfoMixin
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:391
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::GlobalsAAWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: GlobalsModRef.cpp:1043
llvm::FunctionModRefBehavior
FunctionModRefBehavior
Summary of how a function affects memory in the program.
Definition: AliasAnalysis.h:262
ValueHandle.h
llvm::GlobalsAAWrapperPass::runOnModule
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
Definition: GlobalsModRef.cpp:1029
llvm::AAResultBase::getModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
Definition: AliasAnalysis.h:1186
llvm::GlobalsAAResult::alias
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI)
alias - If one of the pointers is to a global that we are tracking, and the other is some random poin...
Definition: GlobalsModRef.cpp:826
llvm::GlobalsAA::run
GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM)
Definition: GlobalsModRef.cpp:1003
Function.h
llvm::TargetLibraryInfo
Provides information about what library functions are available for the current target.
Definition: TargetLibraryInfo.h:219
llvm::GlobalsAAWrapperPass::GlobalsAAWrapperPass
GlobalsAAWrapperPass()
Definition: GlobalsModRef.cpp:1025
llvm::CallbackVH
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:383
llvm::GlobalsAAResult::~GlobalsAAResult
~GlobalsAAResult()
Definition: GlobalsModRef.cpp:982
llvm::GlobalsAA::Result
GlobalsAAResult Result
Definition: GlobalsModRef.h:137
llvm::GlobalsAAWrapperPass
Legacy wrapper pass to provide the GlobalsAAResult object.
Definition: GlobalsModRef.h:143
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1161
llvm::SmallPtrSetImpl< Function * >
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::GlobalsAAResult::getModRefInfo
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
Definition: GlobalsModRef.cpp:940
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::AAResultBase
A CRTP-driven "mixin" base class to help implement the function alias analysis results concept.
Definition: AliasAnalysis.h:1076
llvm::MemoryLocation
Representation for a specific memory location.
Definition: MemoryLocation.h:209
llvm::GlobalsAAWrapperPass::getResult
GlobalsAAResult & getResult()
Definition: GlobalsModRef.h:151