include/llvm/Analysis/MemoryLocation.h

   1 //===- MemoryLocation.h - Memory location descriptions ----------*- 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 /// \file
  10 /// This file provides utility analysis objects describing memory locations.
  11 /// These are used both by the Alias Analysis infrastructure and more
  12 /// specialized memory analysis layers.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_ANALYSIS_MEMORYLOCATION_H
  17 #define LLVM_ANALYSIS_MEMORYLOCATION_H
  18
  19 #include "llvm/ADT/DenseMap.h"
  20 #include "llvm/IR/CallSite.h"
  21 #include "llvm/IR/Metadata.h"
  22
  23 namespace llvm {
  24
  25 class LoadInst;
  26 class StoreInst;
  27 class MemTransferInst;
  28 class MemIntrinsic;
  29 class TargetLibraryInfo;
  30
  31 /// Representation for a specific memory location.
  32 ///
  33 /// This abstraction can be used to represent a specific location in memory.
  34 /// The goal of the location is to represent enough information to describe
  35 /// abstract aliasing, modification, and reference behaviors of whatever
  36 /// value(s) are stored in memory at the particular location.
  37 ///
  38 /// The primary user of this interface is LLVM's Alias Analysis, but other
  39 /// memory analyses such as MemoryDependence can use it as well.
  40 class MemoryLocation {
  41 public:
  42   /// UnknownSize - This is a special value which can be used with the
  43   /// size arguments in alias queries to indicate that the caller does not
  44   /// know the sizes of the potential memory references.
  45   enum : uint64_t { UnknownSize = ~UINT64_C(0) };
  46
  47   /// The address of the start of the location.
  48   const Value *Ptr;
  49
  50   /// The maximum size of the location, in address-units, or
  51   /// UnknownSize if the size is not known.
  52   ///
  53   /// Note that an unknown size does not mean the pointer aliases the entire
  54   /// virtual address space, because there are restrictions on stepping out of
  55   /// one object and into another. See
  56   /// http://llvm.org/docs/LangRef.html#pointeraliasing
  57   uint64_t Size;
  58
  59   /// The metadata nodes which describes the aliasing of the location (each
  60   /// member is null if that kind of information is unavailable).
  61   AAMDNodes AATags;
  62
  63   /// Return a location with information about the memory reference by the given
  64   /// instruction.
  65   static MemoryLocation get(const LoadInst *LI);
  66   static MemoryLocation get(const StoreInst *SI);
  67   static MemoryLocation get(const VAArgInst *VI);
  68   static MemoryLocation get(const AtomicCmpXchgInst *CXI);
  69   static MemoryLocation get(const AtomicRMWInst *RMWI);
  70   static MemoryLocation get(const Instruction *Inst) {
  71     if (auto *I = dyn_cast<LoadInst>(Inst))
  72       return get(I);
  73     else if (auto *I = dyn_cast<StoreInst>(Inst))
  74       return get(I);
  75     else if (auto *I = dyn_cast<VAArgInst>(Inst))
  76       return get(I);
  77     else if (auto *I = dyn_cast<AtomicCmpXchgInst>(Inst))
  78       return get(I);
  79     else if (auto *I = dyn_cast<AtomicRMWInst>(Inst))
  80       return get(I);
  81     llvm_unreachable("unsupported memory instruction");
  82   }
  83
  84   /// Return a location representing the source of a memory transfer.
  85   static MemoryLocation getForSource(const MemTransferInst *MTI);
  86
  87   /// Return a location representing the destination of a memory set or
  88   /// transfer.
  89   static MemoryLocation getForDest(const MemIntrinsic *MI);
  90
  91   /// Return a location representing a particular argument of a call.
  92   static MemoryLocation getForArgument(ImmutableCallSite CS, unsigned ArgIdx,
  93                                        const TargetLibraryInfo &TLI);
  94
  95   explicit MemoryLocation(const Value *Ptr = nullptr,
  96                           uint64_t Size = UnknownSize,
  97                           const AAMDNodes &AATags = AAMDNodes())
  98       : Ptr(Ptr), Size(Size), AATags(AATags) {}
  99
 100   MemoryLocation getWithNewPtr(const Value *NewPtr) const {
 101     MemoryLocation Copy(*this);
 102     Copy.Ptr = NewPtr;
 103     return Copy;
 104   }
 105
 106   MemoryLocation getWithNewSize(uint64_t NewSize) const {
 107     MemoryLocation Copy(*this);
 108     Copy.Size = NewSize;
 109     return Copy;
 110   }
 111
 112   MemoryLocation getWithoutAATags() const {
 113     MemoryLocation Copy(*this);
 114     Copy.AATags = AAMDNodes();
 115     return Copy;
 116   }
 117
 118   bool operator==(const MemoryLocation &Other) const {
 119     return Ptr == Other.Ptr && Size == Other.Size && AATags == Other.AATags;
 120   }
 121 };
 122
 123 // Specialize DenseMapInfo for MemoryLocation.
 124 template <> struct DenseMapInfo<MemoryLocation> {
 125   static inline MemoryLocation getEmptyKey() {
 126     return MemoryLocation(DenseMapInfo<const Value *>::getEmptyKey(), 0);
 127   }
 128   static inline MemoryLocation getTombstoneKey() {
 129     return MemoryLocation(DenseMapInfo<const Value *>::getTombstoneKey(), 0);
 130   }
 131   static unsigned getHashValue(const MemoryLocation &Val) {
 132     return DenseMapInfo<const Value *>::getHashValue(Val.Ptr) ^
 133            DenseMapInfo<uint64_t>::getHashValue(Val.Size) ^
 134            DenseMapInfo<AAMDNodes>::getHashValue(Val.AATags);
 135   }
 136   static bool isEqual(const MemoryLocation &LHS, const MemoryLocation &RHS) {
 137     return LHS == RHS;
 138   }
 139 };
 140 }
 141
 142 #endif