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