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