contrib/llvm/lib/Transforms/Utils/VNCoercion.cpp

   1 #include "llvm/Transforms/Utils/VNCoercion.h"
   2 #include "llvm/Analysis/AliasAnalysis.h"
   3 #include "llvm/Analysis/ConstantFolding.h"
   4 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
   5 #include "llvm/Analysis/ValueTracking.h"
   6 #include "llvm/IR/IRBuilder.h"
   7 #include "llvm/IR/IntrinsicInst.h"
   8 #include "llvm/Support/Debug.h"
   9
  10 #define DEBUG_TYPE "vncoerce"
  11 namespace llvm {
  12 namespace VNCoercion {
  13
  14 /// Return true if coerceAvailableValueToLoadType will succeed.
  15 bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
  16                                      const DataLayout &DL) {
  17   // If the loaded or stored value is an first class array or struct, don't try
  18   // to transform them.  We need to be able to bitcast to integer.
  19   if (LoadTy->isStructTy() || LoadTy->isArrayTy() ||
  20       StoredVal->getType()->isStructTy() || StoredVal->getType()->isArrayTy())
  21     return false;
  22
  23   uint64_t StoreSize = DL.getTypeSizeInBits(StoredVal->getType());
  24
  25   // The store size must be byte-aligned to support future type casts.
  26   if (llvm::alignTo(StoreSize, 8) != StoreSize)
  27     return false;
  28
  29   // The store has to be at least as big as the load.
  30   if (StoreSize < DL.getTypeSizeInBits(LoadTy))
  31     return false;
  32
  33   // Don't coerce non-integral pointers to integers or vice versa.
  34   if (DL.isNonIntegralPointerType(StoredVal->getType()) !=
  35       DL.isNonIntegralPointerType(LoadTy))
  36     return false;
  37
  38   return true;
  39 }
  40
  41 template <class T, class HelperClass>
  42 static T *coerceAvailableValueToLoadTypeHelper(T *StoredVal, Type *LoadedTy,
  43                                                HelperClass &Helper,
  44                                                const DataLayout &DL) {
  45   assert(canCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
  46          "precondition violation - materialization can't fail");
  47   if (auto *C = dyn_cast<Constant>(StoredVal))
  48     if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
  49       StoredVal = FoldedStoredVal;
  50
  51   // If this is already the right type, just return it.
  52   Type *StoredValTy = StoredVal->getType();
  53
  54   uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy);
  55   uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy);
  56
  57   // If the store and reload are the same size, we can always reuse it.
  58   if (StoredValSize == LoadedValSize) {
  59     // Pointer to Pointer -> use bitcast.
  60     if (StoredValTy->isPtrOrPtrVectorTy() && LoadedTy->isPtrOrPtrVectorTy()) {
  61       StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
  62     } else {
  63       // Convert source pointers to integers, which can be bitcast.
  64       if (StoredValTy->isPtrOrPtrVectorTy()) {
  65         StoredValTy = DL.getIntPtrType(StoredValTy);
  66         StoredVal = Helper.CreatePtrToInt(StoredVal, StoredValTy);
  67       }
  68
  69       Type *TypeToCastTo = LoadedTy;
  70       if (TypeToCastTo->isPtrOrPtrVectorTy())
  71         TypeToCastTo = DL.getIntPtrType(TypeToCastTo);
  72
  73       if (StoredValTy != TypeToCastTo)
  74         StoredVal = Helper.CreateBitCast(StoredVal, TypeToCastTo);
  75
  76       // Cast to pointer if the load needs a pointer type.
  77       if (LoadedTy->isPtrOrPtrVectorTy())
  78         StoredVal = Helper.CreateIntToPtr(StoredVal, LoadedTy);
  79     }
  80
  81     if (auto *C = dyn_cast<ConstantExpr>(StoredVal))
  82       if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
  83         StoredVal = FoldedStoredVal;
  84
  85     return StoredVal;
  86   }
  87   // If the loaded value is smaller than the available value, then we can
  88   // extract out a piece from it.  If the available value is too small, then we
  89   // can't do anything.
  90   assert(StoredValSize >= LoadedValSize &&
  91          "canCoerceMustAliasedValueToLoad fail");
  92
  93   // Convert source pointers to integers, which can be manipulated.
  94   if (StoredValTy->isPtrOrPtrVectorTy()) {
  95     StoredValTy = DL.getIntPtrType(StoredValTy);
  96     StoredVal = Helper.CreatePtrToInt(StoredVal, StoredValTy);
  97   }
  98
  99   // Convert vectors and fp to integer, which can be manipulated.
 100   if (!StoredValTy->isIntegerTy()) {
 101     StoredValTy = IntegerType::get(StoredValTy->getContext(), StoredValSize);
 102     StoredVal = Helper.CreateBitCast(StoredVal, StoredValTy);
 103   }
 104
 105   // If this is a big-endian system, we need to shift the value down to the low
 106   // bits so that a truncate will work.
 107   if (DL.isBigEndian()) {
 108     uint64_t ShiftAmt = DL.getTypeStoreSizeInBits(StoredValTy) -
 109                         DL.getTypeStoreSizeInBits(LoadedTy);
 110     StoredVal = Helper.CreateLShr(
 111         StoredVal, ConstantInt::get(StoredVal->getType(), ShiftAmt));
 112   }
 113
 114   // Truncate the integer to the right size now.
 115   Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize);
 116   StoredVal = Helper.CreateTruncOrBitCast(StoredVal, NewIntTy);
 117
 118   if (LoadedTy != NewIntTy) {
 119     // If the result is a pointer, inttoptr.
 120     if (LoadedTy->isPtrOrPtrVectorTy())
 121       StoredVal = Helper.CreateIntToPtr(StoredVal, LoadedTy);
 122     else
 123       // Otherwise, bitcast.
 124       StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
 125   }
 126
 127   if (auto *C = dyn_cast<Constant>(StoredVal))
 128     if (auto *FoldedStoredVal = ConstantFoldConstant(C, DL))
 129       StoredVal = FoldedStoredVal;
 130
 131   return StoredVal;
 132 }
 133
 134 /// If we saw a store of a value to memory, and
 135 /// then a load from a must-aliased pointer of a different type, try to coerce
 136 /// the stored value.  LoadedTy is the type of the load we want to replace.
 137 /// IRB is IRBuilder used to insert new instructions.
 138 ///
 139 /// If we can't do it, return null.
 140 Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
 141                                       IRBuilder<> &IRB, const DataLayout &DL) {
 142   return coerceAvailableValueToLoadTypeHelper(StoredVal, LoadedTy, IRB, DL);
 143 }
 144
 145 /// This function is called when we have a memdep query of a load that ends up
 146 /// being a clobbering memory write (store, memset, memcpy, memmove).  This
 147 /// means that the write *may* provide bits used by the load but we can't be
 148 /// sure because the pointers don't must-alias.
 149 ///
 150 /// Check this case to see if there is anything more we can do before we give
 151 /// up.  This returns -1 if we have to give up, or a byte number in the stored
 152 /// value of the piece that feeds the load.
 153 static int analyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
 154                                           Value *WritePtr,
 155                                           uint64_t WriteSizeInBits,
 156                                           const DataLayout &DL) {
 157   // If the loaded or stored value is a first class array or struct, don't try
 158   // to transform them.  We need to be able to bitcast to integer.
 159   if (LoadTy->isStructTy() || LoadTy->isArrayTy())
 160     return -1;
 161
 162   int64_t StoreOffset = 0, LoadOffset = 0;
 163   Value *StoreBase =
 164       GetPointerBaseWithConstantOffset(WritePtr, StoreOffset, DL);
 165   Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, DL);
 166   if (StoreBase != LoadBase)
 167     return -1;
 168
 169   // If the load and store are to the exact same address, they should have been
 170   // a must alias.  AA must have gotten confused.
 171   // FIXME: Study to see if/when this happens.  One case is forwarding a memset
 172   // to a load from the base of the memset.
 173
 174   // If the load and store don't overlap at all, the store doesn't provide
 175   // anything to the load.  In this case, they really don't alias at all, AA
 176   // must have gotten confused.
 177   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy);
 178
 179   if ((WriteSizeInBits & 7) | (LoadSize & 7))
 180     return -1;
 181   uint64_t StoreSize = WriteSizeInBits / 8; // Convert to bytes.
 182   LoadSize /= 8;
 183
 184   bool isAAFailure = false;
 185   if (StoreOffset < LoadOffset)
 186     isAAFailure = StoreOffset + int64_t(StoreSize) <= LoadOffset;
 187   else
 188     isAAFailure = LoadOffset + int64_t(LoadSize) <= StoreOffset;
 189
 190   if (isAAFailure)
 191     return -1;
 192
 193   // If the Load isn't completely contained within the stored bits, we don't
 194   // have all the bits to feed it.  We could do something crazy in the future
 195   // (issue a smaller load then merge the bits in) but this seems unlikely to be
 196   // valuable.
 197   if (StoreOffset > LoadOffset ||
 198       StoreOffset + StoreSize < LoadOffset + LoadSize)
 199     return -1;
 200
 201   // Okay, we can do this transformation.  Return the number of bytes into the
 202   // store that the load is.
 203   return LoadOffset - StoreOffset;
 204 }
 205
 206 /// This function is called when we have a
 207 /// memdep query of a load that ends up being a clobbering store.
 208 int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
 209                                    StoreInst *DepSI, const DataLayout &DL) {
 210   // Cannot handle reading from store of first-class aggregate yet.
 211   if (DepSI->getValueOperand()->getType()->isStructTy() ||
 212       DepSI->getValueOperand()->getType()->isArrayTy())
 213     return -1;
 214
 215   Value *StorePtr = DepSI->getPointerOperand();
 216   uint64_t StoreSize =
 217       DL.getTypeSizeInBits(DepSI->getValueOperand()->getType());
 218   return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, StorePtr, StoreSize,
 219                                         DL);
 220 }
 221
 222 /// This function is called when we have a
 223 /// memdep query of a load that ends up being clobbered by another load.  See if
 224 /// the other load can feed into the second load.
 225 int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
 226                                   const DataLayout &DL) {
 227   // Cannot handle reading from store of first-class aggregate yet.
 228   if (DepLI->getType()->isStructTy() || DepLI->getType()->isArrayTy())
 229     return -1;
 230
 231   Value *DepPtr = DepLI->getPointerOperand();
 232   uint64_t DepSize = DL.getTypeSizeInBits(DepLI->getType());
 233   int R = analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, DepSize, DL);
 234   if (R != -1)
 235     return R;
 236
 237   // If we have a load/load clobber an DepLI can be widened to cover this load,
 238   // then we should widen it!
 239   int64_t LoadOffs = 0;
 240   const Value *LoadBase =
 241       GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, DL);
 242   unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
 243
 244   unsigned Size = MemoryDependenceResults::getLoadLoadClobberFullWidthSize(
 245       LoadBase, LoadOffs, LoadSize, DepLI);
 246   if (Size == 0)
 247     return -1;
 248
 249   // Check non-obvious conditions enforced by MDA which we rely on for being
 250   // able to materialize this potentially available value
 251   assert(DepLI->isSimple() && "Cannot widen volatile/atomic load!");
 252   assert(DepLI->getType()->isIntegerTy() && "Can't widen non-integer load");
 253
 254   return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size * 8, DL);
 255 }
 256
 257 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
 258                                      MemIntrinsic *MI, const DataLayout &DL) {
 259   // If the mem operation is a non-constant size, we can't handle it.
 260   ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
 261   if (!SizeCst)
 262     return -1;
 263   uint64_t MemSizeInBits = SizeCst->getZExtValue() * 8;
 264
 265   // If this is memset, we just need to see if the offset is valid in the size
 266   // of the memset..
 267   if (MI->getIntrinsicID() == Intrinsic::memset)
 268     return analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
 269                                           MemSizeInBits, DL);
 270
 271   // If we have a memcpy/memmove, the only case we can handle is if this is a
 272   // copy from constant memory.  In that case, we can read directly from the
 273   // constant memory.
 274   MemTransferInst *MTI = cast<MemTransferInst>(MI);
 275
 276   Constant *Src = dyn_cast<Constant>(MTI->getSource());
 277   if (!Src)
 278     return -1;
 279
 280   GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, DL));
 281   if (!GV || !GV->isConstant())
 282     return -1;
 283
 284   // See if the access is within the bounds of the transfer.
 285   int Offset = analyzeLoadFromClobberingWrite(LoadTy, LoadPtr, MI->getDest(),
 286                                               MemSizeInBits, DL);
 287   if (Offset == -1)
 288     return Offset;
 289
 290   unsigned AS = Src->getType()->getPointerAddressSpace();
 291   // Otherwise, see if we can constant fold a load from the constant with the
 292   // offset applied as appropriate.
 293   Src =
 294       ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
 295   Constant *OffsetCst =
 296       ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
 297   Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
 298                                        OffsetCst);
 299   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
 300   if (ConstantFoldLoadFromConstPtr(Src, LoadTy, DL))
 301     return Offset;
 302   return -1;
 303 }
 304
 305 template <class T, class HelperClass>
 306 static T *getStoreValueForLoadHelper(T *SrcVal, unsigned Offset, Type *LoadTy,
 307                                      HelperClass &Helper,
 308                                      const DataLayout &DL) {
 309   LLVMContext &Ctx = SrcVal->getType()->getContext();
 310
 311   // If two pointers are in the same address space, they have the same size,
 312   // so we don't need to do any truncation, etc. This avoids introducing
 313   // ptrtoint instructions for pointers that may be non-integral.
 314   if (SrcVal->getType()->isPointerTy() && LoadTy->isPointerTy() &&
 315       cast<PointerType>(SrcVal->getType())->getAddressSpace() ==
 316           cast<PointerType>(LoadTy)->getAddressSpace()) {
 317     return SrcVal;
 318   }
 319
 320   uint64_t StoreSize = (DL.getTypeSizeInBits(SrcVal->getType()) + 7) / 8;
 321   uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy) + 7) / 8;
 322   // Compute which bits of the stored value are being used by the load.  Convert
 323   // to an integer type to start with.
 324   if (SrcVal->getType()->isPtrOrPtrVectorTy())
 325     SrcVal = Helper.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
 326   if (!SrcVal->getType()->isIntegerTy())
 327     SrcVal = Helper.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
 328
 329   // Shift the bits to the least significant depending on endianness.
 330   unsigned ShiftAmt;
 331   if (DL.isLittleEndian())
 332     ShiftAmt = Offset * 8;
 333   else
 334     ShiftAmt = (StoreSize - LoadSize - Offset) * 8;
 335   if (ShiftAmt)
 336     SrcVal = Helper.CreateLShr(SrcVal,
 337                                ConstantInt::get(SrcVal->getType(), ShiftAmt));
 338
 339   if (LoadSize != StoreSize)
 340     SrcVal = Helper.CreateTruncOrBitCast(SrcVal,
 341                                          IntegerType::get(Ctx, LoadSize * 8));
 342   return SrcVal;
 343 }
 344
 345 /// This function is called when we have a memdep query of a load that ends up
 346 /// being a clobbering store.  This means that the store provides bits used by
 347 /// the load but the pointers don't must-alias.  Check this case to see if
 348 /// there is anything more we can do before we give up.
 349 Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
 350                             Instruction *InsertPt, const DataLayout &DL) {
 351
 352   IRBuilder<> Builder(InsertPt);
 353   SrcVal = getStoreValueForLoadHelper(SrcVal, Offset, LoadTy, Builder, DL);
 354   return coerceAvailableValueToLoadTypeHelper(SrcVal, LoadTy, Builder, DL);
 355 }
 356
 357 Constant *getConstantStoreValueForLoad(Constant *SrcVal, unsigned Offset,
 358                                        Type *LoadTy, const DataLayout &DL) {
 359   ConstantFolder F;
 360   SrcVal = getStoreValueForLoadHelper(SrcVal, Offset, LoadTy, F, DL);
 361   return coerceAvailableValueToLoadTypeHelper(SrcVal, LoadTy, F, DL);
 362 }
 363
 364 /// This function is called when we have a memdep query of a load that ends up
 365 /// being a clobbering load.  This means that the load *may* provide bits used
 366 /// by the load but we can't be sure because the pointers don't must-alias.
 367 /// Check this case to see if there is anything more we can do before we give
 368 /// up.
 369 Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
 370                            Instruction *InsertPt, const DataLayout &DL) {
 371   // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to
 372   // widen SrcVal out to a larger load.
 373   unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
 374   unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
 375   if (Offset + LoadSize > SrcValStoreSize) {
 376     assert(SrcVal->isSimple() && "Cannot widen volatile/atomic load!");
 377     assert(SrcVal->getType()->isIntegerTy() && "Can't widen non-integer load");
 378     // If we have a load/load clobber an DepLI can be widened to cover this
 379     // load, then we should widen it to the next power of 2 size big enough!
 380     unsigned NewLoadSize = Offset + LoadSize;
 381     if (!isPowerOf2_32(NewLoadSize))
 382       NewLoadSize = NextPowerOf2(NewLoadSize);
 383
 384     Value *PtrVal = SrcVal->getPointerOperand();
 385     // Insert the new load after the old load.  This ensures that subsequent
 386     // memdep queries will find the new load.  We can't easily remove the old
 387     // load completely because it is already in the value numbering table.
 388     IRBuilder<> Builder(SrcVal->getParent(), ++BasicBlock::iterator(SrcVal));
 389     Type *DestPTy = IntegerType::get(LoadTy->getContext(), NewLoadSize * 8);
 390     DestPTy =
 391         PointerType::get(DestPTy, PtrVal->getType()->getPointerAddressSpace());
 392     Builder.SetCurrentDebugLocation(SrcVal->getDebugLoc());
 393     PtrVal = Builder.CreateBitCast(PtrVal, DestPTy);
 394     LoadInst *NewLoad = Builder.CreateLoad(PtrVal);
 395     NewLoad->takeName(SrcVal);
 396     NewLoad->setAlignment(SrcVal->getAlignment());
 397
 398     LLVM_DEBUG(dbgs() << "GVN WIDENED LOAD: " << *SrcVal << "\n");
 399     LLVM_DEBUG(dbgs() << "TO: " << *NewLoad << "\n");
 400
 401     // Replace uses of the original load with the wider load.  On a big endian
 402     // system, we need to shift down to get the relevant bits.
 403     Value *RV = NewLoad;
 404     if (DL.isBigEndian())
 405       RV = Builder.CreateLShr(RV, (NewLoadSize - SrcValStoreSize) * 8);
 406     RV = Builder.CreateTrunc(RV, SrcVal->getType());
 407     SrcVal->replaceAllUsesWith(RV);
 408
 409     SrcVal = NewLoad;
 410   }
 411
 412   return getStoreValueForLoad(SrcVal, Offset, LoadTy, InsertPt, DL);
 413 }
 414
 415 Constant *getConstantLoadValueForLoad(Constant *SrcVal, unsigned Offset,
 416                                       Type *LoadTy, const DataLayout &DL) {
 417   unsigned SrcValStoreSize = DL.getTypeStoreSize(SrcVal->getType());
 418   unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
 419   if (Offset + LoadSize > SrcValStoreSize)
 420     return nullptr;
 421   return getConstantStoreValueForLoad(SrcVal, Offset, LoadTy, DL);
 422 }
 423
 424 template <class T, class HelperClass>
 425 T *getMemInstValueForLoadHelper(MemIntrinsic *SrcInst, unsigned Offset,
 426                                 Type *LoadTy, HelperClass &Helper,
 427                                 const DataLayout &DL) {
 428   LLVMContext &Ctx = LoadTy->getContext();
 429   uint64_t LoadSize = DL.getTypeSizeInBits(LoadTy) / 8;
 430
 431   // We know that this method is only called when the mem transfer fully
 432   // provides the bits for the load.
 433   if (MemSetInst *MSI = dyn_cast<MemSetInst>(SrcInst)) {
 434     // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
 435     // independently of what the offset is.
 436     T *Val = cast<T>(MSI->getValue());
 437     if (LoadSize != 1)
 438       Val =
 439           Helper.CreateZExtOrBitCast(Val, IntegerType::get(Ctx, LoadSize * 8));
 440     T *OneElt = Val;
 441
 442     // Splat the value out to the right number of bits.
 443     for (unsigned NumBytesSet = 1; NumBytesSet != LoadSize;) {
 444       // If we can double the number of bytes set, do it.
 445       if (NumBytesSet * 2 <= LoadSize) {
 446         T *ShVal = Helper.CreateShl(
 447             Val, ConstantInt::get(Val->getType(), NumBytesSet * 8));
 448         Val = Helper.CreateOr(Val, ShVal);
 449         NumBytesSet <<= 1;
 450         continue;
 451       }
 452
 453       // Otherwise insert one byte at a time.
 454       T *ShVal = Helper.CreateShl(Val, ConstantInt::get(Val->getType(), 1 * 8));
 455       Val = Helper.CreateOr(OneElt, ShVal);
 456       ++NumBytesSet;
 457     }
 458
 459     return coerceAvailableValueToLoadTypeHelper(Val, LoadTy, Helper, DL);
 460   }
 461
 462   // Otherwise, this is a memcpy/memmove from a constant global.
 463   MemTransferInst *MTI = cast<MemTransferInst>(SrcInst);
 464   Constant *Src = cast<Constant>(MTI->getSource());
 465   unsigned AS = Src->getType()->getPointerAddressSpace();
 466
 467   // Otherwise, see if we can constant fold a load from the constant with the
 468   // offset applied as appropriate.
 469   Src =
 470       ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
 471   Constant *OffsetCst =
 472       ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
 473   Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
 474                                        OffsetCst);
 475   Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
 476   return ConstantFoldLoadFromConstPtr(Src, LoadTy, DL);
 477 }
 478
 479 /// This function is called when we have a
 480 /// memdep query of a load that ends up being a clobbering mem intrinsic.
 481 Value *getMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
 482                               Type *LoadTy, Instruction *InsertPt,
 483                               const DataLayout &DL) {
 484   IRBuilder<> Builder(InsertPt);
 485   return getMemInstValueForLoadHelper<Value, IRBuilder<>>(SrcInst, Offset,
 486                                                           LoadTy, Builder, DL);
 487 }
 488
 489 Constant *getConstantMemInstValueForLoad(MemIntrinsic *SrcInst, unsigned Offset,
 490                                          Type *LoadTy, const DataLayout &DL) {
 491   // The only case analyzeLoadFromClobberingMemInst cannot be converted to a
 492   // constant is when it's a memset of a non-constant.
 493   if (auto *MSI = dyn_cast<MemSetInst>(SrcInst))
 494     if (!isa<Constant>(MSI->getValue()))
 495       return nullptr;
 496   ConstantFolder F;
 497   return getMemInstValueForLoadHelper<Constant, ConstantFolder>(SrcInst, Offset,
 498                                                                 LoadTy, F, DL);
 499 }
 500 } // namespace VNCoercion
 501 } // namespace llvm