LLVM  8.0.0svn
AliasAnalysis.h
Go to the documentation of this file.
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"
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.
88  /// The two locations alias, but only due to a partial overlap.
90  /// The two locations precisely alias each other.
92 };
93 
94 /// << operator for AliasResult.
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.
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 
141  return (static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef)) ==
142  static_cast<int>(ModRefInfo::Must);
143 }
145  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustModRef);
146 }
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  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustMod);
153 }
154 LLVM_NODISCARD inline bool isRefSet(const ModRefInfo MRI) {
155  return static_cast<int>(MRI) & static_cast<int>(ModRefInfo::MustRef);
156 }
158  return !(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::NoModRef));
159 }
160 
162  return ModRefInfo(static_cast<int>(MRI) |
163  static_cast<int>(ModRefInfo::MustMod));
164 }
166  return ModRefInfo(static_cast<int>(MRI) |
167  static_cast<int>(ModRefInfo::MustRef));
168 }
170  return ModRefInfo(static_cast<int>(MRI) &
171  static_cast<int>(ModRefInfo::MustModRef));
172 }
174  return ModRefInfo(static_cast<int>(MRI) |
175  static_cast<int>(ModRefInfo::MustModRef));
176 }
178  return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Ref));
179 }
181  return ModRefInfo(static_cast<int>(MRI) & static_cast<int>(ModRefInfo::Mod));
182 }
184  return ModRefInfo(static_cast<int>(MRI) |
185  static_cast<int>(ModRefInfo::NoModRef));
186 }
188  const ModRefInfo MRI2) {
189  return ModRefInfo(static_cast<int>(MRI1) | static_cast<int>(MRI2));
190 }
192  const ModRefInfo MRI2) {
193  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.
202  /// Base case is no access to memory.
204  /// Access to memory via argument pointers.
206  /// Memory that is inaccessible via LLVM IR.
208  /// Access to any memory.
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.
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.
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.
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.
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.
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.
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.
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.
274 
275  /// This indicates that the function could not be classified into one of the
276  /// behaviors above.
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.
287  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  AAResults(const TargetLibraryInfo &TLI) : TLI(TLI) {}
296  ~AAResults();
297 
298  /// Register a specific AA result.
299  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  AAs.emplace_back(new Model<AAResultT>(AAResult, *this));
304  }
305 
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  /// where we must invalidate the results aggregation if any of our component
310  /// analyses become invalid.
311  void addAADependencyID(AnalysisKey *ID) { AADeps.push_back(ID); }
312 
313  /// Handle invalidation events in the new pass manager.
314  ///
315  /// The aggregation is invalidated if any of the underlying analyses is
316  /// invalidated.
317  bool invalidate(Function &F, const PreservedAnalyses &PA,
319 
320  //===--------------------------------------------------------------------===//
321  /// \name Alias Queries
322  /// @{
323 
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  /// alias analysis implementations.
328  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB);
329 
330  /// A convenience wrapper around the primary \c alias interface.
331  AliasResult alias(const Value *V1, LocationSize V1Size, const Value *V2,
332  LocationSize V2Size) {
333  return alias(MemoryLocation(V1, V1Size), MemoryLocation(V2, V2Size));
334  }
335 
336  /// A convenience wrapper around the primary \c alias interface.
337  AliasResult alias(const Value *V1, const Value *V2) {
338  return alias(V1, LocationSize::unknown(), V2, LocationSize::unknown());
339  }
340 
341  /// A trivial helper function to check to see if the specified pointers are
342  /// no-alias.
343  bool isNoAlias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
344  return alias(LocA, LocB) == NoAlias;
345  }
346 
347  /// 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  }
352 
353  /// A convenience wrapper around the \c isNoAlias helper interface.
354  bool isNoAlias(const Value *V1, const Value *V2) {
355  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  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  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  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.
409  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.
437  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).
456  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).
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).
469  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).
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.
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.
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).
496  return !(MRB & FMRL_Anywhere &
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.
506  LocationSize Size) {
507  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.
513  return getModRefInfo(ImmutableCallSite(C), Loc);
514  }
515 
516  /// getModRefInfo (for calls) - A convenience wrapper.
518  LocationSize Size) {
519  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.
525  return getModRefInfo(ImmutableCallSite(I), Loc);
526  }
527 
528  /// getModRefInfo (for invokes) - A convenience wrapper.
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 
538  /// getModRefInfo (for loads) - A convenience wrapper.
540  LocationSize Size) {
541  return getModRefInfo(L, MemoryLocation(P, Size));
542  }
543 
544  /// 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.
550  LocationSize Size) {
551  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.
560  LocationSize Size) {
561  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.
571  unsigned Size) {
572  return getModRefInfo(CX, MemoryLocation(P, Size));
573  }
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.
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.
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.
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.
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.
626  const Optional<MemoryLocation> &OptLoc) {
627  if (OptLoc == None) {
628  if (auto CS = ImmutableCallSite(I)) {
629  return createModRefInfo(getModRefBehavior(CS));
630  }
631  }
632 
633  const MemoryLocation &Loc = OptLoc.getValueOr(MemoryLocation());
634 
635  switch (I->getOpcode()) {
636  case Instruction::VAArg: return getModRefInfo((const VAArgInst*)I, Loc);
637  case Instruction::Load: return getModRefInfo((const LoadInst*)I, Loc);
638  case Instruction::Store: return getModRefInfo((const StoreInst*)I, Loc);
639  case Instruction::Fence: return getModRefInfo((const FenceInst*)I, Loc);
640  case Instruction::AtomicCmpXchg:
641  return getModRefInfo((const AtomicCmpXchgInst*)I, Loc);
642  case Instruction::AtomicRMW:
643  return getModRefInfo((const AtomicRMWInst*)I, Loc);
644  case Instruction::Call: return getModRefInfo((const CallInst*)I, Loc);
645  case Instruction::Invoke: return getModRefInfo((const InvokeInst*)I,Loc);
646  case Instruction::CatchPad:
647  return getModRefInfo((const CatchPadInst *)I, Loc);
648  case Instruction::CatchRet:
649  return getModRefInfo((const CatchReturnInst *)I, Loc);
650  default:
651  return ModRefInfo::NoModRef;
652  }
653  }
654 
655  /// A convenience wrapper for constructing the memory location.
657  LocationSize Size) {
658  return getModRefInfo(I, MemoryLocation(P, Size));
659  }
660 
661  /// 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  /// instruction ordering queries inside the BasicBlock containing \p I.
674  /// Early exits in callCapturesBefore may lead to ModRefInfo::Must not being
675  /// set.
676  ModRefInfo callCapturesBefore(const Instruction *I,
677  const MemoryLocation &MemLoc, DominatorTree *DT,
678  OrderedBasicBlock *OBB = nullptr);
679 
680  /// A convenience wrapper to synthesize a memory location.
683  OrderedBasicBlock *OBB = nullptr) {
684  return callCapturesBefore(I, MemoryLocation(P, Size), DT, OBB);
685  }
686 
687  /// @}
688  //===--------------------------------------------------------------------===//
689  /// \name Higher level methods for querying mod/ref information.
690  /// @{
691 
692  /// Check if it is possible for execution of the specified basic block to
693  /// modify the location Loc.
694  bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc);
695 
696  /// A convenience wrapper synthesizing a memory location.
697  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.
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.
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.
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  /// 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  explicit Model(AAResultT &Result, AAResults &AAR) : Result(Result) {
813  Result.setAAResults(&AAR);
814  }
815  ~Model() override = default;
816 
817  void setAAResults(AAResults *NewAAR) override { Result.setAAResults(NewAAR); }
818 
819  AliasResult alias(const MemoryLocation &LocA,
820  const MemoryLocation &LocB) override {
821  return Result.alias(LocA, LocB);
822  }
823 
824  bool pointsToConstantMemory(const MemoryLocation &Loc,
825  bool OrLocal) override {
826  return Result.pointsToConstantMemory(Loc, OrLocal);
827  }
828 
829  ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx) override {
830  return Result.getArgModRefInfo(CS, ArgIdx);
831  }
832 
833  FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS) override {
834  return Result.getModRefBehavior(CS);
835  }
836 
837  FunctionModRefBehavior getModRefBehavior(const Function *F) override {
838  return Result.getModRefBehavior(F);
839  }
840 
841  ModRefInfo getModRefInfo(ImmutableCallSite CS,
842  const MemoryLocation &Loc) override {
843  return Result.getModRefInfo(CS, Loc);
844  }
845 
846  ModRefInfo getModRefInfo(ImmutableCallSite CS1,
847  ImmutableCallSite CS2) override {
848  return Result.getModRefInfo(CS1, CS2);
849  }
850 };
851 
852 /// A CRTP-driven "mixin" base class to help implement the function alias
853 /// analysis results concept.
854 ///
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 /// implement the remaining portions of the interface in terms of simpler forms
858 /// of the interface where possible, and otherwise provide conservatively
859 /// correct fallback implementations.
860 ///
861 /// 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 /// use virtual anywhere, the CRTP base class does static dispatch to the
864 /// derived type passed into it.
865 template <typename DerivedT> class AAResultBase {
866  // Expose some parts of the interface only to the AAResults::Model
867  // for wrapping. Specifically, this allows the model to call our
868  // setAAResults method without exposing it as a fully public API.
869  friend class AAResults::Model<DerivedT>;
870 
871  /// A pointer to the AAResults object that this AAResult is
872  /// aggregated within. May be null if not aggregated.
873  AAResults *AAR;
874 
875  /// Helper to dispatch calls back through the derived type.
876  DerivedT &derived() { return static_cast<DerivedT &>(*this); }
877 
878  /// A setter for the AAResults pointer, which is used to satisfy the
879  /// AAResults::Model contract.
880  void setAAResults(AAResults *NewAAR) { AAR = NewAAR; }
881 
882 protected:
883  /// This proxy class models a common pattern where we delegate to either the
884  /// top-level \c AAResults aggregation if one is registered, or to the
885  /// current result if none are registered.
887  AAResults *AAR;
888  DerivedT &CurrentResult;
889 
890  public:
891  AAResultsProxy(AAResults *AAR, DerivedT &CurrentResult)
892  : AAR(AAR), CurrentResult(CurrentResult) {}
893 
894  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
895  return AAR ? AAR->alias(LocA, LocB) : CurrentResult.alias(LocA, LocB);
896  }
897 
898  bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
899  return AAR ? AAR->pointsToConstantMemory(Loc, OrLocal)
900  : CurrentResult.pointsToConstantMemory(Loc, OrLocal);
901  }
902 
904  return AAR ? AAR->getArgModRefInfo(CS, ArgIdx) : CurrentResult.getArgModRefInfo(CS, ArgIdx);
905  }
906 
908  return AAR ? AAR->getModRefBehavior(CS) : CurrentResult.getModRefBehavior(CS);
909  }
910 
912  return AAR ? AAR->getModRefBehavior(F) : CurrentResult.getModRefBehavior(F);
913  }
914 
916  return AAR ? AAR->getModRefInfo(CS, Loc)
917  : CurrentResult.getModRefInfo(CS, Loc);
918  }
919 
921  return AAR ? AAR->getModRefInfo(CS1, CS2) : CurrentResult.getModRefInfo(CS1, CS2);
922  }
923  };
924 
925  explicit AAResultBase() = default;
926 
927  // Provide all the copy and move constructors so that derived types aren't
928  // constrained.
931 
932  /// Get a proxy for the best AA result set to query at this time.
933  ///
934  /// 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  /// back to the derived class's implementation.
937  ///
938  /// Note that callers of this need to take considerable care to not cause
939  /// performance problems when they use this routine, in the case of a large
940  /// number of alias analyses being aggregated, it can be expensive to walk
941  /// back across the chain.
942  AAResultsProxy getBestAAResults() { return AAResultsProxy(AAR, derived()); }
943 
944 public:
945  AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
946  return MayAlias;
947  }
948 
949  bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal) {
950  return false;
951  }
952 
954  return ModRefInfo::ModRef;
955  }
956 
959  }
960 
963  }
964 
966  return ModRefInfo::ModRef;
967  }
968 
970  return ModRefInfo::ModRef;
971  }
972 };
973 
974 /// Return true if this pointer is returned by a noalias function.
975 bool isNoAliasCall(const Value *V);
976 
977 /// Return true if this is an argument with the noalias attribute.
978 bool isNoAliasArgument(const Value *V);
979 
980 /// Return true if this pointer refers to a distinct and identifiable object.
981 /// This returns true for:
982 /// Global Variables and Functions (but not Global Aliases)
983 /// Allocas
984 /// ByVal and NoAlias Arguments
985 /// NoAlias returns (e.g. calls to malloc)
986 ///
987 bool isIdentifiedObject(const Value *V);
988 
989 /// Return true if V is umabigously identified at the function-level.
990 /// Different IdentifiedFunctionLocals can't alias.
991 /// Further, an IdentifiedFunctionLocal can not alias with any function
992 /// arguments other than itself, which is not necessarily true for
993 /// IdentifiedObjects.
994 bool isIdentifiedFunctionLocal(const Value *V);
995 
996 /// A manager for alias analyses.
997 ///
998 /// This class can have analyses registered with it and when run, it will run
999 /// all of them and aggregate their results into single AA results interface
1000 /// that dispatches across all of the alias analysis results available.
1001 ///
1002 /// Note that the order in which analyses are registered is very significant.
1003 /// That is the order in which the results will be aggregated and queried.
1004 ///
1005 /// This manager effectively wraps the AnalysisManager for registering alias
1006 /// analyses. When you register your alias analysis with this manager, it will
1007 /// ensure the analysis itself is registered with its AnalysisManager.
1008 class AAManager : public AnalysisInfoMixin<AAManager> {
1009 public:
1011 
1012  /// Register a specific AA result.
1013  template <typename AnalysisT> void registerFunctionAnalysis() {
1014  ResultGetters.push_back(&getFunctionAAResultImpl<AnalysisT>);
1015  }
1016 
1017  /// Register a specific AA result.
1018  template <typename AnalysisT> void registerModuleAnalysis() {
1019  ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>);
1020  }
1021 
1024  for (auto &Getter : ResultGetters)
1025  (*Getter)(F, AM, R);
1026  return R;
1027  }
1028 
1029 private:
1031 
1032  static AnalysisKey Key;
1033 
1035  AAResults &AAResults),
1036  4> ResultGetters;
1037 
1038  template <typename AnalysisT>
1039  static void getFunctionAAResultImpl(Function &F,
1041  AAResults &AAResults) {
1042  AAResults.addAAResult(AM.template getResult<AnalysisT>(F));
1043  AAResults.addAADependencyID(AnalysisT::ID());
1044  }
1045 
1046  template <typename AnalysisT>
1047  static void getModuleAAResultImpl(Function &F, FunctionAnalysisManager &AM,
1048  AAResults &AAResults) {
1049  auto &MAMProxy = AM.getResult<ModuleAnalysisManagerFunctionProxy>(F);
1050  auto &MAM = MAMProxy.getManager();
1051  if (auto *R = MAM.template getCachedResult<AnalysisT>(*F.getParent())) {
1052  AAResults.addAAResult(*R);
1053  MAMProxy
1054  .template registerOuterAnalysisInvalidation<AnalysisT, AAManager>();
1055  }
1056  }
1057 };
1058 
1059 /// A wrapper pass to provide the legacy pass manager access to a suitably
1060 /// prepared AAResults object.
1062  std::unique_ptr<AAResults> AAR;
1063 
1064 public:
1065  static char ID;
1066 
1068 
1069  AAResults &getAAResults() { return *AAR; }
1070  const AAResults &getAAResults() const { return *AAR; }
1071 
1072  bool runOnFunction(Function &F) override;
1073 
1074  void getAnalysisUsage(AnalysisUsage &AU) const override;
1075 };
1076 
1077 /// A wrapper pass for external alias analyses. This just squirrels away the
1078 /// callback used to run any analyses and register their results.
1080  using CallbackT = std::function<void(Pass &, Function &, AAResults &)>;
1081 
1083 
1084  static char ID;
1085 
1088  }
1089 
1091  : ImmutablePass(ID), CB(std::move(CB)) {
1093  }
1094 
1095  void getAnalysisUsage(AnalysisUsage &AU) const override {
1096  AU.setPreservesAll();
1097  }
1098 };
1099 
1101 
1102 /// A wrapper pass around a callback which can be used to populate the
1103 /// AAResults in the AAResultsWrapperPass from an external AA.
1104 ///
1105 /// The callback provided here will be used each time we prepare an AAResults
1106 /// object, and will receive a reference to the function wrapper pass, the
1107 /// function, and the AAResults object to populate. This should be used when
1108 /// setting up a custom pass pipeline to inject a hook into the AA results.
1110  std::function<void(Pass &, Function &, AAResults &)> Callback);
1111 
1112 /// A helper for the legacy pass manager to create a \c AAResults
1113 /// object populated to the best of our ability for a particular function when
1114 /// inside of a \c ModulePass or a \c CallGraphSCCPass.
1115 ///
1116 /// If a \c ModulePass or a \c CallGraphSCCPass calls \p
1117 /// createLegacyPMAAResults, it also needs to call \p addUsedAAAnalyses in \p
1118 /// getAnalysisUsage.
1120 
1121 /// A helper for the legacy pass manager to populate \p AU to add uses to make
1122 /// sure the analyses required by \p createLegacyPMAAResults are available.
1124 
1125 } // end namespace llvm
1126 
1127 #endif // LLVM_ANALYSIS_ALIASANALYSIS_H
The access may reference and may modify the value stored in memory.
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:81
LLVM_NODISCARD ModRefInfo unionModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
ModRefInfo getModRefInfo(const CatchReturnInst *I, const Value *P, LocationSize Size)
getModRefInfo (for catchrets) - A convenience wrapper.
uint64_t CallInst * C
static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from memory that ...
void addAAResult(AAResultT &AAResult)
Register a specific AA result.
The access neither references nor modifies the value stored in memory.
LLVM_NODISCARD ModRefInfo clearMust(const ModRefInfo MRI)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
SI Whole Quad Mode
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:770
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
ModRefInfo getModRefInfo(const AtomicRMWInst *RMW, const Value *P, unsigned Size)
getModRefInfo (for atomicrmws) - A convenience wrapper.
ModRefInfo getModRefInfo(const CatchPadInst *I, const Value *P, LocationSize Size)
getModRefInfo (for catchpads) - A convenience wrapper.
Various leaf nodes.
Definition: ISDOpcodes.h:60
AAResultsProxy(AAResults *AAR, DerivedT &CurrentResult)
An instruction for ordering other memory operations.
Definition: Instructions.h:444
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal)
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:518
ModRefInfo callCapturesBefore(const Instruction *I, const Value *P, LocationSize Size, DominatorTree *DT, OrderedBasicBlock *OBB=nullptr)
A convenience wrapper to synthesize a memory location.
ModRefInfo getModRefInfo(const FenceInst *S, const Value *P, LocationSize Size)
getModRefInfo (for fences) - A convenience wrapper.
static constexpr LocationSize unknown()
ModRefInfo getModRefInfo(const StoreInst *S, const Value *P, LocationSize Size)
getModRefInfo (for stores) - A convenience wrapper.
bool isNoAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
A trivial helper function to check to see if the specified pointers are no-alias. ...
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
std::function< void(Pass &, Function &, AAResults &)> CallbackT
bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2, const Value *Ptr, LocationSize Size, const ModRefInfo Mode)
A convenience wrapper synthesizing a memory location.
constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION
Definition: Optional.h:190
This class represents a function call, abstracting a target machine&#39;s calling convention.
The two locations do not alias at all.
Definition: AliasAnalysis.h:85
bool doesNotAccessMemory(const Function *F)
Checks if the specified function is known to never read or write memory.
void registerModuleAnalysis()
Register a specific AA result.
const AAResults & getAAResults() const
This is the AA result object for the basic, local, and stateless alias analysis.
bool onlyReadsMemory(ImmutableCallSite CS)
Checks if the specified call is known to only read from non-volatile memory (or not access memory at ...
static bool onlyAccessesInaccessibleOrArgMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from memory that ...
bool pointsToConstantMemory(const Value *P, bool OrLocal=false)
A convenience wrapper around the primary pointsToConstantMemory interface.
F(f)
bool isNoAliasCall(const Value *V)
Return true if this pointer is returned by a noalias function.
An instruction for reading from memory.
Definition: Instructions.h:168
bool canBasicBlockModify(const BasicBlock &BB, const Value *P, LocationSize Size)
A convenience wrapper synthesizing a memory location.
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:681
void initializeExternalAAWrapperPassPass(PassRegistry &)
ModRefInfo getModRefInfo(const AtomicCmpXchgInst *CX, const Value *P, unsigned Size)
getModRefInfo (for cmpxchges) - A convenience wrapper.
LLVM_NODISCARD bool isModAndRefSet(const ModRefInfo MRI)
Access to any memory.
ModRefInfo getModRefInfo(const Instruction *I, const Optional< MemoryLocation > &OptLoc)
Check whether or not an instruction may read or write the optionally specified memory location...
This indicates that the function could not be classified into one of the behaviors above...
LLVM_NODISCARD ModRefInfo clearMod(const ModRefInfo MRI)
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
The main low level interface to the alias analysis implementation.
#define LLVM_NODISCARD
LLVM_NODISCARD - Warn if a type or return value is discarded.
Definition: Compiler.h:129
The only memory references in this function (if it has any) are references of memory that is otherwis...
Definition: BitVector.h:938
FunctionPass * createAAResultsWrapperPass()
static bool doesNotReadMemory(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to only write memory (or not access memory ...
bool isNoAlias(const Value *V1, const Value *V2)
A convenience wrapper around the isNoAlias helper interface.
LLVM_NODISCARD ModRefInfo clearRef(const ModRefInfo MRI)
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Must is provided for completeness, but no routines will return only Must today.
The access may reference the value stored in memory, a mustAlias relation was found, and no mayAlias or partialAlias found.
The access may reference the value stored in memory.
The only memory references in this function (if it has any) are non-volatile loads from objects point...
AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR)
A helper for the legacy pass manager to create a AAResults object populated to the best of our abilit...
The function may perform non-volatile loads and stores of objects pointed to by its pointer-typed arg...
bool isIdentifiedObject(const Value *V)
Return true if this pointer refers to a distinct and identifiable object.
A CRTP-driven "mixin" base class to help implement the function alias analysis results concept...
AliasResult alias(const Value *V1, const Value *V2)
A convenience wrapper around the primary alias interface.
LLVM_NODISCARD ModRefInfo setRef(const ModRefInfo MRI)
Key
PAL metadata keys.
LLVM_NODISCARD bool isMustSet(const ModRefInfo MRI)
ModRefInfo getModRefInfo(const LoadInst *L, const Value *P, LocationSize Size)
getModRefInfo (for loads) - A convenience wrapper.
Access to memory via argument pointers.
The access may reference, modify or both the value stored in memory, a mustAlias relation was found...
FunctionModRefBehavior
Summary of how a function affects memory in the program.
The access may modify the value stored in memory, a mustAlias relation was found, and no mayAlias or ...
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:126
AAResultBase(AAResultBase &&Arg)
An instruction for storing to memory.
Definition: Instructions.h:310
void registerFunctionAnalysis()
Register a specific AA result.
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:145
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal)
A private abstract base class describing the concept of an individual alias analysis implementation...
static bool onlyReadsMemory(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to only read from non-volatile memory (or n...
AliasResult
The possible results of an alias query.
Definition: AliasAnalysis.h:79
FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS)
bool pointsToConstantMemory(const MemoryLocation &Loc, bool OrLocal=false)
Checks whether the given location points to constant memory, or if OrLocal is true whether it points ...
ImmutablePass * createExternalAAWrapperPass(std::function< void(Pass &, Function &, AAResults &)> Callback)
A wrapper pass around a callback which can be used to populate the AAResults in the AAResultsWrapperP...
static bool runOnFunction(Function &F, bool PostInlining)
#define P(N)
bool onlyReadsMemory(const Function *F)
Checks if the specified function is known to only read from non-volatile memory (or not access memory...
AAResultBase(const AAResultBase &Arg)
LLVM_NODISCARD ModRefInfo setMust(const ModRefInfo MRI)
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:154
unsigned const MachineRegisterInfo * MRI
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
AliasResult alias(const Value *V1, LocationSize V1Size, const Value *V2, LocationSize V2Size)
A convenience wrapper around the primary alias interface.
A manager for alias analyses.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:383
ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx)
ModRefInfo getModRefInfo(const VAArgInst *I, const Value *P, LocationSize Size)
getModRefInfo (for va_args) - A convenience wrapper.
Result run(Function &F, FunctionAnalysisManager &AM)
FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS)
Return the behavior of the given call site.
Represent the analysis usage information of a pass.
void addAADependencyID(AnalysisKey *ID)
Register a function analysis ID that the results aggregation depends on.
static bool doesAccessArgPointees(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to potentially read or write from objects p...
The only memory references in this function (if it has any) are non-volatile loads and stores from ob...
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
ModRefInfo getModRefInfo(const InvokeInst *I, const Value *P, LocationSize Size)
getModRefInfo (for invokes) - A convenience wrapper.
ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2)
ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx)
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
void getAAResultsAnalysisUsage(AnalysisUsage &AU)
A helper for the legacy pass manager to populate AU to add uses to make sure the analyses required by...
This function does not perform any non-local loads or stores to memory.
bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
The two locations may or may not alias. This is the least precise result.
Definition: AliasAnalysis.h:87
FunctionModRefLocation
The locations at which a function might access memory.
Representation for a specific memory location.
The two locations precisely alias each other.
Definition: AliasAnalysis.h:91
bool doesNotAccessMemory(ImmutableCallSite CS)
Checks if the specified call is known to never read or write memory.
ImmutablePass class - This class is used to provide information that does not need to be run...
Definition: Pass.h:256
Memory that is inaccessible via LLVM IR.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Definition: PassManager.h:1154
LLVM_NODISCARD ModRefInfo setMod(const ModRefInfo MRI)
ModRefInfo getModRefInfo(const InvokeInst *I, const MemoryLocation &Loc)
getModRefInfo (for invokes) - Return information about whether a particular invoke modifies or reads ...
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
Provides information about what library functions are available for the current target.
This function does not perform any non-local stores or volatile loads, but may read from any memory l...
ModRefInfo getModRefInfo(const CallInst *C, const Value *P, LocationSize Size)
getModRefInfo (for calls) - A convenience wrapper.
The access may modify the value stored in memory.
bool isMustAlias(const Value *V1, const Value *V2)
A convenience wrapper around the isMustAlias helper interface.
This proxy class models a common pattern where we delegate to either the top-level AAResults aggregat...
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
getModRefInfo (for call sites) - Return information about whether a particular call site modifies or ...
void setPreservesAll()
Set by analyses that do not transform their input at all.
LLVM_NODISCARD bool isNoModRef(const ModRefInfo MRI)
bool isMustAlias(const MemoryLocation &LocA, const MemoryLocation &LocB)
A trivial helper function to check to see if the specified pointers are must-alias.
amdgpu Simplify well known AMD library false Value Value * Arg
AAResults(const TargetLibraryInfo &TLI)
LLVM_NODISCARD bool isModSet(const ModRefInfo MRI)
static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from objects poin...
ModRefInfo getModRefInfo(const CallInst *C, const MemoryLocation &Loc)
getModRefInfo (for calls) - Return information about whether a particular call modifies or reads the ...
Base case is no access to memory.
This file provides utility analysis objects describing memory locations.
static bool doesAccessInaccessibleMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to potentially read or write from memory th...
Establish a view to a call site for examination.
Definition: CallSite.h:714
ModRefInfo getModRefInfo(ImmutableCallSite CS, const Value *P, LocationSize Size)
getModRefInfo (for call sites) - A convenience wrapper.
LLVM_NODISCARD ModRefInfo intersectModRef(const ModRefInfo MRI1, const ModRefInfo MRI2)
#define I(x, y, z)
Definition: MD5.cpp:58
AAResultsProxy getBestAAResults()
Get a proxy for the best AA result set to query at this time.
uint32_t Size
Definition: Profile.cpp:47
raw_ostream & operator<<(raw_ostream &OS, const APInt &I)
Definition: APInt.h:2033
FunctionModRefBehavior getModRefBehavior(ImmutableCallSite CS)
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:642
Analysis pass providing the TargetLibraryInfo.
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:566
LLVM Value Representation.
Definition: Value.h:73
ModRefInfo getModRefInfo(ImmutableCallSite CS, const MemoryLocation &Loc)
LLVM_NODISCARD ModRefInfo createModRefInfo(const FunctionModRefBehavior FMRB)
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Invoke instruction.
A wrapper pass for external alias analyses.
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
LLVM_NODISCARD ModRefInfo setModAndRef(const ModRefInfo MRI)
print Print MemDeps of function
FunctionModRefBehavior getModRefBehavior(const Function *F)
bool isNoAlias(const Value *V1, LocationSize V1Size, const Value *V2, LocationSize V2Size)
A convenience wrapper around the isNoAlias helper interface.
A container for analyses that lazily runs them and caches their results.
bool isNoAliasArgument(const Value *V)
Return true if this is an argument with the noalias attribute.
LLVM_NODISCARD bool isModOrRefSet(const ModRefInfo MRI)
A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object...
This header defines various interfaces for pass management in LLVM.
The two locations alias, but only due to a partial overlap.
Definition: AliasAnalysis.h:89
ExternalAAWrapperPass(CallbackT CB)
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:71
ModRefInfo getArgModRefInfo(ImmutableCallSite CS, unsigned ArgIdx)
Get the ModRef info associated with a pointer argument of a callsite.
ModRefInfo getModRefInfo(ImmutableCallSite CS1, ImmutableCallSite CS2)
FunctionModRefBehavior getModRefBehavior(const Function *F)
ModRefInfo getModRefInfo(const Instruction *I, const Value *P, LocationSize Size)
A convenience wrapper for constructing the memory location.
LLVM_NODISCARD bool isRefSet(const ModRefInfo MRI)