1 //===- MemoryLocation.cpp - Memory location descriptions -------------------==//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/Analysis/MemoryLocation.h"
11 #include "llvm/Analysis/TargetLibraryInfo.h"
12 #include "llvm/IR/BasicBlock.h"
13 #include "llvm/IR/DataLayout.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/IntrinsicInst.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 MemoryLocation MemoryLocation::get(const LoadInst *LI) {
22   AAMDNodes AATags;
23   LI->getAAMetadata(AATags);
24   const auto &DL = LI->getModule()->getDataLayout();
25 
26   return MemoryLocation(LI->getPointerOperand(),
27                         DL.getTypeStoreSize(LI->getType()), AATags);
28 }
29 
30 MemoryLocation MemoryLocation::get(const StoreInst *SI) {
31   AAMDNodes AATags;
32   SI->getAAMetadata(AATags);
33   const auto &DL = SI->getModule()->getDataLayout();
34 
35   return MemoryLocation(SI->getPointerOperand(),
36                         DL.getTypeStoreSize(SI->getValueOperand()->getType()),
37                         AATags);
38 }
39 
40 MemoryLocation MemoryLocation::get(const VAArgInst *VI) {
41   AAMDNodes AATags;
42   VI->getAAMetadata(AATags);
43 
44   return MemoryLocation(VI->getPointerOperand(), UnknownSize, AATags);
45 }
46 
47 MemoryLocation MemoryLocation::get(const AtomicCmpXchgInst *CXI) {
48   AAMDNodes AATags;
49   CXI->getAAMetadata(AATags);
50   const auto &DL = CXI->getModule()->getDataLayout();
51 
52   return MemoryLocation(
53       CXI->getPointerOperand(),
54       DL.getTypeStoreSize(CXI->getCompareOperand()->getType()), AATags);
55 }
56 
57 MemoryLocation MemoryLocation::get(const AtomicRMWInst *RMWI) {
58   AAMDNodes AATags;
59   RMWI->getAAMetadata(AATags);
60   const auto &DL = RMWI->getModule()->getDataLayout();
61 
62   return MemoryLocation(RMWI->getPointerOperand(),
63                         DL.getTypeStoreSize(RMWI->getValOperand()->getType()),
64                         AATags);
65 }
66 
67 MemoryLocation MemoryLocation::getForSource(const MemTransferInst *MTI) {
68   return getForSource(cast<AnyMemTransferInst>(MTI));
69 }
70 
71 MemoryLocation MemoryLocation::getForSource(const AtomicMemTransferInst *MTI) {
72   return getForSource(cast<AnyMemTransferInst>(MTI));
73 }
74 
75 MemoryLocation MemoryLocation::getForSource(const AnyMemTransferInst *MTI) {
76   uint64_t Size = UnknownSize;
77   if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
78     Size = C->getValue().getZExtValue();
79 
80   // memcpy/memmove can have AA tags. For memcpy, they apply
81   // to both the source and the destination.
82   AAMDNodes AATags;
83   MTI->getAAMetadata(AATags);
84 
85   return MemoryLocation(MTI->getRawSource(), Size, AATags);
86 }
87 
88 MemoryLocation MemoryLocation::getForDest(const MemIntrinsic *MI) {
89   return getForDest(cast<AnyMemIntrinsic>(MI));
90 }
91 
92 MemoryLocation MemoryLocation::getForDest(const AtomicMemIntrinsic *MI) {
93   return getForDest(cast<AnyMemIntrinsic>(MI));
94 }
95 
96 MemoryLocation MemoryLocation::getForDest(const AnyMemIntrinsic *MI) {
97   uint64_t Size = UnknownSize;
98   if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
99     Size = C->getValue().getZExtValue();
100 
101   // memcpy/memmove can have AA tags. For memcpy, they apply
102   // to both the source and the destination.
103   AAMDNodes AATags;
104   MI->getAAMetadata(AATags);
105 
106   return MemoryLocation(MI->getRawDest(), Size, AATags);
107 }
108 
109 MemoryLocation MemoryLocation::getForArgument(ImmutableCallSite CS,
110                                               unsigned ArgIdx,
111                                               const TargetLibraryInfo *TLI) {
112   AAMDNodes AATags;
113   CS->getAAMetadata(AATags);
114   const Value *Arg = CS.getArgument(ArgIdx);
115 
116   // We may be able to produce an exact size for known intrinsics.
117   if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
118     const DataLayout &DL = II->getModule()->getDataLayout();
119 
120     switch (II->getIntrinsicID()) {
121     default:
122       break;
123     case Intrinsic::memset:
124     case Intrinsic::memcpy:
125     case Intrinsic::memmove:
126       assert((ArgIdx == 0 || ArgIdx == 1) &&
127              "Invalid argument index for memory intrinsic");
128       if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
129         return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
130       break;
131 
132     case Intrinsic::lifetime_start:
133     case Intrinsic::lifetime_end:
134     case Intrinsic::invariant_start:
135       assert(ArgIdx == 1 && "Invalid argument index");
136       return MemoryLocation(
137           Arg, cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AATags);
138 
139     case Intrinsic::invariant_end:
140       // The first argument to an invariant.end is a "descriptor" type (e.g. a
141       // pointer to a empty struct) which is never actually dereferenced.
142       if (ArgIdx == 0)
143         return MemoryLocation(Arg, 0, AATags);
144       assert(ArgIdx == 2 && "Invalid argument index");
145       return MemoryLocation(
146           Arg, cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AATags);
147 
148     case Intrinsic::arm_neon_vld1:
149       assert(ArgIdx == 0 && "Invalid argument index");
150       // LLVM's vld1 and vst1 intrinsics currently only support a single
151       // vector register.
152       return MemoryLocation(Arg, DL.getTypeStoreSize(II->getType()), AATags);
153 
154     case Intrinsic::arm_neon_vst1:
155       assert(ArgIdx == 0 && "Invalid argument index");
156       return MemoryLocation(
157           Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags);
158     }
159   }
160 
161   // We can bound the aliasing properties of memset_pattern16 just as we can
162   // for memcpy/memset.  This is particularly important because the
163   // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
164   // whenever possible.
165   LibFunc F;
166   if (TLI && CS.getCalledFunction() &&
167       TLI->getLibFunc(*CS.getCalledFunction(), F) &&
168       F == LibFunc_memset_pattern16 && TLI->has(F)) {
169     assert((ArgIdx == 0 || ArgIdx == 1) &&
170            "Invalid argument index for memset_pattern16");
171     if (ArgIdx == 1)
172       return MemoryLocation(Arg, 16, AATags);
173     if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2)))
174       return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
175   }
176   // FIXME: Handle memset_pattern4 and memset_pattern8 also.
177 
178   return MemoryLocation(CS.getArgument(ArgIdx), UnknownSize, AATags);
179 }
180