LCOV - code coverage report
Current view: top level - include/llvm/Analysis - MemoryLocation.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 15 20 75.0 %
Date: 2018-07-13 00:08:38 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13