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 } 276
Indexes created Mon Jun 15 00:25:07 UTC 2026