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