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
print(raw_ostream & OS) const21 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
get(const LoadInst * LI)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
get(const StoreInst * SI)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
get(const VAArgInst * VI)55 MemoryLocation MemoryLocation::get(const VAArgInst *VI) {
56 return MemoryLocation(VI->getPointerOperand(),
57 LocationSize::afterPointer(), VI->getAAMetadata());
58 }
59
get(const AtomicCmpXchgInst * CXI)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
get(const AtomicRMWInst * RMWI)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
getOrNone(const Instruction * Inst)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
getForSource(const MemTransferInst * MTI)95 MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
96 return getForSource(cast<AnyMemTransferInst>(MTI));
97 }
98
getForSource(const AtomicMemTransferInst * MTI)99 MemoryLocation MemoryLocation::getForSource(const AtomicMemTransferInst *MTI) {
100 return getForSource(cast<AnyMemTransferInst>(MTI));
101 }
102
getForSource(const AnyMemTransferInst * MTI)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
getForDest(const MemIntrinsic * MI)113 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) {
114 return getForDest(cast<AnyMemIntrinsic>(MI));
115 }
116
getForDest(const AtomicMemIntrinsic * MI)117 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) {
118 return getForDest(cast<AnyMemIntrinsic>(MI));
119 }
120
getForDest(const AnyMemIntrinsic * MI)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
getForArgument(const CallBase * Call,unsigned ArgIdx,const TargetLibraryInfo * TLI)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