1 //===- NVPTXLowerAggrCopies.cpp - ------------------------------*- C++ -*--===//
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 // Lower aggregate copies, memset, memcpy, memmov intrinsics into loops when
10 // the size is large or is not a compile-time constant.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "NVPTXLowerAggrCopies.h"
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/DataLayout.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/IRBuilder.h"
19 #include "llvm/IR/Instructions.h"
20 #include "llvm/IR/IntrinsicInst.h"
21 #include "llvm/IR/Intrinsics.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/Support/InstIterator.h"
25
26 using namespace llvm;
27
28 namespace llvm {
29 FunctionPass *createLowerAggrCopies();
30 }
31
32 char NVPTXLowerAggrCopies::ID = 0;
33
34 // Lower MemTransferInst or load-store pair to loop
convertTransferToLoop(Instruction * splitAt,Value * srcAddr,Value * dstAddr,Value * len,bool srcVolatile,bool dstVolatile,LLVMContext & Context,Function & F)35 static void convertTransferToLoop(Instruction *splitAt, Value *srcAddr,
36 Value *dstAddr, Value *len,
37 //unsigned numLoads,
38 bool srcVolatile, bool dstVolatile,
39 LLVMContext &Context, Function &F) {
40 Type *indType = len->getType();
41
42 BasicBlock *origBB = splitAt->getParent();
43 BasicBlock *newBB = splitAt->getParent()->splitBasicBlock(splitAt, "split");
44 BasicBlock *loopBB = BasicBlock::Create(Context, "loadstoreloop", &F, newBB);
45
46 origBB->getTerminator()->setSuccessor(0, loopBB);
47 IRBuilder<> builder(origBB, origBB->getTerminator());
48
49 // srcAddr and dstAddr are expected to be pointer types,
50 // so no check is made here.
51 unsigned srcAS =
52 dyn_cast<PointerType>(srcAddr->getType())->getAddressSpace();
53 unsigned dstAS =
54 dyn_cast<PointerType>(dstAddr->getType())->getAddressSpace();
55
56 // Cast pointers to (char *)
57 srcAddr = builder.CreateBitCast(srcAddr, Type::getInt8PtrTy(Context, srcAS));
58 dstAddr = builder.CreateBitCast(dstAddr, Type::getInt8PtrTy(Context, dstAS));
59
60 IRBuilder<> loop(loopBB);
61 // The loop index (ind) is a phi node.
62 PHINode *ind = loop.CreatePHI(indType, 0);
63 // Incoming value for ind is 0
64 ind->addIncoming(ConstantInt::get(indType, 0), origBB);
65
66 // load from srcAddr+ind
67 Value *val = loop.CreateLoad(loop.CreateGEP(srcAddr, ind), srcVolatile);
68 // store at dstAddr+ind
69 loop.CreateStore(val, loop.CreateGEP(dstAddr, ind), dstVolatile);
70
71 // The value for ind coming from backedge is (ind + 1)
72 Value *newind = loop.CreateAdd(ind, ConstantInt::get(indType, 1));
73 ind->addIncoming(newind, loopBB);
74
75 loop.CreateCondBr(loop.CreateICmpULT(newind, len), loopBB, newBB);
76 }
77
78 // Lower MemSetInst to loop
convertMemSetToLoop(Instruction * splitAt,Value * dstAddr,Value * len,Value * val,LLVMContext & Context,Function & F)79 static void convertMemSetToLoop(Instruction *splitAt, Value *dstAddr,
80 Value *len, Value *val, LLVMContext &Context,
81 Function &F) {
82 BasicBlock *origBB = splitAt->getParent();
83 BasicBlock *newBB = splitAt->getParent()->splitBasicBlock(splitAt, "split");
84 BasicBlock *loopBB = BasicBlock::Create(Context, "loadstoreloop", &F, newBB);
85
86 origBB->getTerminator()->setSuccessor(0, loopBB);
87 IRBuilder<> builder(origBB, origBB->getTerminator());
88
89 unsigned dstAS =
90 dyn_cast<PointerType>(dstAddr->getType())->getAddressSpace();
91
92 // Cast pointer to the type of value getting stored
93 dstAddr = builder.CreateBitCast(dstAddr,
94 PointerType::get(val->getType(), dstAS));
95
96 IRBuilder<> loop(loopBB);
97 PHINode *ind = loop.CreatePHI(len->getType(), 0);
98 ind->addIncoming(ConstantInt::get(len->getType(), 0), origBB);
99
100 loop.CreateStore(val, loop.CreateGEP(dstAddr, ind), false);
101
102 Value *newind = loop.CreateAdd(ind, ConstantInt::get(len->getType(), 1));
103 ind->addIncoming(newind, loopBB);
104
105 loop.CreateCondBr(loop.CreateICmpULT(newind, len), loopBB, newBB);
106 }
107
runOnFunction(Function & F)108 bool NVPTXLowerAggrCopies::runOnFunction(Function &F) {
109 SmallVector<LoadInst *, 4> aggrLoads;
110 SmallVector<MemTransferInst *, 4> aggrMemcpys;
111 SmallVector<MemSetInst *, 4> aggrMemsets;
112
113 DataLayout *TD = &getAnalysis<DataLayout>();
114 LLVMContext &Context = F.getParent()->getContext();
115
116 //
117 // Collect all the aggrLoads, aggrMemcpys and addrMemsets.
118 //
119 //const BasicBlock *firstBB = &F.front(); // first BB in F
120 for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
121 //BasicBlock *bb = BI;
122 for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE;
123 ++II) {
124 if (LoadInst * load = dyn_cast<LoadInst>(II)) {
125
126 if (load->hasOneUse() == false) continue;
127
128 if (TD->getTypeStoreSize(load->getType()) < MaxAggrCopySize) continue;
129
130 User *use = *(load->use_begin());
131 if (StoreInst * store = dyn_cast<StoreInst>(use)) {
132 if (store->getOperand(0) != load) //getValueOperand
133 continue;
134 aggrLoads.push_back(load);
135 }
136 } else if (MemTransferInst * intr = dyn_cast<MemTransferInst>(II)) {
137 Value *len = intr->getLength();
138 // If the number of elements being copied is greater
139 // than MaxAggrCopySize, lower it to a loop
140 if (ConstantInt * len_int = dyn_cast < ConstantInt > (len)) {
141 if (len_int->getZExtValue() >= MaxAggrCopySize) {
142 aggrMemcpys.push_back(intr);
143 }
144 } else {
145 // turn variable length memcpy/memmov into loop
146 aggrMemcpys.push_back(intr);
147 }
148 } else if (MemSetInst * memsetintr = dyn_cast<MemSetInst>(II)) {
149 Value *len = memsetintr->getLength();
150 if (ConstantInt * len_int = dyn_cast<ConstantInt>(len)) {
151 if (len_int->getZExtValue() >= MaxAggrCopySize) {
152 aggrMemsets.push_back(memsetintr);
153 }
154 } else {
155 // turn variable length memset into loop
156 aggrMemsets.push_back(memsetintr);
157 }
158 }
159 }
160 }
161 if ((aggrLoads.size() == 0) && (aggrMemcpys.size() == 0)
162 && (aggrMemsets.size() == 0)) return false;
163
164 //
165 // Do the transformation of an aggr load/copy/set to a loop
166 //
167 for (unsigned i = 0, e = aggrLoads.size(); i != e; ++i) {
168 LoadInst *load = aggrLoads[i];
169 StoreInst *store = dyn_cast<StoreInst>(*load->use_begin());
170 Value *srcAddr = load->getOperand(0);
171 Value *dstAddr = store->getOperand(1);
172 unsigned numLoads = TD->getTypeStoreSize(load->getType());
173 Value *len = ConstantInt::get(Type::getInt32Ty(Context), numLoads);
174
175 convertTransferToLoop(store, srcAddr, dstAddr, len, load->isVolatile(),
176 store->isVolatile(), Context, F);
177
178 store->eraseFromParent();
179 load->eraseFromParent();
180 }
181
182 for (unsigned i = 0, e = aggrMemcpys.size(); i != e; ++i) {
183 MemTransferInst *cpy = aggrMemcpys[i];
184 Value *len = cpy->getLength();
185 // llvm 2.7 version of memcpy does not have volatile
186 // operand yet. So always making it non-volatile
187 // optimistically, so that we don't see unnecessary
188 // st.volatile in ptx
189 convertTransferToLoop(cpy, cpy->getSource(), cpy->getDest(), len, false,
190 false, Context, F);
191 cpy->eraseFromParent();
192 }
193
194 for (unsigned i = 0, e = aggrMemsets.size(); i != e; ++i) {
195 MemSetInst *memsetinst = aggrMemsets[i];
196 Value *len = memsetinst->getLength();
197 Value *val = memsetinst->getValue();
198 convertMemSetToLoop(memsetinst, memsetinst->getDest(), len, val, Context,
199 F);
200 memsetinst->eraseFromParent();
201 }
202
203 return true;
204 }
205
createLowerAggrCopies()206 FunctionPass *llvm::createLowerAggrCopies() {
207 return new NVPTXLowerAggrCopies();
208 }
209