LLVM 19.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/PassManager.h"
18#include "llvm/IR/ValueHandle.h"
19#include "llvm/Pass.h"
20#include <list>
21
22namespace llvm {
23class CallGraph;
24class Function;
25
26/// An alias analysis result set for globals.
27///
28/// This focuses on handling aliasing properties of globals and interprocedural
29/// function call mod/ref information.
31 class FunctionInfo;
32
33 const DataLayout &DL;
34 std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
35
36 /// The globals that do not have their addresses taken.
37 SmallPtrSet<const GlobalValue *, 8> NonAddressTakenGlobals;
38
39 /// Are there functions with local linkage that may modify globals.
40 bool UnknownFunctionsWithLocalLinkage = false;
41
42 /// IndirectGlobals - The memory pointed to by this global is known to be
43 /// 'owned' by the global.
45
46 /// AllocsForIndirectGlobals - If an instruction allocates memory for an
47 /// indirect global, this map indicates which one.
48 DenseMap<const Value *, const GlobalValue *> AllocsForIndirectGlobals;
49
50 /// For each function, keep track of what globals are modified or read.
52
53 /// A map of functions to SCC. The SCCs are described by a simple integer
54 /// ID that is only useful for comparing for equality (are two functions
55 /// in the same SCC or not?)
57
58 /// Handle to clear this analysis on deletion of values.
59 struct DeletionCallbackHandle final : CallbackVH {
60 GlobalsAAResult *GAR;
61 std::list<DeletionCallbackHandle>::iterator I;
62
63 DeletionCallbackHandle(GlobalsAAResult &GAR, Value *V)
64 : CallbackVH(V), GAR(&GAR) {}
65
66 void deleted() override;
67 };
68
69 /// List of callbacks for globals being tracked by this analysis. Note that
70 /// these objects are quite large, but we only anticipate having one per
71 /// global tracked by this analysis. There are numerous optimizations we
72 /// could perform to the memory utilization here if this becomes a problem.
73 std::list<DeletionCallbackHandle> Handles;
74
75 explicit GlobalsAAResult(
76 const DataLayout &DL,
77 std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
78
80
81public:
84
85 bool invalidate(Module &M, const PreservedAnalyses &PA,
87
88 static GlobalsAAResult
90 std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
91 CallGraph &CG);
92
93 //------------------------------------------------
94 // Implement the AliasAnalysis API
95 //
96 AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB,
97 AAQueryInfo &AAQI, const Instruction *CtxI);
98
100 ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc,
101 AAQueryInfo &AAQI);
102
104 /// getMemoryEffects - 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
109private:
110 FunctionInfo *getFunctionInfo(const Function *F);
111
112 void AnalyzeGlobals(Module &M);
113 void AnalyzeCallGraph(CallGraph &CG, Module &M);
114 bool AnalyzeUsesOfPointer(Value *V,
115 SmallPtrSetImpl<Function *> *Readers = nullptr,
116 SmallPtrSetImpl<Function *> *Writers = nullptr,
117 GlobalValue *OkayStoreDest = nullptr);
118 bool AnalyzeIndirectGlobalMemory(GlobalVariable *GV);
119 void CollectSCCMembership(CallGraph &CG);
120
121 bool isNonEscapingGlobalNoAlias(const GlobalValue *GV, const Value *V);
122 ModRefInfo getModRefInfoForArgument(const CallBase *Call,
123 const GlobalValue *GV, AAQueryInfo &AAQI);
124};
125
126/// Analysis pass providing a never-invalidated alias analysis result.
127class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> {
129 static AnalysisKey Key;
130
131public:
133
135};
136
137struct RecomputeGlobalsAAPass : PassInfoMixin<RecomputeGlobalsAAPass> {
139};
140
141/// Legacy wrapper pass to provide the GlobalsAAResult object.
143 std::unique_ptr<GlobalsAAResult> Result;
144
145public:
146 static char ID;
147
149
150 GlobalsAAResult &getResult() { return *Result; }
151 const GlobalsAAResult &getResult() const { return *Result; }
152
153 bool runOnModule(Module &M) override;
154 bool doFinalization(Module &M) override;
155 void getAnalysisUsage(AnalysisUsage &AU) const override;
156};
157
158//===--------------------------------------------------------------------===//
159//
160// createGlobalsAAWrapperPass - This pass provides alias and mod/ref info for
161// global values that do not have their addresses taken.
162//
163ModulePass *createGlobalsAAWrapperPass();
164}
165
166#endif
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This header defines various interfaces for pass management in LLVM.
The mod/ref information collected for a particular function.
This class stores info we want to provide to or retain within an alias query.
A base class to help implement the function alias analysis results concept.
MemoryEffects getMemoryEffects(const CallBase *Call, AAQueryInfo &AAQI)
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
The possible results of an alias query.
Definition: AliasAnalysis.h:81
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:387
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
Represent the analysis usage information of a pass.
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1455
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:72
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:383
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
An alias analysis result set for globals.
Definition: GlobalsModRef.h:30
ModRefInfo getModRefInfo(const CallBase *Call, const MemoryLocation &Loc, AAQueryInfo &AAQI)
bool invalidate(Module &M, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &)
static GlobalsAAResult analyzeModule(Module &M, std::function< const TargetLibraryInfo &(Function &F)> GetTLI, CallGraph &CG)
MemoryEffects getMemoryEffects(const Function *F)
getMemoryEffects - Return the behavior of the specified function if called from the specified call si...
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB, AAQueryInfo &AAQI, const Instruction *CtxI)
alias - If one of the pointers is to a global that we are tracking, and the other is some random poin...
Legacy wrapper pass to provide the GlobalsAAResult object.
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
const GlobalsAAResult & getResult() const
GlobalsAAResult & getResult()
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Analysis pass providing a never-invalidated alias analysis result.
GlobalsAAResult run(Module &M, ModuleAnalysisManager &AM)
GlobalsAAResult Result
Representation for a specific memory location.
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:251
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:321
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
Provides information about what library functions are available for the current target.
LLVM Value Representation.
Definition: Value.h:74
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
ModulePass * createGlobalsAAWrapperPass()
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
Definition: ModRef.h:27
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:114
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:26
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:91
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)