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