contrib/llvm/lib/Analysis/MemoryLocation.cpp

   1 //===- MemoryLocation.cpp - Memory location descriptions -------------------==//
   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 #include "llvm/Analysis/MemoryLocation.h"
  11 #include "llvm/Analysis/TargetLibraryInfo.h"
  12 #include "llvm/IR/BasicBlock.h"
  13 #include "llvm/IR/DataLayout.h"
  14 #include "llvm/IR/Instructions.h"
  15 #include "llvm/IR/IntrinsicInst.h"
  16 #include "llvm/IR/LLVMContext.h"
  17 #include "llvm/IR/Module.h"
  18 #include "llvm/IR/Type.h"
  19 using namespace llvm;
  20
  21 void LocationSize::print(raw_ostream &OS) const {
  22   OS << "LocationSize::";
  23   if (*this == unknown())
  24     OS << "unknown";
  25   else if (*this == mapEmpty())
  26     OS << "mapEmpty";
  27   else if (*this == mapTombstone())
  28     OS << "mapTombstone";
  29   else if (isPrecise())
  30     OS << "precise(" << getValue() << ')';
  31   else
  32     OS << "upperBound(" << getValue() << ')';
  33 }
  34
  35 MemoryLocation MemoryLocation::get(const LoadInst *LI) {
  36   AAMDNodes AATags;
  37   LI->getAAMetadata(AATags);
  38   const auto &DL = LI->getModule()->getDataLayout();
  39
  40   return MemoryLocation(
  41       LI->getPointerOperand(),
  42       LocationSize::precise(DL.getTypeStoreSize(LI->getType())), AATags);
  43 }
  44
  45 MemoryLocation MemoryLocation::get(const StoreInst *SI) {
  46   AAMDNodes AATags;
  47   SI->getAAMetadata(AATags);
  48   const auto &DL = SI->getModule()->getDataLayout();
  49
  50   return MemoryLocation(SI->getPointerOperand(),
  51                         LocationSize::precise(DL.getTypeStoreSize(
  52                             SI->getValueOperand()->getType())),
  53                         AATags);
  54 }
  55
  56 MemoryLocation MemoryLocation::get(const VAArgInst *VI) {
  57   AAMDNodes AATags;
  58   VI->getAAMetadata(AATags);
  59
  60   return MemoryLocation(VI->getPointerOperand(), LocationSize::unknown(),
  61                         AATags);
  62 }
  63
  64 MemoryLocation MemoryLocation::get(const AtomicCmpXchgInst *CXI) {
  65   AAMDNodes AATags;
  66   CXI->getAAMetadata(AATags);
  67   const auto &DL = CXI->getModule()->getDataLayout();
  68
  69   return MemoryLocation(CXI->getPointerOperand(),
  70                         LocationSize::precise(DL.getTypeStoreSize(
  71                             CXI->getCompareOperand()->getType())),
  72                         AATags);
  73 }
  74
  75 MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) {
  76   AAMDNodes AATags;
  77   RMWI->getAAMetadata(AATags);
  78   const auto &DL = RMWI->getModule()->getDataLayout();
  79
  80   return MemoryLocation(RMWI->getPointerOperand(),
  81                         LocationSize::precise(DL.getTypeStoreSize(
  82                             RMWI->getValOperand()->getType())),
  83                         AATags);
  84 }
  85
  86 MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
  87   return getForSource(cast<AnyMemTransferInst>(MTI));
  88 }
  89
  90 MemoryLocation MemoryLocation::getForSource(const AtomicMemTransferInst *MTI) {
  91   return getForSource(cast<AnyMemTransferInst>(MTI));
  92 }
  93
  94 MemoryLocation MemoryLocation::getForSource(const AnyMemTransferInst *MTI) {
  95   auto Size = LocationSize::unknown();
  96   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
  97     Size = LocationSize::precise(C->getValue().getZExtValue());
  98
  99   // memcpy/memmove can have AA tags. For memcpy, they apply
 100   // to both the source and the destination.
 101   AAMDNodes AATags;
 102   MTI->getAAMetadata(AATags);
 103
 104   return MemoryLocation(MTI->getRawSource(), Size, AATags);
 105 }
 106
 107 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) {
 108   return getForDest(cast<AnyMemIntrinsic>(MI));
 109 }
 110
 111 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) {
 112   return getForDest(cast<AnyMemIntrinsic>(MI));
 113 }
 114
 115 MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) {
 116   auto Size = LocationSize::unknown();
 117   if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
 118     Size = LocationSize::precise(C->getValue().getZExtValue());
 119
 120   // memcpy/memmove can have AA tags. For memcpy, they apply
 121   // to both the source and the destination.
 122   AAMDNodes AATags;
 123   MI->getAAMetadata(AATags);
 124
 125   return MemoryLocation(MI->getRawDest(), Size, AATags);
 126 }
 127
 128 MemoryLocation MemoryLocation::getForArgument(const CallBase *Call,
 129                                               unsigned ArgIdx,
 130                                               const TargetLibraryInfo *TLI) {
 131   AAMDNodes AATags;
 132   Call->getAAMetadata(AATags);
 133   const Value *Arg = Call->getArgOperand(ArgIdx);
 134
 135   // We may be able to produce an exact size for known intrinsics.
 136   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call)) {
 137     const DataLayout &DL = II->getModule()->getDataLayout();
 138
 139     switch (II->getIntrinsicID()) {
 140     default:
 141       break;
 142     case Intrinsic::memset:
 143     case Intrinsic::memcpy:
 144     case Intrinsic::memmove:
 145       assert((ArgIdx == 0 || ArgIdx == 1) &&
 146              "Invalid argument index for memory intrinsic");
 147       if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
 148         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 149                               AATags);
 150       break;
 151
 152     case Intrinsic::lifetime_start:
 153     case Intrinsic::lifetime_end:
 154     case Intrinsic::invariant_start:
 155       assert(ArgIdx == 1 && "Invalid argument index");
 156       return MemoryLocation(
 157           Arg,
 158           LocationSize::precise(
 159               cast<ConstantInt>(II->getArgOperand(0))->getZExtValue()),
 160           AATags);
 161
 162     case Intrinsic::invariant_end:
 163       // The first argument to an invariant.end is a "descriptor" type (e.g. a
 164       // pointer to a empty struct) which is never actually dereferenced.
 165       if (ArgIdx == 0)
 166         return MemoryLocation(Arg, LocationSize::precise(0), AATags);
 167       assert(ArgIdx == 2 && "Invalid argument index");
 168       return MemoryLocation(
 169           Arg,
 170           LocationSize::precise(
 171               cast<ConstantInt>(II->getArgOperand(1))->getZExtValue()),
 172           AATags);
 173
 174     case Intrinsic::arm_neon_vld1:
 175       assert(ArgIdx == 0 && "Invalid argument index");
 176       // LLVM's vld1 and vst1 intrinsics currently only support a single
 177       // vector register.
 178       return MemoryLocation(
 179           Arg, LocationSize::precise(DL.getTypeStoreSize(II->getType())),
 180           AATags);
 181
 182     case Intrinsic::arm_neon_vst1:
 183       assert(ArgIdx == 0 && "Invalid argument index");
 184       return MemoryLocation(Arg,
 185                             LocationSize::precise(DL.getTypeStoreSize(
 186                                 II->getArgOperand(1)->getType())),
 187                             AATags);
 188     }
 189   }
 190
 191   // We can bound the aliasing properties of memset_pattern16 just as we can
 192   // for memcpy/memset.  This is particularly important because the
 193   // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
 194   // whenever possible.
 195   LibFunc F;
 196   if (TLI && Call->getCalledFunction() &&
 197       TLI->getLibFunc(*Call->getCalledFunction(), F) &&
 198       F == LibFunc_memset_pattern16 && TLI->has(F)) {
 199     assert((ArgIdx == 0 || ArgIdx == 1) &&
 200            "Invalid argument index for memset_pattern16");
 201     if (ArgIdx == 1)
 202       return MemoryLocation(Arg, LocationSize::precise(16), AATags);
 203     if (const ConstantInt *LenCI =
 204             dyn_cast<ConstantInt>(Call->getArgOperand(2)))
 205       return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 206                             AATags);
 207   }
 208   // FIXME: Handle memset_pattern4 and memset_pattern8 also.
 209
 210   return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(),
 211                         AATags);
 212 }