1 /*
2 * Copyright 2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "bcc/Assert.h"
18 #include "bcc/Renderscript/RSTransforms.h"
19
20 #include <cstdlib>
21
22 #include <llvm/DerivedTypes.h>
23 #include <llvm/Function.h>
24 #include <llvm/Instructions.h>
25 #include <llvm/IRBuilder.h>
26 #include <llvm/Module.h>
27 #include <llvm/Pass.h>
28 #include <llvm/Support/raw_ostream.h>
29 #include <llvm/Target/TargetData.h>
30 #include <llvm/Type.h>
31
32 #include "bcc/Config/Config.h"
33 #include "bcc/Renderscript/RSInfo.h"
34 #include "bcc/Support/Log.h"
35
36 using namespace bcc;
37
38 namespace {
39
40 /* RSForEachExpandPass - This pass operates on functions that are able to be
41 * called via rsForEach() or "foreach_<NAME>". We create an inner loop for the
42 * ForEach-able function to be invoked over the appropriate data cells of the
43 * input/output allocations (adjusting other relevant parameters as we go). We
44 * support doing this for any ForEach-able compute kernels. The new function
45 * name is the original function name followed by ".expand". Note that we
46 * still generate code for the original function.
47 */
48 class RSForEachExpandPass : public llvm::ModulePass {
49 private:
50 static char ID;
51
52 llvm::Module *M;
53 llvm::LLVMContext *C;
54
55 const RSInfo::ExportForeachFuncListTy &mFuncs;
56
57 // Turns on optimization of allocation stride values.
58 bool mEnableStepOpt;
59
getRootSignature(llvm::Function * F)60 uint32_t getRootSignature(llvm::Function *F) {
61 const llvm::NamedMDNode *ExportForEachMetadata =
62 M->getNamedMetadata("#rs_export_foreach");
63
64 if (!ExportForEachMetadata) {
65 llvm::SmallVector<llvm::Type*, 8> RootArgTys;
66 for (llvm::Function::arg_iterator B = F->arg_begin(),
67 E = F->arg_end();
68 B != E;
69 ++B) {
70 RootArgTys.push_back(B->getType());
71 }
72
73 // For pre-ICS bitcode, we may not have signature information. In that
74 // case, we use the size of the RootArgTys to select the number of
75 // arguments.
76 return (1 << RootArgTys.size()) - 1;
77 }
78
79 if (ExportForEachMetadata->getNumOperands() == 0) {
80 return 0;
81 }
82
83 bccAssert(ExportForEachMetadata->getNumOperands() > 0);
84
85 // We only handle the case for legacy root() functions here, so this is
86 // hard-coded to look at only the first such function.
87 llvm::MDNode *SigNode = ExportForEachMetadata->getOperand(0);
88 if (SigNode != NULL && SigNode->getNumOperands() == 1) {
89 llvm::Value *SigVal = SigNode->getOperand(0);
90 if (SigVal->getValueID() == llvm::Value::MDStringVal) {
91 llvm::StringRef SigString =
92 static_cast<llvm::MDString*>(SigVal)->getString();
93 uint32_t Signature = 0;
94 if (SigString.getAsInteger(10, Signature)) {
95 ALOGE("Non-integer signature value '%s'", SigString.str().c_str());
96 return 0;
97 }
98 return Signature;
99 }
100 }
101
102 return 0;
103 }
104
105 // Get the actual value we should use to step through an allocation.
106 // TD - Target Data size/layout information.
107 // T - Type of allocation (should be a pointer).
108 // OrigStep - Original step increment (root.expand() input from driver).
getStepValue(llvm::TargetData * TD,llvm::Type * T,llvm::Value * OrigStep)109 llvm::Value *getStepValue(llvm::TargetData *TD, llvm::Type *T,
110 llvm::Value *OrigStep) {
111 bccAssert(TD);
112 bccAssert(T);
113 bccAssert(OrigStep);
114 llvm::PointerType *PT = llvm::dyn_cast<llvm::PointerType>(T);
115 llvm::Type *VoidPtrTy = llvm::Type::getInt8PtrTy(*C);
116 if (mEnableStepOpt && T != VoidPtrTy && PT) {
117 llvm::Type *ET = PT->getElementType();
118 uint64_t ETSize = TD->getTypeAllocSize(ET);
119 llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*C);
120 return llvm::ConstantInt::get(Int32Ty, ETSize);
121 } else {
122 return OrigStep;
123 }
124 }
125
hasIn(uint32_t Signature)126 static bool hasIn(uint32_t Signature) {
127 return Signature & 0x01;
128 }
129
hasOut(uint32_t Signature)130 static bool hasOut(uint32_t Signature) {
131 return Signature & 0x02;
132 }
133
hasUsrData(uint32_t Signature)134 static bool hasUsrData(uint32_t Signature) {
135 return Signature & 0x04;
136 }
137
hasX(uint32_t Signature)138 static bool hasX(uint32_t Signature) {
139 return Signature & 0x08;
140 }
141
hasY(uint32_t Signature)142 static bool hasY(uint32_t Signature) {
143 return Signature & 0x10;
144 }
145
isKernel(uint32_t Signature)146 static bool isKernel(uint32_t Signature) {
147 return Signature & 0x20;
148 }
149
150
151 public:
RSForEachExpandPass(const RSInfo::ExportForeachFuncListTy & pForeachFuncs,bool pEnableStepOpt)152 RSForEachExpandPass(const RSInfo::ExportForeachFuncListTy &pForeachFuncs,
153 bool pEnableStepOpt)
154 : ModulePass(ID), M(NULL), C(NULL), mFuncs(pForeachFuncs),
155 mEnableStepOpt(pEnableStepOpt) {
156 }
157
158 /* Performs the actual optimization on a selected function. On success, the
159 * Module will contain a new function of the name "<NAME>.expand" that
160 * invokes <NAME>() in a loop with the appropriate parameters.
161 */
ExpandFunction(llvm::Function * F,uint32_t Signature)162 bool ExpandFunction(llvm::Function *F, uint32_t Signature) {
163 ALOGV("Expanding ForEach-able Function %s", F->getName().str().c_str());
164
165 if (!Signature) {
166 Signature = getRootSignature(F);
167 if (!Signature) {
168 // We couldn't determine how to expand this function based on its
169 // function signature.
170 return false;
171 }
172 }
173
174 llvm::TargetData TD(M);
175
176 llvm::Type *VoidPtrTy = llvm::Type::getInt8PtrTy(*C);
177 llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*C);
178 llvm::Type *SizeTy = Int32Ty;
179
180 /* Defined in frameworks/base/libs/rs/rs_hal.h:
181 *
182 * struct RsForEachStubParamStruct {
183 * const void *in;
184 * void *out;
185 * const void *usr;
186 * size_t usr_len;
187 * uint32_t x;
188 * uint32_t y;
189 * uint32_t z;
190 * uint32_t lod;
191 * enum RsAllocationCubemapFace face;
192 * uint32_t ar[16];
193 * };
194 */
195 llvm::SmallVector<llvm::Type*, 9> StructTys;
196 StructTys.push_back(VoidPtrTy); // const void *in
197 StructTys.push_back(VoidPtrTy); // void *out
198 StructTys.push_back(VoidPtrTy); // const void *usr
199 StructTys.push_back(SizeTy); // size_t usr_len
200 StructTys.push_back(Int32Ty); // uint32_t x
201 StructTys.push_back(Int32Ty); // uint32_t y
202 StructTys.push_back(Int32Ty); // uint32_t z
203 StructTys.push_back(Int32Ty); // uint32_t lod
204 StructTys.push_back(Int32Ty); // enum RsAllocationCubemapFace
205 StructTys.push_back(llvm::ArrayType::get(Int32Ty, 16)); // uint32_t ar[16]
206
207 llvm::Type *ForEachStubPtrTy = llvm::StructType::create(
208 StructTys, "RsForEachStubParamStruct")->getPointerTo();
209
210 /* Create the function signature for our expanded function.
211 * void (const RsForEachStubParamStruct *p, uint32_t x1, uint32_t x2,
212 * uint32_t instep, uint32_t outstep)
213 */
214 llvm::SmallVector<llvm::Type*, 8> ParamTys;
215 ParamTys.push_back(ForEachStubPtrTy); // const RsForEachStubParamStruct *p
216 ParamTys.push_back(Int32Ty); // uint32_t x1
217 ParamTys.push_back(Int32Ty); // uint32_t x2
218 ParamTys.push_back(Int32Ty); // uint32_t instep
219 ParamTys.push_back(Int32Ty); // uint32_t outstep
220
221 llvm::FunctionType *FT =
222 llvm::FunctionType::get(llvm::Type::getVoidTy(*C), ParamTys, false);
223 llvm::Function *ExpandedFunc =
224 llvm::Function::Create(FT,
225 llvm::GlobalValue::ExternalLinkage,
226 F->getName() + ".expand", M);
227
228 // Create and name the actual arguments to this expanded function.
229 llvm::SmallVector<llvm::Argument*, 8> ArgVec;
230 for (llvm::Function::arg_iterator B = ExpandedFunc->arg_begin(),
231 E = ExpandedFunc->arg_end();
232 B != E;
233 ++B) {
234 ArgVec.push_back(B);
235 }
236
237 if (ArgVec.size() != 5) {
238 ALOGE("Incorrect number of arguments to function: %zu",
239 ArgVec.size());
240 return false;
241 }
242 llvm::Value *Arg_p = ArgVec[0];
243 llvm::Value *Arg_x1 = ArgVec[1];
244 llvm::Value *Arg_x2 = ArgVec[2];
245 llvm::Value *Arg_instep = ArgVec[3];
246 llvm::Value *Arg_outstep = ArgVec[4];
247
248 Arg_p->setName("p");
249 Arg_x1->setName("x1");
250 Arg_x2->setName("x2");
251 Arg_instep->setName("arg_instep");
252 Arg_outstep->setName("arg_outstep");
253
254 llvm::Value *InStep = NULL;
255 llvm::Value *OutStep = NULL;
256
257 // Construct the actual function body.
258 llvm::BasicBlock *Begin =
259 llvm::BasicBlock::Create(*C, "Begin", ExpandedFunc);
260 llvm::IRBuilder<> Builder(Begin);
261
262 // uint32_t X = x1;
263 llvm::AllocaInst *AX = Builder.CreateAlloca(Int32Ty, 0, "AX");
264 Builder.CreateStore(Arg_x1, AX);
265
266 // Collect and construct the arguments for the kernel().
267 // Note that we load any loop-invariant arguments before entering the Loop.
268 llvm::Function::arg_iterator Args = F->arg_begin();
269
270 llvm::Type *InTy = NULL;
271 llvm::AllocaInst *AIn = NULL;
272 if (hasIn(Signature)) {
273 InTy = Args->getType();
274 AIn = Builder.CreateAlloca(InTy, 0, "AIn");
275 InStep = getStepValue(&TD, InTy, Arg_instep);
276 InStep->setName("instep");
277 Builder.CreateStore(Builder.CreatePointerCast(Builder.CreateLoad(
278 Builder.CreateStructGEP(Arg_p, 0)), InTy), AIn);
279 Args++;
280 }
281
282 llvm::Type *OutTy = NULL;
283 llvm::AllocaInst *AOut = NULL;
284 if (hasOut(Signature)) {
285 OutTy = Args->getType();
286 AOut = Builder.CreateAlloca(OutTy, 0, "AOut");
287 OutStep = getStepValue(&TD, OutTy, Arg_outstep);
288 OutStep->setName("outstep");
289 Builder.CreateStore(Builder.CreatePointerCast(Builder.CreateLoad(
290 Builder.CreateStructGEP(Arg_p, 1)), OutTy), AOut);
291 Args++;
292 }
293
294 llvm::Value *UsrData = NULL;
295 if (hasUsrData(Signature)) {
296 llvm::Type *UsrDataTy = Args->getType();
297 UsrData = Builder.CreatePointerCast(Builder.CreateLoad(
298 Builder.CreateStructGEP(Arg_p, 2)), UsrDataTy);
299 UsrData->setName("UsrData");
300 Args++;
301 }
302
303 if (hasX(Signature)) {
304 Args++;
305 }
306
307 llvm::Value *Y = NULL;
308 if (hasY(Signature)) {
309 Y = Builder.CreateLoad(Builder.CreateStructGEP(Arg_p, 5), "Y");
310 Args++;
311 }
312
313 bccAssert(Args == F->arg_end());
314
315 llvm::BasicBlock *Loop = llvm::BasicBlock::Create(*C, "Loop", ExpandedFunc);
316 llvm::BasicBlock *Exit = llvm::BasicBlock::Create(*C, "Exit", ExpandedFunc);
317
318 // if (x1 < x2) goto Loop; else goto Exit;
319 llvm::Value *Cond = Builder.CreateICmpSLT(Arg_x1, Arg_x2);
320 Builder.CreateCondBr(Cond, Loop, Exit);
321
322 // Loop:
323 Builder.SetInsertPoint(Loop);
324
325 // Populate the actual call to kernel().
326 llvm::SmallVector<llvm::Value*, 8> RootArgs;
327
328 llvm::Value *InPtr = NULL;
329 llvm::Value *OutPtr = NULL;
330
331 if (AIn) {
332 InPtr = Builder.CreateLoad(AIn, "InPtr");
333 RootArgs.push_back(InPtr);
334 }
335
336 if (AOut) {
337 OutPtr = Builder.CreateLoad(AOut, "OutPtr");
338 RootArgs.push_back(OutPtr);
339 }
340
341 if (UsrData) {
342 RootArgs.push_back(UsrData);
343 }
344
345 // We always have to load X, since it is used to iterate through the loop.
346 llvm::Value *X = Builder.CreateLoad(AX, "X");
347 if (hasX(Signature)) {
348 RootArgs.push_back(X);
349 }
350
351 if (Y) {
352 RootArgs.push_back(Y);
353 }
354
355 Builder.CreateCall(F, RootArgs);
356
357 if (InPtr) {
358 // InPtr += instep
359 llvm::Value *NewIn = Builder.CreateIntToPtr(Builder.CreateNUWAdd(
360 Builder.CreatePtrToInt(InPtr, Int32Ty), InStep), InTy);
361 Builder.CreateStore(NewIn, AIn);
362 }
363
364 if (OutPtr) {
365 // OutPtr += outstep
366 llvm::Value *NewOut = Builder.CreateIntToPtr(Builder.CreateNUWAdd(
367 Builder.CreatePtrToInt(OutPtr, Int32Ty), OutStep), OutTy);
368 Builder.CreateStore(NewOut, AOut);
369 }
370
371 // X++;
372 llvm::Value *XPlusOne =
373 Builder.CreateNUWAdd(X, llvm::ConstantInt::get(Int32Ty, 1));
374 Builder.CreateStore(XPlusOne, AX);
375
376 // If (X < x2) goto Loop; else goto Exit;
377 Cond = Builder.CreateICmpSLT(XPlusOne, Arg_x2);
378 Builder.CreateCondBr(Cond, Loop, Exit);
379
380 // Exit:
381 Builder.SetInsertPoint(Exit);
382 Builder.CreateRetVoid();
383
384 return true;
385 }
386
387 /* Expand a pass-by-value kernel.
388 */
ExpandKernel(llvm::Function * F,uint32_t Signature)389 bool ExpandKernel(llvm::Function *F, uint32_t Signature) {
390 bccAssert(isKernel(Signature));
391 ALOGV("Expanding kernel Function %s", F->getName().str().c_str());
392
393 // TODO: Refactor this to share functionality with ExpandFunction.
394 llvm::TargetData TD(M);
395
396 llvm::Type *VoidPtrTy = llvm::Type::getInt8PtrTy(*C);
397 llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*C);
398 llvm::Type *SizeTy = Int32Ty;
399
400 /* Defined in frameworks/base/libs/rs/rs_hal.h:
401 *
402 * struct RsForEachStubParamStruct {
403 * const void *in;
404 * void *out;
405 * const void *usr;
406 * size_t usr_len;
407 * uint32_t x;
408 * uint32_t y;
409 * uint32_t z;
410 * uint32_t lod;
411 * enum RsAllocationCubemapFace face;
412 * uint32_t ar[16];
413 * };
414 */
415 llvm::SmallVector<llvm::Type*, 9> StructTys;
416 StructTys.push_back(VoidPtrTy); // const void *in
417 StructTys.push_back(VoidPtrTy); // void *out
418 StructTys.push_back(VoidPtrTy); // const void *usr
419 StructTys.push_back(SizeTy); // size_t usr_len
420 StructTys.push_back(Int32Ty); // uint32_t x
421 StructTys.push_back(Int32Ty); // uint32_t y
422 StructTys.push_back(Int32Ty); // uint32_t z
423 StructTys.push_back(Int32Ty); // uint32_t lod
424 StructTys.push_back(Int32Ty); // enum RsAllocationCubemapFace
425 StructTys.push_back(llvm::ArrayType::get(Int32Ty, 16)); // uint32_t ar[16]
426
427 llvm::Type *ForEachStubPtrTy = llvm::StructType::create(
428 StructTys, "RsForEachStubParamStruct")->getPointerTo();
429
430 /* Create the function signature for our expanded function.
431 * void (const RsForEachStubParamStruct *p, uint32_t x1, uint32_t x2,
432 * uint32_t instep, uint32_t outstep)
433 */
434 llvm::SmallVector<llvm::Type*, 8> ParamTys;
435 ParamTys.push_back(ForEachStubPtrTy); // const RsForEachStubParamStruct *p
436 ParamTys.push_back(Int32Ty); // uint32_t x1
437 ParamTys.push_back(Int32Ty); // uint32_t x2
438 ParamTys.push_back(Int32Ty); // uint32_t instep
439 ParamTys.push_back(Int32Ty); // uint32_t outstep
440
441 llvm::FunctionType *FT =
442 llvm::FunctionType::get(llvm::Type::getVoidTy(*C), ParamTys, false);
443 llvm::Function *ExpandedFunc =
444 llvm::Function::Create(FT,
445 llvm::GlobalValue::ExternalLinkage,
446 F->getName() + ".expand", M);
447
448 // Create and name the actual arguments to this expanded function.
449 llvm::SmallVector<llvm::Argument*, 8> ArgVec;
450 for (llvm::Function::arg_iterator B = ExpandedFunc->arg_begin(),
451 E = ExpandedFunc->arg_end();
452 B != E;
453 ++B) {
454 ArgVec.push_back(B);
455 }
456
457 if (ArgVec.size() != 5) {
458 ALOGE("Incorrect number of arguments to function: %zu",
459 ArgVec.size());
460 return false;
461 }
462 llvm::Value *Arg_p = ArgVec[0];
463 llvm::Value *Arg_x1 = ArgVec[1];
464 llvm::Value *Arg_x2 = ArgVec[2];
465 llvm::Value *Arg_instep = ArgVec[3];
466 llvm::Value *Arg_outstep = ArgVec[4];
467
468 Arg_p->setName("p");
469 Arg_x1->setName("x1");
470 Arg_x2->setName("x2");
471 Arg_instep->setName("arg_instep");
472 Arg_outstep->setName("arg_outstep");
473
474 llvm::Value *InStep = NULL;
475 llvm::Value *OutStep = NULL;
476
477 // Construct the actual function body.
478 llvm::BasicBlock *Begin =
479 llvm::BasicBlock::Create(*C, "Begin", ExpandedFunc);
480 llvm::IRBuilder<> Builder(Begin);
481
482 // uint32_t X = x1;
483 llvm::AllocaInst *AX = Builder.CreateAlloca(Int32Ty, 0, "AX");
484 Builder.CreateStore(Arg_x1, AX);
485
486 // Collect and construct the arguments for the kernel().
487 // Note that we load any loop-invariant arguments before entering the Loop.
488 llvm::Function::arg_iterator Args = F->arg_begin();
489
490 llvm::Type *OutTy = NULL;
491 llvm::AllocaInst *AOut = NULL;
492 bool PassOutByReference = false;
493 if (hasOut(Signature)) {
494 llvm::Type *OutBaseTy = F->getReturnType();
495 if (OutBaseTy->isVoidTy()) {
496 PassOutByReference = true;
497 OutTy = Args->getType();
498 Args++;
499 } else {
500 OutTy = OutBaseTy->getPointerTo();
501 // We don't increment Args, since we are using the actual return type.
502 }
503 AOut = Builder.CreateAlloca(OutTy, 0, "AOut");
504 OutStep = getStepValue(&TD, OutTy, Arg_outstep);
505 OutStep->setName("outstep");
506 Builder.CreateStore(Builder.CreatePointerCast(Builder.CreateLoad(
507 Builder.CreateStructGEP(Arg_p, 1)), OutTy), AOut);
508 }
509
510 llvm::Type *InBaseTy = NULL;
511 llvm::Type *InTy = NULL;
512 llvm::AllocaInst *AIn = NULL;
513 if (hasIn(Signature)) {
514 InBaseTy = Args->getType();
515 InTy =InBaseTy->getPointerTo();
516 AIn = Builder.CreateAlloca(InTy, 0, "AIn");
517 InStep = getStepValue(&TD, InTy, Arg_instep);
518 InStep->setName("instep");
519 Builder.CreateStore(Builder.CreatePointerCast(Builder.CreateLoad(
520 Builder.CreateStructGEP(Arg_p, 0)), InTy), AIn);
521 Args++;
522 }
523
524 // No usrData parameter on kernels.
525 bccAssert(!hasUsrData(Signature));
526
527 if (hasX(Signature)) {
528 Args++;
529 }
530
531 llvm::Value *Y = NULL;
532 if (hasY(Signature)) {
533 Y = Builder.CreateLoad(Builder.CreateStructGEP(Arg_p, 5), "Y");
534 Args++;
535 }
536
537 bccAssert(Args == F->arg_end());
538
539 llvm::BasicBlock *Loop = llvm::BasicBlock::Create(*C, "Loop", ExpandedFunc);
540 llvm::BasicBlock *Exit = llvm::BasicBlock::Create(*C, "Exit", ExpandedFunc);
541
542 // if (x1 < x2) goto Loop; else goto Exit;
543 llvm::Value *Cond = Builder.CreateICmpSLT(Arg_x1, Arg_x2);
544 Builder.CreateCondBr(Cond, Loop, Exit);
545
546 // Loop:
547 Builder.SetInsertPoint(Loop);
548
549 // Populate the actual call to kernel().
550 llvm::SmallVector<llvm::Value*, 8> RootArgs;
551
552 llvm::Value *InPtr = NULL;
553 llvm::Value *In = NULL;
554 llvm::Value *OutPtr = NULL;
555
556 if (PassOutByReference) {
557 OutPtr = Builder.CreateLoad(AOut, "OutPtr");
558 RootArgs.push_back(OutPtr);
559 }
560
561 if (AIn) {
562 InPtr = Builder.CreateLoad(AIn, "InPtr");
563 In = Builder.CreateLoad(InPtr, "In");
564 RootArgs.push_back(In);
565 }
566
567 // We always have to load X, since it is used to iterate through the loop.
568 llvm::Value *X = Builder.CreateLoad(AX, "X");
569 if (hasX(Signature)) {
570 RootArgs.push_back(X);
571 }
572
573 if (Y) {
574 RootArgs.push_back(Y);
575 }
576
577 llvm::Value *RetVal = Builder.CreateCall(F, RootArgs);
578
579 if (AOut && !PassOutByReference) {
580 OutPtr = Builder.CreateLoad(AOut, "OutPtr");
581 Builder.CreateStore(RetVal, OutPtr);
582 }
583
584 if (InPtr) {
585 // InPtr += instep
586 llvm::Value *NewIn = Builder.CreateIntToPtr(Builder.CreateNUWAdd(
587 Builder.CreatePtrToInt(InPtr, Int32Ty), InStep), InTy);
588 Builder.CreateStore(NewIn, AIn);
589 }
590
591 if (OutPtr) {
592 // OutPtr += outstep
593 llvm::Value *NewOut = Builder.CreateIntToPtr(Builder.CreateNUWAdd(
594 Builder.CreatePtrToInt(OutPtr, Int32Ty), OutStep), OutTy);
595 Builder.CreateStore(NewOut, AOut);
596 }
597
598 // X++;
599 llvm::Value *XPlusOne =
600 Builder.CreateNUWAdd(X, llvm::ConstantInt::get(Int32Ty, 1));
601 Builder.CreateStore(XPlusOne, AX);
602
603 // If (X < x2) goto Loop; else goto Exit;
604 Cond = Builder.CreateICmpSLT(XPlusOne, Arg_x2);
605 Builder.CreateCondBr(Cond, Loop, Exit);
606
607 // Exit:
608 Builder.SetInsertPoint(Exit);
609 Builder.CreateRetVoid();
610
611 return true;
612 }
613
runOnModule(llvm::Module & M)614 virtual bool runOnModule(llvm::Module &M) {
615 bool Changed = false;
616 this->M = &M;
617 C = &M.getContext();
618
619 for (RSInfo::ExportForeachFuncListTy::const_iterator
620 func_iter = mFuncs.begin(), func_end = mFuncs.end();
621 func_iter != func_end; func_iter++) {
622 const char *name = func_iter->first;
623 uint32_t signature = func_iter->second;
624 llvm::Function *kernel = M.getFunction(name);
625 if (kernel && isKernel(signature)) {
626 Changed |= ExpandKernel(kernel, signature);
627 }
628 else if (kernel && kernel->getReturnType()->isVoidTy()) {
629 Changed |= ExpandFunction(kernel, signature);
630 }
631 }
632
633 return Changed;
634 }
635
getPassName() const636 virtual const char *getPassName() const {
637 return "ForEach-able Function Expansion";
638 }
639
640 }; // end RSForEachExpandPass
641
642 } // end anonymous namespace
643
644 char RSForEachExpandPass::ID = 0;
645
646 namespace bcc {
647
648 llvm::ModulePass *
createRSForEachExpandPass(const RSInfo::ExportForeachFuncListTy & pForeachFuncs,bool pEnableStepOpt)649 createRSForEachExpandPass(const RSInfo::ExportForeachFuncListTy &pForeachFuncs,
650 bool pEnableStepOpt){
651 return new RSForEachExpandPass(pForeachFuncs, pEnableStepOpt);
652 }
653
654 } // end namespace bcc
655