Line data Source code
1 : //===- llvm/Analysis/AliasAnalysis.h - Alias Analysis Interface -*- C++ -*-===//
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 file defines the generic AliasAnalysis interface, which is used as the
11 : // common interface used by all clients of alias analysis information, and
12 : // implemented by all alias analysis implementations. Mod/Ref information is
13 : // also captured by this interface.
14 : //
15 : // Implementations of this interface must implement the various virtual methods,
16 : // which automatically provides functionality for the entire suite of client
17 : // APIs.
18 : //
19 : // This API identifies memory regions with the MemoryLocation class. The pointer
20 : // component specifies the base memory address of the region. The Size specifies
21 : // the maximum size (in address units) of the memory region, or
22 : // MemoryLocation::UnknownSize if the size is not known. The TBAA tag
23 : // identifies the "type" of the memory reference; see the
24 : // TypeBasedAliasAnalysis class for details.
25 : //
26 : // Some non-obvious details include:
27 : // - Pointers that point to two completely different objects in memory never
28 : // alias, regardless of the value of the Size component.
29 : // - NoAlias doesn't imply inequal pointers. The most obvious example of this
30 : // is two pointers to constant memory. Even if they are equal, constant
31 : // memory is never stored to, so there will never be any dependencies.
32 : // In this and other situations, the pointers may be both NoAlias and
33 : // MustAlias at the same time. The current API can only return one result,
34 : // though this is rarely a problem in practice.
35 : //
36 : //===----------------------------------------------------------------------===//
37 :
38 : #ifndef LLVM_ANALYSIS_ALIASANALYSIS_H
39 : #define LLVM_ANALYSIS_ALIASANALYSIS_H
40 :
41 : #include "llvm/ADT/None.h"
42 : #include "llvm/ADT/Optional.h"
43 : #include "llvm/ADT/SmallVector.h"
44 : #include "llvm/Analysis/MemoryLocation.h"
45 : #include "llvm/Analysis/TargetLibraryInfo.h"
46 : #include "llvm/IR/CallSite.h"
47 : #include "llvm/IR/Function.h"
48 : #include "llvm/IR/Instruction.h"
49 : #include "llvm/IR/Instructions.h"
50 : #include "llvm/IR/PassManager.h"
51 : #include "llvm/Pass.h"
52 : #include <cstdint>
53 : #include <functional>
54 : #include <memory>
55 : #include <vector>
56 :
57 : namespace llvm {
58 :
59 : class AnalysisUsage;
60 : class BasicAAResult;
61 : class BasicBlock;
62 : class DominatorTree;
63 : class OrderedBasicBlock;
64 : class Value;
65 :
66 : /// The possible results of an alias query.
67 : ///
68 : /// These results are always computed between two MemoryLocation objects as
69 : /// a query to some alias analysis.
70 : ///
71 : /// Note that these are unscoped enumerations because we would like to support
72 : /// implicitly testing a result for the existence of any possible aliasing with
73 : /// a conversion to bool, but an "enum class" doesn't support this. The
74 : /// canonical names from the literature are suffixed and unique anyways, and so
75 : /// they serve as global constants in LLVM for these results.
76 : ///
77 : /// See docs/AliasAnalysis.html for more information on the specific meanings
78 : /// of these values.
79 : enum AliasResult : uint8_t {
80 : /// The two locations do not alias at all.
81 : ///
82 : /// This value is arranged to convert to false, while all other values
83 : /// convert to true. This allows a boolean context to convert the result to
84 : /// a binary flag indicating whether there is the possibility of aliasing.
85 : NoAlias = 0,
86 : /// The two locations may or may not alias. This is the least precise result.
87 : MayAlias,
88 : /// The two locations alias, but only due to a partial overlap.
89 : PartialAlias,
90 : /// The two locations precisely alias each other.
91 : MustAlias,
92 : };
93 :
94 : /// << operator for AliasResult.
95 : raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
96 :
97 : /// Flags indicating whether a memory access modifies or references memory.
98 : ///
99 : /// This is no access at all, a modification, a reference, or both
100 : /// a modification and a reference. These are specifically structured such that
101 : /// they form a three bit matrix and bit-tests for 'mod' or 'ref' or 'must'
102 : /// work with any of the possible values.
103 : enum class ModRefInfo : uint8_t {
104 : /// Must is provided for completeness, but no routines will return only
105 : /// Must today. See definition of Must below.
106 : Must = 0,
107 : /// The access may reference the value stored in memory,
108 : /// a mustAlias relation was found, and no mayAlias or partialAlias found.
109 : MustRef = 1,
110 : /// The access may modify the value stored in memory,
111 : /// a mustAlias relation was found, and no mayAlias or partialAlias found.
112 : MustMod = 2,
113 : /// The access may reference, modify or both the value stored in memory,
114 : /// a mustAlias relation was found, and no mayAlias or partialAlias found.
115 : MustModRef = MustRef | MustMod,
116 : /// The access neither references nor modifies the value stored in memory.
117 : NoModRef = 4,
118 : /// The access may reference the value stored in memory.
119 : Ref = NoModRef | MustRef,
120 : /// The access may modify the value stored in memory.
121 : Mod = NoModRef | MustMod,
122 : /// The access may reference and may modify the value stored in memory.
123 : ModRef = Ref | Mod,
124 :
125 : /// About Must:
126 : /// Must is set in a best effort manner.
127 : /// We usually do not try our best to infer Must, instead it is merely
128 : /// another piece of "free" information that is presented when available.
129 : /// Must set means there was certainly a MustAlias found. For calls,
130 : /// where multiple arguments are checked (argmemonly), this translates to
131 : /// only MustAlias or NoAlias was found.
132 : /// Must is not set for RAR accesses, even if the two locations must
133 : /// alias. The reason is that two read accesses translate to an early return
134 : /// of NoModRef. An additional alias check to set Must may be
135 : /// expensive. Other cases may also not set Must(e.g. callCapturesBefore).
136 : /// We refer to Must being *set* when the most significant bit is *cleared*.
137 : /// Conversely we *clear* Must information by *setting* the Must bit to 1.
138 : };
139 :
140 : LLVM_NODISCARD inline bool isNoModRef(const ModRefInfo MRI) {
141 : return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
142 : static_cast<int>(ModRefInfo::Must);
143 : }
144 : LLVM_NODISCARD inline bool isModOrRefSet(const ModRefInfo MRI) {
145 11965 : return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef);
146 : }
147 : LLVM_NODISCARD inline bool isModAndRefSet(const ModRefInfo MRI) {
148 : return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
149 : static_cast<int>(ModRefInfo::MustModRef);
150 : }
151 : LLVM_NODISCARD inline bool isModSet(const ModRefInfo MRI) {
152 3222332 : return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustMod);
153 : }
154 : LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) {
155 3373531 : return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustRef);
156 : }
157 : LLVM_NODISCARD inline bool isMustSet(const ModRefInfo MRI) {
158 5863 : return !(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::NoModRef));
159 : }
160 :
161 : LLVM_NODISCARD inline ModRefInfo setMod(const ModRefInfo MRI) {
162 : return ModRefInfo(static_cast<int>(MRI) |
163 8876 : static_cast<int>(ModRefInfo::MustMod));
164 : }
165 : LLVM_NODISCARD inline ModRefInfo setRef(const ModRefInfo MRI) {
166 : return ModRefInfo(static_cast<int>(MRI) |
167 539 : static_cast<int>(ModRefInfo::MustRef));
168 : }
169 : LLVM_NODISCARD inline ModRefInfo setMust(const ModRefInfo MRI) {
170 : return ModRefInfo(static_cast<int>(MRI) &
171 13975 : static_cast<int>(ModRefInfo::MustModRef));
172 : }
173 : LLVM_NODISCARD inline ModRefInfo setModAndRef(const ModRefInfo MRI) {
174 : return ModRefInfo(static_cast<int>(MRI) |
175 1115 : static_cast<int>(ModRefInfo::MustModRef));
176 : }
177 : LLVM_NODISCARD inline ModRefInfo clearMod(const ModRefInfo MRI) {
178 24745 : return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref));
179 : }
180 : LLVM_NODISCARD inline ModRefInfo clearRef(const ModRefInfo MRI) {
181 30 : return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod));
182 : }
183 : LLVM_NODISCARD inline ModRefInfo clearMust(const ModRefInfo MRI) {
184 : return ModRefInfo(static_cast<int>(MRI) |
185 19903972 : static_cast<int>(ModRefInfo::NoModRef));
186 : }
187 : LLVM_NODISCARD inline ModRefInfo unionModRef(const ModRefInfo MRI1,
188 : const ModRefInfo MRI2) {
189 44921 : return ModRefInfo(static_cast<int>(MRI1) | static_cast<int>(MRI2));
190 : }
191 : LLVM_NODISCARD inline ModRefInfo intersectModRef(const ModRefInfo MRI1,
192 : const ModRefInfo MRI2) {
193 46769761 : return ModRefInfo(static_cast<int>(MRI1) & static_cast<int>(MRI2));
194 : }
195 :
196 : /// The locations at which a function might access memory.
197 : ///
198 : /// These are primarily used in conjunction with the \c AccessKind bits to
199 : /// describe both the nature of access and the locations of access for a
200 : /// function call.
201 : enum FunctionModRefLocation {
202 : /// Base case is no access to memory.
203 : FMRL_Nowhere = 0,
204 : /// Access to memory via argument pointers.
205 : FMRL_ArgumentPointees = 8,
206 : /// Memory that is inaccessible via LLVM IR.
207 : FMRL_InaccessibleMem = 16,
208 : /// Access to any memory.
209 : FMRL_Anywhere = 32 | FMRL_InaccessibleMem | FMRL_ArgumentPointees
210 : };
211 :
212 : /// Summary of how a function affects memory in the program.
213 : ///
214 : /// Loads from constant globals are not considered memory accesses for this
215 : /// interface. Also, functions may freely modify stack space local to their
216 : /// invocation without having to report it through these interfaces.
217 : enum FunctionModRefBehavior {
218 : /// This function does not perform any non-local loads or stores to memory.
219 : ///
220 : /// This property corresponds to the GCC 'const' attribute.
221 : /// This property corresponds to the LLVM IR 'readnone' attribute.
222 : /// This property corresponds to the IntrNoMem LLVM intrinsic flag.
223 : FMRB_DoesNotAccessMemory =
224 : FMRL_Nowhere | static_cast<int>(ModRefInfo::NoModRef),
225 :
226 : /// The only memory references in this function (if it has any) are
227 : /// non-volatile loads from objects pointed to by its pointer-typed
228 : /// arguments, with arbitrary offsets.
229 : ///
230 : /// This property corresponds to the IntrReadArgMem LLVM intrinsic flag.
231 : FMRB_OnlyReadsArgumentPointees =
232 : FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::Ref),
233 :
234 : /// The only memory references in this function (if it has any) are
235 : /// non-volatile loads and stores from objects pointed to by its
236 : /// pointer-typed arguments, with arbitrary offsets.
237 : ///
238 : /// This property corresponds to the IntrArgMemOnly LLVM intrinsic flag.
239 : FMRB_OnlyAccessesArgumentPointees =
240 : FMRL_ArgumentPointees | static_cast<int>(ModRefInfo::ModRef),
241 :
242 : /// The only memory references in this function (if it has any) are
243 : /// references of memory that is otherwise inaccessible via LLVM IR.
244 : ///
245 : /// This property corresponds to the LLVM IR inaccessiblememonly attribute.
246 : FMRB_OnlyAccessesInaccessibleMem =
247 : FMRL_InaccessibleMem | static_cast<int>(ModRefInfo::ModRef),
248 :
249 : /// The function may perform non-volatile loads and stores of objects
250 : /// pointed to by its pointer-typed arguments, with arbitrary offsets, and
251 : /// it may also perform loads and stores of memory that is otherwise
252 : /// inaccessible via LLVM IR.
253 : ///
254 : /// This property corresponds to the LLVM IR
255 : /// inaccessiblemem_or_argmemonly attribute.
256 : FMRB_OnlyAccessesInaccessibleOrArgMem = FMRL_InaccessibleMem |
257 : FMRL_ArgumentPointees |
258 : static_cast<int>(ModRefInfo::ModRef),
259 :
260 : /// This function does not perform any non-local stores or volatile loads,
261 : /// but may read from any memory location.
262 : ///
263 : /// This property corresponds to the GCC 'pure' attribute.
264 : /// This property corresponds to the LLVM IR 'readonly' attribute.
265 : /// This property corresponds to the IntrReadMem LLVM intrinsic flag.
266 : FMRB_OnlyReadsMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Ref),
267 :
268 : // This function does not read from memory anywhere, but may write to any
269 : // memory location.
270 : //
271 : // This property corresponds to the LLVM IR 'writeonly' attribute.
272 : // This property corresponds to the IntrWriteMem LLVM intrinsic flag.
273 : FMRB_DoesNotReadMemory = FMRL_Anywhere | static_cast<int>(ModRefInfo::Mod),
274 :
275 : /// This indicates that the function could not be classified into one of the
276 : /// behaviors above.
277 : FMRB_UnknownModRefBehavior =
278 : FMRL_Anywhere | static_cast<int>(ModRefInfo::ModRef)
279 : };
280 :
281 : // Wrapper method strips bits significant only in FunctionModRefBehavior,
282 : // to obtain a valid ModRefInfo. The benefit of using the wrapper is that if
283 : // ModRefInfo enum changes, the wrapper can be updated to & with the new enum
284 : // entry with all bits set to 1.
285 : LLVM_NODISCARD inline ModRefInfo
286 : createModRefInfo(const FunctionModRefBehavior FMRB) {
287 8308329 : return ModRefInfo(FMRB & static_cast<int>(ModRefInfo::ModRef));
288 : }
289 :
290 : class AAResults {
291 : public:
292 : // Make these results default constructable and movable. We have to spell
293 : // these out because MSVC won't synthesize them.
294 2658406 : AAResults(const TargetLibraryInfo &TLI) : TLI(TLI) {}
295 : AAResults(AAResults &&Arg);
296 : ~AAResults();
297 :
298 : /// Register a specific AA result.
299 6203937 : template <typename AAResultT> void addAAResult(AAResultT &AAResult) {
300 : // FIXME: We should use a much lighter weight system than the usual
301 : // polymorphic pattern because we don't own AAResult. It should
302 : // ideally involve two pointers and no separate allocation.
303 6203937 : AAs.emplace_back(new Model<AAResultT>(AAResult, *this));
304 6203937 : }
305 71 :
306 : /// Register a function analysis ID that the results aggregation depends on.
307 : ///
308 : /// This is used in the new pass manager to implement the invalidation logic
309 71 : /// where we must invalidate the results aggregation if any of our component
310 71 : /// analyses become invalid.
311 85 : void addAADependencyID(AnalysisKey *ID) { AADeps.push_back(ID); }
312 :
313 : /// Handle invalidation events in the new pass manager.
314 : ///
315 85 : /// The aggregation is invalidated if any of the underlying analyses is
316 85 : /// invalidated.
317 48 : bool invalidate(Function &F, const PreservedAnalyses &PA,
318 : FunctionAnalysisManager::Invalidator &Inv);
319 :
320 : //===--------------------------------------------------------------------===//
321 48 : /// \name Alias Queries
322 48 : /// @{
323 727447 :
324 : /// The main low level interface to the alias analysis implementation.
325 : /// Returns an AliasResult indicating whether the two pointers are aliased to
326 : /// each other. This is the interface that must be implemented by specific
327 727447 : /// alias analysis implementations.
328 727447 : AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
329 1301 :
330 : /// A convenience wrapper around the primary \c alias interface.
331 173611 : AliasResult alias(const Value *V1, LocationSize V1Size, const Value *V2,
332 : LocationSize V2Size) {
333 174912 : return alias(MemoryLocation(V1, V1Size), MemoryLocation(V2, V2Size));
334 1301 : }
335 1330979 :
336 : /// A convenience wrapper around the primary \c alias interface.
337 : AliasResult alias(const Value *V1, const Value *V2) {
338 737 : return alias(V1, LocationSize::unknown(), V2, LocationSize::unknown());
339 1330979 : }
340 1330979 :
341 1331400 : /// A trivial helper function to check to see if the specified pointers are
342 : /// no-alias.
343 4 : bool isNoAlias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
344 653 : return alias(LocA, LocB) == NoAlias;
345 1331404 : }
346 1331400 :
347 2656353 : /// A convenience wrapper around the \c isNoAlias helper interface.
348 : bool isNoAlias(const Value *V1, LocationSize V1Size, const Value *V2,
349 : LocationSize V2Size) {
350 : return isNoAlias(MemoryLocation(V1, V1Size), MemoryLocation(V2, V2Size));
351 2656353 : }
352 2656353 :
353 1652 : /// A convenience wrapper around the \c isNoAlias helper interface.
354 0 : bool isNoAlias(const Value *V1, const Value *V2) {
355 0 : return isNoAlias(MemoryLocation(V1), MemoryLocation(V2));
356 : }
357 :
358 : /// A trivial helper function to check to see if the specified pointers are
359 : /// must-alias.
360 : bool isMustAlias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
361 164271 : return alias(LocA, LocB) == MustAlias;
362 : }
363 :
364 : /// A convenience wrapper around the \c isMustAlias helper interface.
365 : bool isMustAlias(const Value *V1, const Value *V2) {
366 167518 : return alias(V1, 1, V2, 1) == MustAlias;
367 : }
368 :
369 : /// Checks whether the given location points to constant memory, or if
370 : /// \p OrLocal is true whether it points to a local alloca.
371 : bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal = false);
372 :
373 : /// A convenience wrapper around the primary \c pointsToConstantMemory
374 : /// interface.
375 : bool pointsToConstantMemory(const Value *P, bool OrLocal = false) {
376 1037453 : return pointsToConstantMemory(MemoryLocation(P), OrLocal);
377 : }
378 :
379 : /// @}
380 : //===--------------------------------------------------------------------===//
381 : /// \name Simple mod/ref information
382 : /// @{
383 :
384 : /// Get the ModRef info associated with a pointer argument of a callsite. The
385 : /// result's bits are set to indicate the allowed aliasing ModRef kinds. Note
386 : /// that these bits do not necessarily account for the overall behavior of
387 : /// the function, but rather only provide additional per-argument
388 : /// information. This never sets ModRefInfo::Must.
389 : ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx);
390 :
391 : /// Return the behavior of the given call site.
392 : FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS);
393 :
394 : /// Return the behavior when calling the given function.
395 : FunctionModRefBehavior getModRefBehavior(const Function *F);
396 :
397 : /// Checks if the specified call is known to never read or write memory.
398 : ///
399 : /// Note that if the call only reads from known-constant memory, it is also
400 : /// legal to return true. Also, calls that unwind the stack are legal for
401 : /// this predicate.
402 : ///
403 : /// Many optimizations (such as CSE and LICM) can be performed on such calls
404 : /// without worrying about aliasing properties, and many calls have this
405 : /// property (e.g. calls to 'sin' and 'cos').
406 : ///
407 : /// This property corresponds to the GCC 'const' attribute.
408 : bool doesNotAccessMemory(ImmutableCallSite CS) {
409 92531 : return getModRefBehavior(CS) == FMRB_DoesNotAccessMemory;
410 : }
411 :
412 : /// Checks if the specified function is known to never read or write memory.
413 : ///
414 : /// Note that if the function only reads from known-constant memory, it is
415 : /// also legal to return true. Also, function that unwind the stack are legal
416 : /// for this predicate.
417 : ///
418 : /// Many optimizations (such as CSE and LICM) can be performed on such calls
419 : /// to such functions without worrying about aliasing properties, and many
420 : /// functions have this property (e.g. 'sin' and 'cos').
421 : ///
422 : /// This property corresponds to the GCC 'const' attribute.
423 : bool doesNotAccessMemory(const Function *F) {
424 : return getModRefBehavior(F) == FMRB_DoesNotAccessMemory;
425 : }
426 :
427 : /// Checks if the specified call is known to only read from non-volatile
428 : /// memory (or not access memory at all).
429 : ///
430 : /// Calls that unwind the stack are legal for this predicate.
431 : ///
432 : /// This property allows many common optimizations to be performed in the
433 : /// absence of interfering store instructions, such as CSE of strlen calls.
434 : ///
435 : /// This property corresponds to the GCC 'pure' attribute.
436 : bool onlyReadsMemory(ImmutableCallSite CS) {
437 54989 : return onlyReadsMemory(getModRefBehavior(CS));
438 : }
439 :
440 : /// Checks if the specified function is known to only read from non-volatile
441 : /// memory (or not access memory at all).
442 : ///
443 : /// Functions that unwind the stack are legal for this predicate.
444 : ///
445 : /// This property allows many common optimizations to be performed in the
446 : /// absence of interfering store instructions, such as CSE of strlen calls.
447 : ///
448 : /// This property corresponds to the GCC 'pure' attribute.
449 : bool onlyReadsMemory(const Function *F) {
450 : return onlyReadsMemory(getModRefBehavior(F));
451 : }
452 :
453 : /// Checks if functions with the specified behavior are known to only read
454 : /// from non-volatile memory (or not access memory at all).
455 : static bool onlyReadsMemory(FunctionModRefBehavior MRB) {
456 29976 : return !isModSet(createModRefInfo(MRB));
457 : }
458 :
459 : /// Checks if functions with the specified behavior are known to only write
460 : /// memory (or not access memory at all).
461 : static bool doesNotReadMemory(FunctionModRefBehavior MRB) {
462 : return !isRefSet(createModRefInfo(MRB));
463 : }
464 :
465 : /// Checks if functions with the specified behavior are known to read and
466 : /// write at most from objects pointed to by their pointer-typed arguments
467 : /// (with arbitrary offsets).
468 : static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB) {
469 98952 : return !(MRB & FMRL_Anywhere & ~FMRL_ArgumentPointees);
470 : }
471 :
472 : /// Checks if functions with the specified behavior are known to potentially
473 : /// read or write from objects pointed to be their pointer-typed arguments
474 : /// (with arbitrary offsets).
475 : static bool doesAccessArgPointees(FunctionModRefBehavior MRB) {
476 : return isModOrRefSet(createModRefInfo(MRB)) &&
477 : (MRB & FMRL_ArgumentPointees);
478 : }
479 :
480 : /// Checks if functions with the specified behavior are known to read and
481 : /// write at most from memory that is inaccessible from LLVM IR.
482 : static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB) {
483 : return !(MRB & FMRL_Anywhere & ~FMRL_InaccessibleMem);
484 : }
485 :
486 : /// Checks if functions with the specified behavior are known to potentially
487 : /// read or write from memory that is inaccessible from LLVM IR.
488 : static bool doesAccessInaccessibleMem(FunctionModRefBehavior MRB) {
489 : return isModOrRefSet(createModRefInfo(MRB)) && (MRB & FMRL_InaccessibleMem);
490 : }
491 :
492 : /// Checks if functions with the specified behavior are known to read and
493 : /// write at most from memory that is inaccessible from LLVM IR or objects
494 : /// pointed to by their pointer-typed arguments (with arbitrary offsets).
495 : static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB) {
496 : return !(MRB & FMRL_Anywhere &
497 : ~(FMRL_InaccessibleMem | FMRL_ArgumentPointees));
498 : }
499 :
500 : /// getModRefInfo (for call sites) - Return information about whether
501 : /// a particular call site modifies or reads the specified memory location.
502 : ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc);
503 :
504 : /// getModRefInfo (for call sites) - A convenience wrapper.
505 : ModRefInfo getModRefInfo(ImmutableCallSite CS, const Value *P,
506 : LocationSize Size) {
507 958 : return getModRefInfo(CS, MemoryLocation(P, Size));
508 : }
509 :
510 : /// getModRefInfo (for calls) - Return information about whether
511 : /// a particular call modifies or reads the specified memory location.
512 : ModRefInfo getModRefInfo(const CallInst *C, const MemoryLocation &Loc) {
513 1462456 : return getModRefInfo(ImmutableCallSite(C), Loc);
514 : }
515 :
516 : /// getModRefInfo (for calls) - A convenience wrapper.
517 7558710 : ModRefInfo getModRefInfo(const CallInst *C, const Value *P,
518 : LocationSize Size) {
519 27 : return getModRefInfo(C, MemoryLocation(P, Size));
520 : }
521 :
522 : /// getModRefInfo (for invokes) - Return information about whether
523 : /// a particular invoke modifies or reads the specified memory location.
524 5255800 : ModRefInfo getModRefInfo(const InvokeInst *I, const MemoryLocation &Loc) {
525 5974396 : return getModRefInfo(ImmutableCallSite(I), Loc);
526 : }
527 :
528 : /// getModRefInfo (for invokes) - A convenience wrapper.
529 : ModRefInfo getModRefInfo(const InvokeInst *I, const Value *P,
530 : LocationSize Size) {
531 : return getModRefInfo(I, MemoryLocation(P, Size));
532 : }
533 :
534 : /// getModRefInfo (for loads) - Return information about whether
535 : /// a particular load modifies or reads the specified memory location.
536 : ModRefInfo getModRefInfo(const LoadInst *L, const MemoryLocation &Loc);
537 0 :
538 : /// getModRefInfo (for loads) - A convenience wrapper.
539 : ModRefInfo getModRefInfo(const LoadInst *L, const Value *P,
540 : LocationSize Size) {
541 : return getModRefInfo(L, MemoryLocation(P, Size));
542 : }
543 :
544 2273962 : /// getModRefInfo (for stores) - Return information about whether
545 : /// a particular store modifies or reads the specified memory location.
546 : ModRefInfo getModRefInfo(const StoreInst *S, const MemoryLocation &Loc);
547 :
548 : /// getModRefInfo (for stores) - A convenience wrapper.
549 : ModRefInfo getModRefInfo(const StoreInst *S, const Value *P,
550 : LocationSize Size) {
551 4483813 : return getModRefInfo(S, MemoryLocation(P, Size));
552 : }
553 :
554 : /// getModRefInfo (for fences) - Return information about whether
555 : /// a particular store modifies or reads the specified memory location.
556 : ModRefInfo getModRefInfo(const FenceInst *S, const MemoryLocation &Loc);
557 :
558 : /// getModRefInfo (for fences) - A convenience wrapper.
559 : ModRefInfo getModRefInfo(const FenceInst *S, const Value *P,
560 : LocationSize Size) {
561 116 : return getModRefInfo(S, MemoryLocation(P, Size));
562 : }
563 :
564 : /// getModRefInfo (for cmpxchges) - Return information about whether
565 : /// a particular cmpxchg modifies or reads the specified memory location.
566 : ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX,
567 : const MemoryLocation &Loc);
568 :
569 : /// getModRefInfo (for cmpxchges) - A convenience wrapper.
570 : ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX, const Value *P,
571 : unsigned Size) {
572 : return getModRefInfo(CX, MemoryLocation(P, Size));
573 0 : }
574 :
575 : /// getModRefInfo (for atomicrmws) - Return information about whether
576 : /// a particular atomicrmw modifies or reads the specified memory location.
577 : ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const MemoryLocation &Loc);
578 :
579 : /// getModRefInfo (for atomicrmws) - A convenience wrapper.
580 : ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const Value *P,
581 : unsigned Size) {
582 : return getModRefInfo(RMW, MemoryLocation(P, Size));
583 : }
584 :
585 : /// getModRefInfo (for va_args) - Return information about whether
586 : /// a particular va_arg modifies or reads the specified memory location.
587 : ModRefInfo getModRefInfo(const VAArgInst *I, const MemoryLocation &Loc);
588 :
589 : /// getModRefInfo (for va_args) - A convenience wrapper.
590 : ModRefInfo getModRefInfo(const VAArgInst *I, const Value *P,
591 : LocationSize Size) {
592 : return getModRefInfo(I, MemoryLocation(P, Size));
593 : }
594 :
595 : /// getModRefInfo (for catchpads) - Return information about whether
596 : /// a particular catchpad modifies or reads the specified memory location.
597 : ModRefInfo getModRefInfo(const CatchPadInst *I, const MemoryLocation &Loc);
598 :
599 : /// getModRefInfo (for catchpads) - A convenience wrapper.
600 : ModRefInfo getModRefInfo(const CatchPadInst *I, const Value *P,
601 : LocationSize Size) {
602 : return getModRefInfo(I, MemoryLocation(P, Size));
603 : }
604 :
605 : /// getModRefInfo (for catchrets) - Return information about whether
606 : /// a particular catchret modifies or reads the specified memory location.
607 : ModRefInfo getModRefInfo(const CatchReturnInst *I, const MemoryLocation &Loc);
608 :
609 : /// getModRefInfo (for catchrets) - A convenience wrapper.
610 : ModRefInfo getModRefInfo(const CatchReturnInst *I, const Value *P,
611 : LocationSize Size) {
612 : return getModRefInfo(I, MemoryLocation(P, Size));
613 : }
614 :
615 : /// Check whether or not an instruction may read or write the optionally
616 : /// specified memory location.
617 : ///
618 : ///
619 : /// An instruction that doesn't read or write memory may be trivially LICM'd
620 : /// for example.
621 : ///
622 : /// For function calls, this delegates to the alias-analysis specific
623 : /// call-site mod-ref behavior queries. Otherwise it delegates to the specific
624 : /// helpers above.
625 27333650 : ModRefInfo getModRefInfo(const Instruction *I,
626 : const Optional<MemoryLocation> &OptLoc) {
627 27333650 : if (OptLoc == None) {
628 3373536 : if (auto CS = ImmutableCallSite(I)) {
629 426466 : return createModRefInfo(getModRefBehavior(CS));
630 : }
631 : }
632 :
633 : const MemoryLocation &Loc = OptLoc.getValueOr(MemoryLocation());
634 :
635 26907184 : switch (I->getOpcode()) {
636 1 : case Instruction::VAArg: return getModRefInfo((const VAArgInst*)I, Loc);
637 701229 : case Instruction::Load: return getModRefInfo((const LoadInst*)I, Loc);
638 3705635 : case Instruction::Store: return getModRefInfo((const StoreInst*)I, Loc);
639 542 : case Instruction::Fence: return getModRefInfo((const FenceInst*)I, Loc);
640 1560 : case Instruction::AtomicCmpXchg:
641 1554 : return getModRefInfo((const AtomicCmpXchgInst*)I, Loc);
642 2552 : case Instruction::AtomicRMW:
643 2552 : return getModRefInfo((const AtomicRMWInst*)I, Loc);
644 1462421 : case Instruction::Call: return getModRefInfo((const CallInst*)I, Loc);
645 718596 : case Instruction::Invoke: return getModRefInfo((const InvokeInst*)I,Loc);
646 2 : case Instruction::CatchPad:
647 9 : return getModRefInfo((const CatchPadInst *)I, Loc);
648 7 : case Instruction::CatchRet:
649 7 : return getModRefInfo((const CatchReturnInst *)I, Loc);
650 1 : default:
651 0 : return ModRefInfo::NoModRef;
652 1 : }
653 1 : }
654 1 :
655 1 : /// A convenience wrapper for constructing the memory location.
656 783210 : ModRefInfo getModRefInfo(const Instruction *I, const Value *P,
657 0 : LocationSize Size) {
658 783210 : return getModRefInfo(I, MemoryLocation(P, Size));
659 0 : }
660 0 :
661 0 : /// Return information about whether a call and an instruction may refer to
662 : /// the same memory locations.
663 : ModRefInfo getModRefInfo(Instruction *I, ImmutableCallSite Call);
664 :
665 : /// Return information about whether two call sites may refer to the same set
666 : /// of memory locations. See the AA documentation for details:
667 : /// http://llvm.org/docs/AliasAnalysis.html#ModRefInfo
668 : ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2);
669 :
670 : /// Return information about whether a particular call site modifies
671 : /// or reads the specified memory location \p MemLoc before instruction \p I
672 : /// in a BasicBlock. An ordered basic block \p OBB can be used to speed up
673 2025 : /// instruction ordering queries inside the BasicBlock containing \p I.
674 : /// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being
675 2025 : /// set.
676 0 : ModRefInfo callCapturesBefore(const Instruction *I,
677 0 : const MemoryLocation &MemLoc, DominatorTree *DT,
678 : OrderedBasicBlock *OBB = nullptr);
679 :
680 : /// A convenience wrapper to synthesize a memory location.
681 : ModRefInfo callCapturesBefore(const Instruction *I, const Value *P,
682 : LocationSize Size, DominatorTree *DT,
683 2025 : OrderedBasicBlock *OBB = nullptr) {
684 4 : return callCapturesBefore(I, MemoryLocation(P, Size), DT, OBB);
685 440 : }
686 513 :
687 0 : /// @}
688 0 : //===--------------------------------------------------------------------===//
689 0 : /// \name Higher level methods for querying mod/ref information.
690 0 : /// @{
691 0 :
692 116 : /// Check if it is possible for execution of the specified basic block to
693 0 : /// modify the location Loc.
694 0 : bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc);
695 0 :
696 0 : /// A convenience wrapper synthesizing a memory location.
697 0 : bool canBasicBlockModify(const BasicBlock &BB, const Value *P,
698 : LocationSize Size) {
699 : return canBasicBlockModify(BB, MemoryLocation(P, Size));
700 : }
701 :
702 : /// Check if it is possible for the execution of the specified instructions
703 : /// to mod\ref (according to the mode) the location Loc.
704 : ///
705 : /// The instructions to consider are all of the instructions in the range of
706 : /// [I1,I2] INCLUSIVE. I1 and I2 must be in the same basic block.
707 : bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
708 : const MemoryLocation &Loc,
709 : const ModRefInfo Mode);
710 :
711 : /// A convenience wrapper synthesizing a memory location.
712 : bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2,
713 : const Value *Ptr, LocationSize Size,
714 : const ModRefInfo Mode) {
715 : return canInstructionRangeModRef(I1, I2, MemoryLocation(Ptr, Size), Mode);
716 : }
717 :
718 : private:
719 : class Concept;
720 :
721 : template <typename T> class Model;
722 :
723 : template <typename T> friend class AAResultBase;
724 :
725 : const TargetLibraryInfo &TLI;
726 :
727 : std::vector<std::unique_ptr<Concept>> AAs;
728 :
729 : std::vector<AnalysisKey *> AADeps;
730 : };
731 :
732 : /// Temporary typedef for legacy code that uses a generic \c AliasAnalysis
733 : /// pointer or reference.
734 : using AliasAnalysis = AAResults;
735 :
736 : /// A private abstract base class describing the concept of an individual alias
737 : /// analysis implementation.
738 : ///
739 : /// This interface is implemented by any \c Model instantiation. It is also the
740 : /// interface which a type used to instantiate the model must provide.
741 : ///
742 : /// All of these methods model methods by the same name in the \c
743 : /// AAResults class. Only differences and specifics to how the
744 : /// implementations are called are documented here.
745 : class AAResults::Concept {
746 : public:
747 : virtual ~Concept() = 0;
748 :
749 : /// An update API used internally by the AAResults to provide
750 : /// a handle back to the top level aggregation.
751 : virtual void setAAResults(AAResults *NewAAR) = 0;
752 :
753 : //===--------------------------------------------------------------------===//
754 : /// \name Alias Queries
755 : /// @{
756 :
757 : /// The main low level interface to the alias analysis implementation.
758 : /// Returns an AliasResult indicating whether the two pointers are aliased to
759 : /// each other. This is the interface that must be implemented by specific
760 : /// alias analysis implementations.
761 : virtual AliasResult alias(const MemoryLocation &LocA,
762 : const MemoryLocation &LocB) = 0;
763 :
764 : /// Checks whether the given location points to constant memory, or if
765 : /// \p OrLocal is true whether it points to a local alloca.
766 : virtual bool pointsToConstantMemory(const MemoryLocation &Loc,
767 : bool OrLocal) = 0;
768 :
769 : /// @}
770 : //===--------------------------------------------------------------------===//
771 : /// \name Simple mod/ref information
772 : /// @{
773 :
774 : /// Get the ModRef info associated with a pointer argument of a callsite. The
775 : /// result's bits are set to indicate the allowed aliasing ModRef kinds. Note
776 : /// that these bits do not necessarily account for the overall behavior of
777 : /// the function, but rather only provide additional per-argument
778 : /// information.
779 : virtual ModRefInfo getArgModRefInfo(ImmutableCallSite CS,
780 : unsigned ArgIdx) = 0;
781 :
782 : /// Return the behavior of the given call site.
783 : virtual FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) = 0;
784 :
785 : /// Return the behavior when calling the given function.
786 : virtual FunctionModRefBehavior getModRefBehavior(const Function *F) = 0;
787 :
788 : /// getModRefInfo (for call sites) - Return information about whether
789 : /// a particular call site modifies or reads the specified memory location.
790 : virtual ModRefInfo getModRefInfo(ImmutableCallSite CS,
791 : const MemoryLocation &Loc) = 0;
792 :
793 6202982 : /// Return information about whether two call sites may refer to the same set
794 : /// of memory locations. See the AA documentation for details:
795 : /// http://llvm.org/docs/AliasAnalysis.html#ModRefInfo
796 : virtual ModRefInfo getModRefInfo(ImmutableCallSite CS1,
797 : ImmutableCallSite CS2) = 0;
798 :
799 : /// @}
800 : };
801 :
802 : /// A private class template which derives from \c Concept and wraps some other
803 : /// type.
804 : ///
805 : /// This models the concept by directly forwarding each interface point to the
806 : /// wrapped type which must implement a compatible interface. This provides
807 : /// a type erased binding.
808 : template <typename AAResultT> class AAResults::Model final : public Concept {
809 : AAResultT &Result;
810 :
811 : public:
812 156253 : explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {
813 : Result.setAAResults(&AAR);
814 : }
815 156160 : ~Model() override = default;
816 :
817 0 : void setAAResults(AAResults *NewAAR) override { Result.setAAResults(NewAAR); }
818 :
819 74837 : AliasResult alias(const MemoryLocation &LocA,
820 : const MemoryLocation &LocB) override {
821 74837 : return Result.alias(LocA, LocB);
822 : }
823 :
824 89123 : bool pointsToConstantMemory(const MemoryLocation &Loc,
825 : bool OrLocal) override {
826 89121 : return Result.pointsToConstantMemory(Loc, OrLocal);
827 33 : }
828 :
829 23 : ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) override {
830 23 : return Result.getArgModRefInfo(CS, ArgIdx);
831 92 : }
832 :
833 1390 : FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override {
834 1298 : return Result.getModRefBehavior(CS);
835 88 : }
836 :
837 1094 : FunctionModRefBehavior getModRefBehavior(const Function *F) override {
838 1006 : return Result.getModRefBehavior(F);
839 4 : }
840 :
841 12686 : ModRefInfo getModRefInfo(ImmutableCallSite CS,
842 : const MemoryLocation &Loc) override {
843 12682 : return Result.getModRefInfo(CS, Loc);
844 77 : }
845 :
846 225 : ModRefInfo getModRefInfo(ImmutableCallSite CS1,
847 : ImmutableCallSite CS2) override {
848 225 : return Result.getModRefInfo(CS1, CS2);
849 : }
850 77 : };
851 :
852 0 : /// A CRTP-driven "mixin" base class to help implement the function alias
853 : /// analysis results concept.
854 1877 : ///
855 : /// Because of the nature of many alias analysis implementations, they often
856 : /// only implement a subset of the interface. This base class will attempt to
857 0 : /// implement the remaining portions of the interface in terms of simpler forms
858 0 : /// of the interface where possible, and otherwise provide conservatively
859 0 : /// correct fallback implementations.
860 6045805 : ///
861 0 : /// Implementors of an alias analysis should derive from this CRTP, and then
862 : /// override specific methods that they wish to customize. There is no need to
863 6046793 : /// use virtual anywhere, the CRTP base class does static dispatch to the
864 0 : /// derived type passed into it.
865 3803768 : template <typename DerivedT> class AAResultBase {
866 : // Expose some parts of the interface only to the AAResults::Model
867 58901354 : // for wrapping. Specifically, this allows the model to call our
868 2 : // setAAResults method without exposing it as a fully public API.
869 58901352 : friend class AAResults::Model<DerivedT>;
870 2 :
871 39451601 : /// A pointer to the AAResults object that this AAResult is
872 : /// aggregated within. May be null if not aggregated.
873 39451599 : AAResults *AAR;
874 0 :
875 6590440 : /// Helper to dispatch calls back through the derived type.
876 : DerivedT &derived() { return static_cast<DerivedT &>(*this); }
877 6590442 :
878 2 : /// A setter for the AAResults pointer, which is used to satisfy the
879 6581675 : /// AAResults::Model contract.
880 156255 : void setAAResults(AAResults *NewAAR) { AAR = NewAAR; }
881 6581677 :
882 : protected:
883 1311 : /// This proxy class models a common pattern where we delegate to either the
884 0 : /// top-level \c AAResults aggregation if one is registered, or to the
885 1311 : /// current result if none are registered.
886 : class AAResultsProxy {
887 6272734 : AAResults *AAR;
888 : DerivedT &CurrentResult;
889 6272734 :
890 : public:
891 124 : AAResultsProxy(AAResults *AAR, DerivedT &CurrentResult)
892 : : AAR(AAR), CurrentResult(CurrentResult) {}
893 124 :
894 0 : AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
895 665 : return AAR ? AAR->alias(LocA, LocB) : CurrentResult.alias(LocA, LocB);
896 0 : }
897 665 :
898 0 : bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
899 2804 : return AAR ? AAR->pointsToConstantMemory(Loc, OrLocal)
900 0 : : CurrentResult.pointsToConstantMemory(Loc, OrLocal);
901 2804 : }
902 0 :
903 : ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
904 25107685 : return AAR ? AAR->getArgModRefInfo(CS, ArgIdx) : CurrentResult.getArgModRefInfo(CS, ArgIdx);
905 : }
906 25107685 :
907 : FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) {
908 6748391 : return AAR ? AAR->getModRefBehavior(CS) : CurrentResult.getModRefBehavior(CS);
909 : }
910 6748391 :
911 0 : FunctionModRefBehavior getModRefBehavior(const Function *F) {
912 6662982 : return AAR ? AAR->getModRefBehavior(F) : CurrentResult.getModRefBehavior(F);
913 : }
914 6662982 :
915 : ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) {
916 6663153 : return AAR ? AAR->getModRefInfo(CS, Loc)
917 : : CurrentResult.getModRefInfo(CS, Loc);
918 6663153 : }
919 :
920 1555 : ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
921 : return AAR ? AAR->getModRefInfo(CS1, CS2) : CurrentResult.getModRefInfo(CS1, CS2);
922 1555 : }
923 : };
924 5031054 :
925 : explicit AAResultBase() = default;
926 5031054 :
927 0 : // Provide all the copy and move constructors so that derived types aren't
928 0 : // constrained.
929 : AAResultBase(const AAResultBase &Arg) {}
930 1451742 : AAResultBase(AAResultBase &&Arg) {}
931 0 :
932 252 : /// Get a proxy for the best AA result set to query at this time.
933 0 : ///
934 252 : /// When this result is part of a larger aggregation, this will proxy to that
935 : /// aggregation. When this result is used in isolation, it will just delegate
936 298 : /// back to the derived class's implementation.
937 0 : ///
938 298 : /// Note that callers of this need to take considerable care to not cause
939 0 : /// performance problems when they use this routine, in the case of a large
940 0 : /// number of alias analyses being aggregated, it can be expensive to walk
941 8845260 : /// back across the chain.
942 24638824 : AAResultsProxy getBestAAResults() { return AAResultsProxy(AAR, derived()); }
943 0 :
944 2212267 : public:
945 2212267 : AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
946 0 : return MayAlias;
947 2211138 : }
948 2211138 :
949 0 : bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
950 2211148 : return false;
951 2211148 : }
952 0 :
953 7 : ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) {
954 7 : return ModRefInfo::ModRef;
955 0 : }
956 2210700 :
957 2210700 : FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) {
958 0 : return FMRB_UnknownModRefBehavior;
959 0 : }
960 0 :
961 0 : FunctionModRefBehavior getModRefBehavior(const Function *F) {
962 0 : return FMRB_UnknownModRefBehavior;
963 0 : }
964 0 :
965 0 : ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc) {
966 0 : return ModRefInfo::ModRef;
967 0 : }
968 0 :
969 41358234 : ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2) {
970 41358234 : return ModRefInfo::ModRef;
971 0 : }
972 10633384 : };
973 10633384 :
974 0 : /// Return true if this pointer is returned by a noalias function.
975 10251284 : bool isNoAliasCall(const Value *V);
976 10251284 :
977 0 : /// Return true if this is an argument with the noalias attribute.
978 10251474 : bool isNoAliasArgument(const Value *V);
979 10251474 :
980 0 : /// Return true if this pointer refers to a distinct and identifiable object.
981 3180 : /// This returns true for:
982 3180 : /// Global Variables and Functions (but not Global Aliases)
983 0 : /// Allocas
984 10218269 : /// ByVal and NoAlias Arguments
985 10218269 : /// NoAlias returns (e.g. calls to malloc)
986 0 : ///
987 0 : bool isIdentifiedObject(const Value *V);
988 0 :
989 0 : /// Return true if V is umabigously identified at the function-level.
990 284 : /// Different IdentifiedFunctionLocals can't alias.
991 284 : /// Further, an IdentifiedFunctionLocal can not alias with any function
992 0 : /// arguments other than itself, which is not necessarily true for
993 359 : /// IdentifiedObjects.
994 359 : bool isIdentifiedFunctionLocal(const Value *V);
995 0 :
996 0 : /// A manager for alias analyses.
997 40650847 : ///
998 40650847 : /// This class can have analyses registered with it and when run, it will run
999 0 : /// all of them and aggregate their results into single AA results interface
1000 10203785 : /// that dispatches across all of the alias analysis results available.
1001 10203785 : ///
1002 0 : /// Note that the order in which analyses are registered is very significant.
1003 10159273 : /// That is the order in which the results will be aggregated and queried.
1004 10159273 : ///
1005 : /// This manager effectively wraps the AnalysisManager for registering alias
1006 10159473 : /// analyses. When you register your alias analysis with this manager, it will
1007 10159473 : /// ensure the analysis itself is registered with its AnalysisManager.
1008 955 : class AAManager : public AnalysisInfoMixin<AAManager> {
1009 2790 : public:
1010 2790 : using Result = AAResults;
1011 :
1012 10125526 : /// Register a specific AA result.
1013 10125526 : template <typename AnalysisT> void registerFunctionAnalysis() {
1014 0 : ResultGetters.push_back(&getFunctionAAResultImpl<AnalysisT>);
1015 0 : }
1016 0 :
1017 : /// Register a specific AA result.
1018 0 : template <typename AnalysisT> void registerModuleAnalysis() {
1019 0 : ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
1020 0 : }
1021 0 :
1022 1843 : Result run(Function &F, FunctionAnalysisManager &AM) {
1023 0 : Result R(AM.getResult<TargetLibraryAnalysis>(F));
1024 3813 : for (auto &Getter : ResultGetters)
1025 21647055 : (*Getter)(F, AM, R);
1026 1843 : return R;
1027 21645085 : }
1028 0 :
1029 5461680 : private:
1030 0 : friend AnalysisInfoMixin<AAManager>;
1031 5461680 :
1032 0 : static AnalysisKey Key;
1033 5407971 :
1034 : SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,
1035 5407971 : AAResults &AAResults),
1036 : 4> ResultGetters;
1037 5407963 :
1038 : template <typename AnalysisT>
1039 5407963 : static void getFunctionAAResultImpl(Function &F,
1040 : FunctionAnalysisManager &AM,
1041 416 : AAResults &AAResults) {
1042 : AAResults.addAAResult(AM.template getResult<AnalysisT>(F));
1043 416 : AAResults.addAADependencyID(AnalysisT::ID());
1044 : }
1045 5366504 :
1046 : template <typename AnalysisT>
1047 5366504 : static void getModuleAAResultImpl(Function &F, FunctionAnalysisManager &AM,
1048 : AAResults &AAResults) {
1049 0 : auto &MAMProxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
1050 : auto &MAM = MAMProxy.getManager();
1051 0 : if (auto *R = MAM.template getCachedResult<AnalysisT>(*F.getParent())) {
1052 : AAResults.addAAResult(*R);
1053 252 : MAMProxy
1054 : .template registerOuterAnalysisInvalidation<AnalysisT, AAManager>();
1055 252 : }
1056 : }
1057 299 : };
1058 :
1059 299 : /// A wrapper pass to provide the legacy pass manager access to a suitably
1060 : /// prepared AAResults object.
1061 0 : class AAResultsWrapperPass : public FunctionPass {
1062 8691622 : std::unique_ptr<AAResults> AAR;
1063 0 :
1064 8691622 : public:
1065 0 : static char ID;
1066 2173425 :
1067 : AAResultsWrapperPass();
1068 2173425 :
1069 : AAResults &getAAResults() { return *AAR; }
1070 2172925 : const AAResults &getAAResults() const { return *AAR; }
1071 :
1072 2172925 : bool runOnFunction(Function &F) override;
1073 :
1074 2172899 : void getAnalysisUsage(AnalysisUsage &AU) const override;
1075 : };
1076 2172899 :
1077 : FunctionPass *createAAResultsWrapperPass();
1078 32 :
1079 : /// A wrapper pass around a callback which can be used to populate the
1080 32 : /// AAResults in the AAResultsWrapperPass from an external AA.
1081 : ///
1082 2172295 : /// The callback provided here will be used each time we prepare an AAResults
1083 : /// object, and will receive a reference to the function wrapper pass, the
1084 2172295 : /// function, and the AAResults object to populate. This should be used when
1085 : /// setting up a custom pass pipeline to inject a hook into the AA results.
1086 0 : ImmutablePass *createExternalAAWrapperPass(
1087 : std::function<void(Pass &, Function &, AAResults &)> Callback);
1088 0 :
1089 : /// A helper for the legacy pass manager to create a \c AAResults
1090 16 : /// object populated to the best of our ability for a particular function when
1091 : /// inside of a \c ModulePass or a \c CallGraphSCCPass.
1092 16 : ///
1093 : /// If a \c ModulePass or a \c CallGraphSCCPass calls \p
1094 30 : /// createLegacyPMAAResults, it also needs to call \p addUsedAAAnalyses in \p
1095 : /// getAnalysisUsage.
1096 30 : AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR);
1097 1877 :
1098 : /// A helper for the legacy pass manager to populate \p AU to add uses to make
1099 : /// sure the analyses required by \p createLegacyPMAAResults are available.
1100 : void getAAResultsAnalysisUsage(AnalysisUsage &AU);
1101 :
1102 : } // end namespace llvm
1103 :
1104 : #endif // LLVM_ANALYSIS_ALIASANALYSIS_H
|
