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 assert(MTI->getRawSource() == MTI->getArgOperand(1)); 105 return getForArgument(MTI, 1, nullptr); 106 } 107 108 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) { 109 return getForDest(cast<AnyMemIntrinsic>(MI)); 110 } 111 112 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) { 113 return getForDest(cast<AnyMemIntrinsic>(MI)); 114 } 115 116 MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) { 117 assert(MI->getRawDest() == MI->getArgOperand(0)); 118 return getForArgument(MI, 0, nullptr); 119 } 120 121 Optional<MemoryLocation> 122 MemoryLocation::getForDest(const CallBase *CB, const TargetLibraryInfo &TLI) { 123 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CB)) { 124 if (auto *MemInst = dyn_cast<AnyMemIntrinsic>(CB)) 125 return getForDest(MemInst); 126 127 switch (II->getIntrinsicID()) { 128 default: 129 return None; 130 case Intrinsic::init_trampoline: 131 return MemoryLocation::getForArgument(CB, 0, TLI); 132 case Intrinsic::masked_store: 133 return MemoryLocation::getForArgument(CB, 1, TLI); 134 } 135 } 136 137 LibFunc LF; 138 if (TLI.getLibFunc(*CB, LF) && TLI.has(LF)) { 139 switch (LF) { 140 case LibFunc_strncpy: 141 case LibFunc_strcpy: 142 case LibFunc_strcat: 143 case LibFunc_strncat: 144 return getForArgument(CB, 0, &TLI); 145 default: 146 break; 147 } 148 } 149 150 return None; 151 } 152 153 MemoryLocation MemoryLocation::getForArgument(const CallBase *Call, 154 unsigned ArgIdx, 155 const TargetLibraryInfo *TLI) { 156 AAMDNodes AATags = Call->getAAMetadata(); 157 const Value *Arg = Call->getArgOperand(ArgIdx); 158 159 // We may be able to produce an exact size for known intrinsics. 160 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call)) { 161 const DataLayout &DL = II->getModule()->getDataLayout(); 162 163 switch (II->getIntrinsicID()) { 164 default: 165 break; 166 case Intrinsic::memset: 167 case Intrinsic::memcpy: 168 case Intrinsic::memcpy_inline: 169 case Intrinsic::memmove: 170 case Intrinsic::memcpy_element_unordered_atomic: 171 case Intrinsic::memmove_element_unordered_atomic: 172 case Intrinsic::memset_element_unordered_atomic: 173 assert((ArgIdx == 0 || ArgIdx == 1) && 174 "Invalid argument index for memory intrinsic"); 175 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2))) 176 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), 177 AATags); 178 return MemoryLocation::getAfter(Arg, AATags); 179 180 case Intrinsic::lifetime_start: 181 case Intrinsic::lifetime_end: 182 case Intrinsic::invariant_start: 183 assert(ArgIdx == 1 && "Invalid argument index"); 184 return MemoryLocation( 185 Arg, 186 LocationSize::precise( 187 cast<ConstantInt>(II->getArgOperand(0))->getZExtValue()), 188 AATags); 189 190 case Intrinsic::masked_load: 191 assert(ArgIdx == 0 && "Invalid argument index"); 192 return MemoryLocation( 193 Arg, 194 LocationSize::upperBound(DL.getTypeStoreSize(II->getType())), 195 AATags); 196 197 case Intrinsic::masked_store: 198 assert(ArgIdx == 1 && "Invalid argument index"); 199 return MemoryLocation( 200 Arg, 201 LocationSize::upperBound( 202 DL.getTypeStoreSize(II->getArgOperand(0)->getType())), 203 AATags); 204 205 case Intrinsic::invariant_end: 206 // The first argument to an invariant.end is a "descriptor" type (e.g. a 207 // pointer to a empty struct) which is never actually dereferenced. 208 if (ArgIdx == 0) 209 return MemoryLocation(Arg, LocationSize::precise(0), AATags); 210 assert(ArgIdx == 2 && "Invalid argument index"); 211 return MemoryLocation( 212 Arg, 213 LocationSize::precise( 214 cast<ConstantInt>(II->getArgOperand(1))->getZExtValue()), 215 AATags); 216 217 case Intrinsic::arm_neon_vld1: 218 assert(ArgIdx == 0 && "Invalid argument index"); 219 // LLVM's vld1 and vst1 intrinsics currently only support a single 220 // vector register. 221 return MemoryLocation( 222 Arg, LocationSize::precise(DL.getTypeStoreSize(II->getType())), 223 AATags); 224 225 case Intrinsic::arm_neon_vst1: 226 assert(ArgIdx == 0 && "Invalid argument index"); 227 return MemoryLocation(Arg, 228 LocationSize::precise(DL.getTypeStoreSize( 229 II->getArgOperand(1)->getType())), 230 AATags); 231 } 232 233 assert( 234 !isa<AnyMemTransferInst>(II) && 235 "all memory transfer intrinsics should be handled by the switch above"); 236 } 237 238 // We can bound the aliasing properties of memset_pattern16 just as we can 239 // for memcpy/memset. This is particularly important because the 240 // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16 241 // whenever possible. 242 LibFunc F; 243 if (TLI && TLI->getLibFunc(*Call, F) && TLI->has(F)) { 244 switch (F) { 245 case LibFunc_strcpy: 246 case LibFunc_strcat: 247 case LibFunc_strncat: 248 assert((ArgIdx == 0 || ArgIdx == 1) && "Invalid argument index for str function"); 249 return MemoryLocation::getAfter(Arg, AATags); 250 251 case LibFunc_memset_chk: { 252 assert(ArgIdx == 0 && "Invalid argument index for memset_chk"); 253 LocationSize Size = LocationSize::afterPointer(); 254 if (const auto *Len = dyn_cast<ConstantInt>(Call->getArgOperand(2))) { 255 // memset_chk writes at most Len bytes. It may write less, if Len 256 // exceeds the specified max size and aborts. 257 Size = LocationSize::upperBound(Len->getZExtValue()); 258 } 259 return MemoryLocation(Arg, Size, AATags); 260 } 261 case LibFunc_strncpy: { 262 assert((ArgIdx == 0 || ArgIdx == 1) && 263 "Invalid argument index for strncpy"); 264 LocationSize Size = LocationSize::afterPointer(); 265 if (const auto *Len = dyn_cast<ConstantInt>(Call->getArgOperand(2))) { 266 // strncpy is guaranteed to write Len bytes, but only reads up to Len 267 // bytes. 268 Size = ArgIdx == 0 ? LocationSize::precise(Len->getZExtValue()) 269 : LocationSize::upperBound(Len->getZExtValue()); 270 } 271 return MemoryLocation(Arg, Size, AATags); 272 } 273 case LibFunc_memset_pattern16: 274 case LibFunc_memset_pattern4: 275 case LibFunc_memset_pattern8: 276 assert((ArgIdx == 0 || ArgIdx == 1) && 277 "Invalid argument index for memset_pattern16"); 278 if (ArgIdx == 1) { 279 unsigned Size = 16; 280 if (F == LibFunc_memset_pattern4) 281 Size = 4; 282 else if (F == LibFunc_memset_pattern8) 283 Size = 8; 284 return MemoryLocation(Arg, LocationSize::precise(Size), AATags); 285 } 286 if (const ConstantInt *LenCI = 287 dyn_cast<ConstantInt>(Call->getArgOperand(2))) 288 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), 289 AATags); 290 return MemoryLocation::getAfter(Arg, AATags); 291 case LibFunc_bcmp: 292 case LibFunc_memcmp: 293 assert((ArgIdx == 0 || ArgIdx == 1) && 294 "Invalid argument index for memcmp/bcmp"); 295 if (const ConstantInt *LenCI = 296 dyn_cast<ConstantInt>(Call->getArgOperand(2))) 297 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), 298 AATags); 299 return MemoryLocation::getAfter(Arg, AATags); 300 case LibFunc_memchr: 301 assert((ArgIdx == 0) && "Invalid argument index for memchr"); 302 if (const ConstantInt *LenCI = 303 dyn_cast<ConstantInt>(Call->getArgOperand(2))) 304 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), 305 AATags); 306 return MemoryLocation::getAfter(Arg, AATags); 307 case LibFunc_memccpy: 308 assert((ArgIdx == 0 || ArgIdx == 1) && 309 "Invalid argument index for memccpy"); 310 // We only know an upper bound on the number of bytes read/written. 311 if (const ConstantInt *LenCI = 312 dyn_cast<ConstantInt>(Call->getArgOperand(3))) 313 return MemoryLocation( 314 Arg, LocationSize::upperBound(LenCI->getZExtValue()), AATags); 315 return MemoryLocation::getAfter(Arg, AATags); 316 default: 317 break; 318 }; 319 } 320 321 return MemoryLocation::getBeforeOrAfter(Call->getArgOperand(ArgIdx), AATags); 322 } 323