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 == unknown())
24 OS << "unknown";
25 else if (*this == mapEmpty())
26 OS << "mapEmpty";
27 else if (*this == mapTombstone())
28 OS << "mapTombstone";
29 else if (isPrecise())
30 OS << "precise(" << getValue() << ')';
31 else
32 OS << "upperBound(" << getValue() << ')';
33 }
34
get(const LoadInst * LI)35 MemoryLocation MemoryLocation::get(const LoadInst *LI) {
36 AAMDNodes AATags;
37 LI->getAAMetadata(AATags);
38 const auto &DL = LI->getModule()->getDataLayout();
39
40 return MemoryLocation(
41 LI->getPointerOperand(),
42 LocationSize::precise(DL.getTypeStoreSize(LI->getType())), AATags);
43 }
44
get(const StoreInst * SI)45 MemoryLocation MemoryLocation::get(const StoreInst *SI) {
46 AAMDNodes AATags;
47 SI->getAAMetadata(AATags);
48 const auto &DL = SI->getModule()->getDataLayout();
49
50 return MemoryLocation(SI->getPointerOperand(),
51 LocationSize::precise(DL.getTypeStoreSize(
52 SI->getValueOperand()->getType())),
53 AATags);
54 }
55
get(const VAArgInst * VI)56 MemoryLocation MemoryLocation::get(const VAArgInst *VI) {
57 AAMDNodes AATags;
58 VI->getAAMetadata(AATags);
59
60 return MemoryLocation(VI->getPointerOperand(), LocationSize::unknown(),
61 AATags);
62 }
63
get(const AtomicCmpXchgInst * CXI)64 MemoryLocation MemoryLocation::get(const AtomicCmpXchgInst *CXI) {
65 AAMDNodes AATags;
66 CXI->getAAMetadata(AATags);
67 const auto &DL = CXI->getModule()->getDataLayout();
68
69 return MemoryLocation(CXI->getPointerOperand(),
70 LocationSize::precise(DL.getTypeStoreSize(
71 CXI->getCompareOperand()->getType())),
72 AATags);
73 }
74
get(const AtomicRMWInst * RMWI)75 MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) {
76 AAMDNodes AATags;
77 RMWI->getAAMetadata(AATags);
78 const auto &DL = RMWI->getModule()->getDataLayout();
79
80 return MemoryLocation(RMWI->getPointerOperand(),
81 LocationSize::precise(DL.getTypeStoreSize(
82 RMWI->getValOperand()->getType())),
83 AATags);
84 }
85
getForSource(const MemTransferInst * MTI)86 MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
87 return getForSource(cast<AnyMemTransferInst>(MTI));
88 }
89
getForSource(const AtomicMemTransferInst * MTI)90 MemoryLocation MemoryLocation::getForSource(const AtomicMemTransferInst *MTI) {
91 return getForSource(cast<AnyMemTransferInst>(MTI));
92 }
93
getForSource(const AnyMemTransferInst * MTI)94 MemoryLocation MemoryLocation::getForSource(const AnyMemTransferInst *MTI) {
95 auto Size = LocationSize::unknown();
96 if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
97 Size = LocationSize::precise(C->getValue().getZExtValue());
98
99 // memcpy/memmove can have AA tags. For memcpy, they apply
100 // to both the source and the destination.
101 AAMDNodes AATags;
102 MTI->getAAMetadata(AATags);
103
104 return MemoryLocation(MTI->getRawSource(), Size, AATags);
105 }
106
getForDest(const MemIntrinsic * MI)107 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) {
108 return getForDest(cast<AnyMemIntrinsic>(MI));
109 }
110
getForDest(const AtomicMemIntrinsic * MI)111 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) {
112 return getForDest(cast<AnyMemIntrinsic>(MI));
113 }
114
getForDest(const AnyMemIntrinsic * MI)115 MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) {
116 auto Size = LocationSize::unknown();
117 if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
118 Size = LocationSize::precise(C->getValue().getZExtValue());
119
120 // memcpy/memmove can have AA tags. For memcpy, they apply
121 // to both the source and the destination.
122 AAMDNodes AATags;
123 MI->getAAMetadata(AATags);
124
125 return MemoryLocation(MI->getRawDest(), Size, AATags);
126 }
127
getForArgument(const CallBase * Call,unsigned ArgIdx,const TargetLibraryInfo * TLI)128 MemoryLocation MemoryLocation::getForArgument(const CallBase *Call,
129 unsigned ArgIdx,
130 const TargetLibraryInfo *TLI) {
131 AAMDNodes AATags;
132 Call->getAAMetadata(AATags);
133 const Value *Arg = Call->getArgOperand(ArgIdx);
134
135 // We may be able to produce an exact size for known intrinsics.
136 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Call)) {
137 const DataLayout &DL = II->getModule()->getDataLayout();
138
139 switch (II->getIntrinsicID()) {
140 default:
141 break;
142 case Intrinsic::memset:
143 case Intrinsic::memcpy:
144 case Intrinsic::memmove:
145 assert((ArgIdx == 0 || ArgIdx == 1) &&
146 "Invalid argument index for memory intrinsic");
147 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
148 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
149 AATags);
150 break;
151
152 case Intrinsic::lifetime_start:
153 case Intrinsic::lifetime_end:
154 case Intrinsic::invariant_start:
155 assert(ArgIdx == 1 && "Invalid argument index");
156 return MemoryLocation(
157 Arg,
158 LocationSize::precise(
159 cast<ConstantInt>(II->getArgOperand(0))->getZExtValue()),
160 AATags);
161
162 case Intrinsic::invariant_end:
163 // The first argument to an invariant.end is a "descriptor" type (e.g. a
164 // pointer to a empty struct) which is never actually dereferenced.
165 if (ArgIdx == 0)
166 return MemoryLocation(Arg, LocationSize::precise(0), AATags);
167 assert(ArgIdx == 2 && "Invalid argument index");
168 return MemoryLocation(
169 Arg,
170 LocationSize::precise(
171 cast<ConstantInt>(II->getArgOperand(1))->getZExtValue()),
172 AATags);
173
174 case Intrinsic::arm_neon_vld1:
175 assert(ArgIdx == 0 && "Invalid argument index");
176 // LLVM's vld1 and vst1 intrinsics currently only support a single
177 // vector register.
178 return MemoryLocation(
179 Arg, LocationSize::precise(DL.getTypeStoreSize(II->getType())),
180 AATags);
181
182 case Intrinsic::arm_neon_vst1:
183 assert(ArgIdx == 0 && "Invalid argument index");
184 return MemoryLocation(Arg,
185 LocationSize::precise(DL.getTypeStoreSize(
186 II->getArgOperand(1)->getType())),
187 AATags);
188 }
189 }
190
191 // We can bound the aliasing properties of memset_pattern16 just as we can
192 // for memcpy/memset. This is particularly important because the
193 // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
194 // whenever possible.
195 LibFunc F;
196 if (TLI && Call->getCalledFunction() &&
197 TLI->getLibFunc(*Call->getCalledFunction(), F) &&
198 F == LibFunc_memset_pattern16 && TLI->has(F)) {
199 assert((ArgIdx == 0 || ArgIdx == 1) &&
200 "Invalid argument index for memset_pattern16");
201 if (ArgIdx == 1)
202 return MemoryLocation(Arg, LocationSize::precise(16), AATags);
203 if (const ConstantInt *LenCI =
204 dyn_cast<ConstantInt>(Call->getArgOperand(2)))
205 return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
206 AATags);
207 }
208 // FIXME: Handle memset_pattern4 and memset_pattern8 also.
209
210 return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(),
211 AATags);
212 }
213