MemoryLocation.cpp revision 321369
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" 19using namespace llvm; 20 21MemoryLocation MemoryLocation::get(const LoadInst *LI) { 22 AAMDNodes AATags; 23 LI->getAAMetadata(AATags); 24 const auto &DL = LI->getModule()->getDataLayout(); 25 26 return MemoryLocation(LI->getPointerOperand(), 27 DL.getTypeStoreSize(LI->getType()), AATags); 28} 29 30MemoryLocation MemoryLocation::get(const StoreInst *SI) { 31 AAMDNodes AATags; 32 SI->getAAMetadata(AATags); 33 const auto &DL = SI->getModule()->getDataLayout(); 34 35 return MemoryLocation(SI->getPointerOperand(), 36 DL.getTypeStoreSize(SI->getValueOperand()->getType()), 37 AATags); 38} 39 40MemoryLocation MemoryLocation::get(const VAArgInst *VI) { 41 AAMDNodes AATags; 42 VI->getAAMetadata(AATags); 43 44 return MemoryLocation(VI->getPointerOperand(), UnknownSize, AATags); 45} 46 47MemoryLocation MemoryLocation::get(const AtomicCmpXchgInst *CXI) { 48 AAMDNodes AATags; 49 CXI->getAAMetadata(AATags); 50 const auto &DL = CXI->getModule()->getDataLayout(); 51 52 return MemoryLocation( 53 CXI->getPointerOperand(), 54 DL.getTypeStoreSize(CXI->getCompareOperand()->getType()), AATags); 55} 56 57MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) { 58 AAMDNodes AATags; 59 RMWI->getAAMetadata(AATags); 60 const auto &DL = RMWI->getModule()->getDataLayout(); 61 62 return MemoryLocation(RMWI->getPointerOperand(), 63 DL.getTypeStoreSize(RMWI->getValOperand()->getType()), 64 AATags); 65} 66 67MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) { 68 uint64_t Size = UnknownSize; 69 if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength())) 70 Size = C->getValue().getZExtValue(); 71 72 // memcpy/memmove can have AA tags. For memcpy, they apply 73 // to both the source and the destination. 74 AAMDNodes AATags; 75 MTI->getAAMetadata(AATags); 76 77 return MemoryLocation(MTI->getRawSource(), Size, AATags); 78} 79 80MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MTI) { 81 uint64_t Size = UnknownSize; 82 if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength())) 83 Size = C->getValue().getZExtValue(); 84 85 // memcpy/memmove can have AA tags. For memcpy, they apply 86 // to both the source and the destination. 87 AAMDNodes AATags; 88 MTI->getAAMetadata(AATags); 89 90 return MemoryLocation(MTI->getRawDest(), Size, AATags); 91} 92 93MemoryLocation MemoryLocation::getForArgument(ImmutableCallSite CS, 94 unsigned ArgIdx, 95 const TargetLibraryInfo &TLI) { 96 AAMDNodes AATags; 97 CS->getAAMetadata(AATags); 98 const Value *Arg = CS.getArgument(ArgIdx); 99 100 // We may be able to produce an exact size for known intrinsics. 101 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) { 102 const DataLayout &DL = II->getModule()->getDataLayout(); 103 104 switch (II->getIntrinsicID()) { 105 default: 106 break; 107 case Intrinsic::memset: 108 case Intrinsic::memcpy: 109 case Intrinsic::memmove: 110 assert((ArgIdx == 0 || ArgIdx == 1) && 111 "Invalid argument index for memory intrinsic"); 112 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2))) 113 return MemoryLocation(Arg, LenCI->getZExtValue(), AATags); 114 break; 115 116 case Intrinsic::lifetime_start: 117 case Intrinsic::lifetime_end: 118 case Intrinsic::invariant_start: 119 assert(ArgIdx == 1 && "Invalid argument index"); 120 return MemoryLocation( 121 Arg, cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AATags); 122 123 case Intrinsic::invariant_end: 124 assert(ArgIdx == 2 && "Invalid argument index"); 125 return MemoryLocation( 126 Arg, cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AATags); 127 128 case Intrinsic::arm_neon_vld1: 129 assert(ArgIdx == 0 && "Invalid argument index"); 130 // LLVM's vld1 and vst1 intrinsics currently only support a single 131 // vector register. 132 return MemoryLocation(Arg, DL.getTypeStoreSize(II->getType()), AATags); 133 134 case Intrinsic::arm_neon_vst1: 135 assert(ArgIdx == 0 && "Invalid argument index"); 136 return MemoryLocation( 137 Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags); 138 } 139 } 140 141 // We can bound the aliasing properties of memset_pattern16 just as we can 142 // for memcpy/memset. This is particularly important because the 143 // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16 144 // whenever possible. 145 LibFunc F; 146 if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) && 147 F == LibFunc_memset_pattern16 && TLI.has(F)) { 148 assert((ArgIdx == 0 || ArgIdx == 1) && 149 "Invalid argument index for memset_pattern16"); 150 if (ArgIdx == 1) 151 return MemoryLocation(Arg, 16, AATags); 152 if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2))) 153 return MemoryLocation(Arg, LenCI->getZExtValue(), AATags); 154 } 155 // FIXME: Handle memset_pattern4 and memset_pattern8 also. 156 157 return MemoryLocation(CS.getArgument(ArgIdx), UnknownSize, AATags); 158} 159