llvm/lib/Analysis/MemoryLocation.cpp

   1 //===- MemoryLocation.cpp - Memory location descriptions -------------------==//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Analysis/MemoryLocation.h"
  10 #include "llvm/Analysis/TargetLibraryInfo.h"
  11 #include "llvm/IR/BasicBlock.h"
  12 #include "llvm/IR/DataLayout.h"
  13 #include "llvm/IR/Instructions.h"
  14 #include "llvm/IR/IntrinsicInst.h"
  15 #include "llvm/IR/IntrinsicsARM.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 == beforeOrAfterPointer())
  24     OS << "beforeOrAfterPointer";
  25   else if (*this == afterPointer())
  26     OS << "afterPointer";
  27   else if (*this == mapEmpty())
  28     OS << "mapEmpty";
  29   else if (*this == mapTombstone())
  30     OS << "mapTombstone";
  31   else if (isPrecise())
  32     OS << "precise(" << getValue() << ')';
  33   else
  34     OS << "upperBound(" << getValue() << ')';
  35 }
  36
  37 MemoryLocation MemoryLocation::get(const LoadInst *LI) {
  38   AAMDNodes AATags;
  39   LI->getAAMetadata(AATags);
  40   const auto &DL = LI->getModule()->getDataLayout();
  41
  42   return MemoryLocation(
  43       LI->getPointerOperand(),
  44       LocationSize::precise(DL.getTypeStoreSize(LI->getType())), AATags);
  45 }
  46
  47 MemoryLocation MemoryLocation::get(const StoreInst *SI) {
  48   AAMDNodes AATags;
  49   SI->getAAMetadata(AATags);
  50   const auto &DL = SI->getModule()->getDataLayout();
  51
  52   return MemoryLocation(SI->getPointerOperand(),
  53                         LocationSize::precise(DL.getTypeStoreSize(
  54                             SI->getValueOperand()->getType())),
  55                         AATags);
  56 }
  57
  58 MemoryLocation MemoryLocation::get(const VAArgInst *VI) {
  59   AAMDNodes AATags;
  60   VI->getAAMetadata(AATags);
  61
  62   return MemoryLocation(VI->getPointerOperand(),
  63                         LocationSize::afterPointer(), AATags);
  64 }
  65
  66 MemoryLocation MemoryLocation::get(const AtomicCmpXchgInst *CXI) {
  67   AAMDNodes AATags;
  68   CXI->getAAMetadata(AATags);
  69   const auto &DL = CXI->getModule()->getDataLayout();
  70
  71   return MemoryLocation(CXI->getPointerOperand(),
  72                         LocationSize::precise(DL.getTypeStoreSize(
  73                             CXI->getCompareOperand()->getType())),
  74                         AATags);
  75 }
  76
  77 MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) {
  78   AAMDNodes AATags;
  79   RMWI->getAAMetadata(AATags);
  80   const auto &DL = RMWI->getModule()->getDataLayout();
  81
  82   return MemoryLocation(RMWI->getPointerOperand(),
  83                         LocationSize::precise(DL.getTypeStoreSize(
  84                             RMWI->getValOperand()->getType())),
  85                         AATags);
  86 }
  87
  88 Optional<MemoryLocation> MemoryLocation::getOrNone(const Instruction *Inst) {
  89   switch (Inst->getOpcode()) {
  90   case Instruction::Load:
  91     return get(cast<LoadInst>(Inst));
  92   case Instruction::Store:
  93     return get(cast<StoreInst>(Inst));
  94   case Instruction::VAArg:
  95     return get(cast<VAArgInst>(Inst));
  96   case Instruction::AtomicCmpXchg:
  97     return get(cast<AtomicCmpXchgInst>(Inst));
  98   case Instruction::AtomicRMW:
  99     return get(cast<AtomicRMWInst>(Inst));
 100   default:
 101     return None;
 102   }
 103 }
 104
 105 MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
 106   return getForSource(cast<AnyMemTransferInst>(MTI));
 107 }
 108
 109 MemoryLocation MemoryLocation::getForSource(const AtomicMemTransferInst *MTI) {
 110   return getForSource(cast<AnyMemTransferInst>(MTI));
 111 }
 112
 113 MemoryLocation MemoryLocation::getForSource(const AnyMemTransferInst *MTI) {
 114   auto Size = LocationSize::afterPointer();
 115   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
 116     Size = LocationSize::precise(C->getValue().getZExtValue());
 117
 118   // memcpy/memmove can have AA tags. For memcpy, they apply
 119   // to both the source and the destination.
 120   AAMDNodes AATags;
 121   MTI->getAAMetadata(AATags);
 122
 123   return MemoryLocation(MTI->getRawSource(), Size, AATags);
 124 }
 125
 126 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) {
 127   return getForDest(cast<AnyMemIntrinsic>(MI));
 128 }
 129
 130 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) {
 131   return getForDest(cast<AnyMemIntrinsic>(MI));
 132 }
 133
 134 MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) {
 135   auto Size = LocationSize::afterPointer();
 136   if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
 137     Size = LocationSize::precise(C->getValue().getZExtValue());
 138
 139   // memcpy/memmove can have AA tags. For memcpy, they apply
 140   // to both the source and the destination.
 141   AAMDNodes AATags;
 142   MI->getAAMetadata(AATags);
 143
 144   return MemoryLocation(MI->getRawDest(), Size, AATags);
 145 }
 146
 147 MemoryLocation MemoryLocation::getForArgument(const CallBase *Call,
 148                                               unsigned ArgIdx,
 149                                               const TargetLibraryInfo *TLI) {
 150   AAMDNodes AATags;
 151   Call->getAAMetadata(AATags);
 152   const Value *Arg = Call->getArgOperand(ArgIdx);
 153
 154   // We may be able to produce an exact size for known intrinsics.
 155   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call)) {
 156     const DataLayout &DL = II->getModule()->getDataLayout();
 157
 158     switch (II->getIntrinsicID()) {
 159     default:
 160       break;
 161     case Intrinsic::memset:
 162     case Intrinsic::memcpy:
 163     case Intrinsic::memcpy_inline:
 164     case Intrinsic::memmove:
 165       assert((ArgIdx == 0 || ArgIdx == 1) &&
 166              "Invalid argument index for memory intrinsic");
 167       if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
 168         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 169                               AATags);
 170       return MemoryLocation::getAfter(Arg, AATags);
 171
 172     case Intrinsic::lifetime_start:
 173     case Intrinsic::lifetime_end:
 174     case Intrinsic::invariant_start:
 175       assert(ArgIdx == 1 && "Invalid argument index");
 176       return MemoryLocation(
 177           Arg,
 178           LocationSize::precise(
 179               cast<ConstantInt>(II->getArgOperand(0))->getZExtValue()),
 180           AATags);
 181
 182     case Intrinsic::masked_load:
 183       assert(ArgIdx == 0 && "Invalid argument index");
 184       return MemoryLocation(
 185           Arg,
 186           LocationSize::upperBound(DL.getTypeStoreSize(II->getType())),
 187           AATags);
 188
 189     case Intrinsic::masked_store:
 190       assert(ArgIdx == 1 && "Invalid argument index");
 191       return MemoryLocation(
 192           Arg,
 193           LocationSize::upperBound(
 194               DL.getTypeStoreSize(II->getArgOperand(0)->getType())),
 195           AATags);
 196
 197     case Intrinsic::invariant_end:
 198       // The first argument to an invariant.end is a "descriptor" type (e.g. a
 199       // pointer to a empty struct) which is never actually dereferenced.
 200       if (ArgIdx == 0)
 201         return MemoryLocation(Arg, LocationSize::precise(0), AATags);
 202       assert(ArgIdx == 2 && "Invalid argument index");
 203       return MemoryLocation(
 204           Arg,
 205           LocationSize::precise(
 206               cast<ConstantInt>(II->getArgOperand(1))->getZExtValue()),
 207           AATags);
 208
 209     case Intrinsic::arm_neon_vld1:
 210       assert(ArgIdx == 0 && "Invalid argument index");
 211       // LLVM's vld1 and vst1 intrinsics currently only support a single
 212       // vector register.
 213       return MemoryLocation(
 214           Arg, LocationSize::precise(DL.getTypeStoreSize(II->getType())),
 215           AATags);
 216
 217     case Intrinsic::arm_neon_vst1:
 218       assert(ArgIdx == 0 && "Invalid argument index");
 219       return MemoryLocation(Arg,
 220                             LocationSize::precise(DL.getTypeStoreSize(
 221                                 II->getArgOperand(1)->getType())),
 222                             AATags);
 223     }
 224   }
 225
 226   // We can bound the aliasing properties of memset_pattern16 just as we can
 227   // for memcpy/memset.  This is particularly important because the
 228   // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
 229   // whenever possible.
 230   LibFunc F;
 231   if (TLI && TLI->getLibFunc(*Call, F) && TLI->has(F)) {
 232     switch (F) {
 233     case LibFunc_memset_pattern16:
 234       assert((ArgIdx == 0 || ArgIdx == 1) &&
 235              "Invalid argument index for memset_pattern16");
 236       if (ArgIdx == 1)
 237         return MemoryLocation(Arg, LocationSize::precise(16), AATags);
 238       if (const ConstantInt *LenCI =
 239               dyn_cast<ConstantInt>(Call->getArgOperand(2)))
 240         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 241                               AATags);
 242       return MemoryLocation::getAfter(Arg, AATags);
 243     case LibFunc_bcmp:
 244     case LibFunc_memcmp:
 245       assert((ArgIdx == 0 || ArgIdx == 1) &&
 246              "Invalid argument index for memcmp/bcmp");
 247       if (const ConstantInt *LenCI =
 248               dyn_cast<ConstantInt>(Call->getArgOperand(2)))
 249         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 250                               AATags);
 251       return MemoryLocation::getAfter(Arg, AATags);
 252     case LibFunc_memchr:
 253       assert((ArgIdx == 0) && "Invalid argument index for memchr");
 254       if (const ConstantInt *LenCI =
 255               dyn_cast<ConstantInt>(Call->getArgOperand(2)))
 256         return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
 257                               AATags);
 258       return MemoryLocation::getAfter(Arg, AATags);
 259     case LibFunc_memccpy:
 260       assert((ArgIdx == 0 || ArgIdx == 1) &&
 261              "Invalid argument index for memccpy");
 262       // We only know an upper bound on the number of bytes read/written.
 263       if (const ConstantInt *LenCI =
 264               dyn_cast<ConstantInt>(Call->getArgOperand(3)))
 265         return MemoryLocation(
 266             Arg, LocationSize::upperBound(LenCI->getZExtValue()), AATags);
 267       return MemoryLocation::getAfter(Arg, AATags);
 268     default:
 269       break;
 270     };
 271   }
 272   // FIXME: Handle memset_pattern4 and memset_pattern8 also.
 273
 274   return MemoryLocation::getBeforeOrAfter(Call->getArgOperand(ArgIdx), AATags);
 275 }