xref: /freebsd/contrib/llvm-project/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp (revision e6bfd18d21b225af6a0ed67ceeaf1293b7b9eba5)
1 //=== AMDGPUPrintfRuntimeBinding.cpp - OpenCL printf implementation -------===//
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 // \file
9 //
10 // The pass bind printfs to a kernel arg pointer that will be bound to a buffer
11 // later by the runtime.
12 //
13 // This pass traverses the functions in the module and converts
14 // each call to printf to a sequence of operations that
15 // store the following into the printf buffer:
16 // - format string (passed as a module's metadata unique ID)
17 // - bitwise copies of printf arguments
18 // The backend passes will need to store metadata in the kernel
19 //===----------------------------------------------------------------------===//
20 
21 #include "AMDGPU.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/Analysis/InstructionSimplify.h"
24 #include "llvm/Analysis/TargetLibraryInfo.h"
25 #include "llvm/IR/Dominators.h"
26 #include "llvm/IR/IRBuilder.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/InitializePasses.h"
29 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
30 
31 using namespace llvm;
32 
33 #define DEBUG_TYPE "printfToRuntime"
34 #define DWORD_ALIGN 4
35 
36 namespace {
37 class AMDGPUPrintfRuntimeBinding final : public ModulePass {
38 
39 public:
40   static char ID;
41 
42   explicit AMDGPUPrintfRuntimeBinding();
43 
44 private:
45   bool runOnModule(Module &M) override;
46 
47   void getAnalysisUsage(AnalysisUsage &AU) const override {
48     AU.addRequired<TargetLibraryInfoWrapperPass>();
49     AU.addRequired<DominatorTreeWrapperPass>();
50   }
51 };
52 
53 class AMDGPUPrintfRuntimeBindingImpl {
54 public:
55   AMDGPUPrintfRuntimeBindingImpl(
56       function_ref<const DominatorTree &(Function &)> GetDT,
57       function_ref<const TargetLibraryInfo &(Function &)> GetTLI)
58       : GetDT(GetDT), GetTLI(GetTLI) {}
59   bool run(Module &M);
60 
61 private:
62   void getConversionSpecifiers(SmallVectorImpl<char> &OpConvSpecifiers,
63                                StringRef fmt, size_t num_ops) const;
64 
65   bool shouldPrintAsStr(char Specifier, Type *OpType) const;
66   bool lowerPrintfForGpu(Module &M);
67 
68   Value *simplify(Instruction *I, const TargetLibraryInfo *TLI,
69                   const DominatorTree *DT) {
70     return simplifyInstruction(I, {*TD, TLI, DT});
71   }
72 
73   const DataLayout *TD;
74   function_ref<const DominatorTree &(Function &)> GetDT;
75   function_ref<const TargetLibraryInfo &(Function &)> GetTLI;
76   SmallVector<CallInst *, 32> Printfs;
77 };
78 } // namespace
79 
80 char AMDGPUPrintfRuntimeBinding::ID = 0;
81 
82 INITIALIZE_PASS_BEGIN(AMDGPUPrintfRuntimeBinding,
83                       "amdgpu-printf-runtime-binding", "AMDGPU Printf lowering",
84                       false, false)
85 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
86 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
87 INITIALIZE_PASS_END(AMDGPUPrintfRuntimeBinding, "amdgpu-printf-runtime-binding",
88                     "AMDGPU Printf lowering", false, false)
89 
90 char &llvm::AMDGPUPrintfRuntimeBindingID = AMDGPUPrintfRuntimeBinding::ID;
91 
92 namespace llvm {
93 ModulePass *createAMDGPUPrintfRuntimeBinding() {
94   return new AMDGPUPrintfRuntimeBinding();
95 }
96 } // namespace llvm
97 
98 AMDGPUPrintfRuntimeBinding::AMDGPUPrintfRuntimeBinding() : ModulePass(ID) {
99   initializeAMDGPUPrintfRuntimeBindingPass(*PassRegistry::getPassRegistry());
100 }
101 
102 void AMDGPUPrintfRuntimeBindingImpl::getConversionSpecifiers(
103     SmallVectorImpl<char> &OpConvSpecifiers, StringRef Fmt,
104     size_t NumOps) const {
105   // not all format characters are collected.
106   // At this time the format characters of interest
107   // are %p and %s, which use to know if we
108   // are either storing a literal string or a
109   // pointer to the printf buffer.
110   static const char ConvSpecifiers[] = "cdieEfgGaosuxXp";
111   size_t CurFmtSpecifierIdx = 0;
112   size_t PrevFmtSpecifierIdx = 0;
113 
114   while ((CurFmtSpecifierIdx = Fmt.find_first_of(
115               ConvSpecifiers, CurFmtSpecifierIdx)) != StringRef::npos) {
116     bool ArgDump = false;
117     StringRef CurFmt = Fmt.substr(PrevFmtSpecifierIdx,
118                                   CurFmtSpecifierIdx - PrevFmtSpecifierIdx);
119     size_t pTag = CurFmt.find_last_of("%");
120     if (pTag != StringRef::npos) {
121       ArgDump = true;
122       while (pTag && CurFmt[--pTag] == '%') {
123         ArgDump = !ArgDump;
124       }
125     }
126 
127     if (ArgDump)
128       OpConvSpecifiers.push_back(Fmt[CurFmtSpecifierIdx]);
129 
130     PrevFmtSpecifierIdx = ++CurFmtSpecifierIdx;
131   }
132 }
133 
134 bool AMDGPUPrintfRuntimeBindingImpl::shouldPrintAsStr(char Specifier,
135                                                       Type *OpType) const {
136   if (Specifier != 's')
137     return false;
138   const PointerType *PT = dyn_cast<PointerType>(OpType);
139   if (!PT || PT->getAddressSpace() != AMDGPUAS::CONSTANT_ADDRESS)
140     return false;
141   Type *ElemType = PT->getContainedType(0);
142   if (ElemType->getTypeID() != Type::IntegerTyID)
143     return false;
144   IntegerType *ElemIType = cast<IntegerType>(ElemType);
145   return ElemIType->getBitWidth() == 8;
146 }
147 
148 bool AMDGPUPrintfRuntimeBindingImpl::lowerPrintfForGpu(Module &M) {
149   LLVMContext &Ctx = M.getContext();
150   IRBuilder<> Builder(Ctx);
151   Type *I32Ty = Type::getInt32Ty(Ctx);
152   unsigned UniqID = 0;
153   // NB: This is important for this string size to be divisible by 4
154   const char NonLiteralStr[4] = "???";
155 
156   for (auto CI : Printfs) {
157     unsigned NumOps = CI->arg_size();
158 
159     SmallString<16> OpConvSpecifiers;
160     Value *Op = CI->getArgOperand(0);
161 
162     if (auto LI = dyn_cast<LoadInst>(Op)) {
163       Op = LI->getPointerOperand();
164       for (auto Use : Op->users()) {
165         if (auto SI = dyn_cast<StoreInst>(Use)) {
166           Op = SI->getValueOperand();
167           break;
168         }
169       }
170     }
171 
172     if (auto I = dyn_cast<Instruction>(Op)) {
173       Value *Op_simplified =
174           simplify(I, &GetTLI(*I->getFunction()), &GetDT(*I->getFunction()));
175       if (Op_simplified)
176         Op = Op_simplified;
177     }
178 
179     ConstantExpr *ConstExpr = dyn_cast<ConstantExpr>(Op);
180 
181     if (ConstExpr) {
182       GlobalVariable *GVar = dyn_cast<GlobalVariable>(ConstExpr->getOperand(0));
183 
184       StringRef Str("unknown");
185       if (GVar && GVar->hasInitializer()) {
186         auto *Init = GVar->getInitializer();
187         if (auto *CA = dyn_cast<ConstantDataArray>(Init)) {
188           if (CA->isString())
189             Str = CA->getAsCString();
190         } else if (isa<ConstantAggregateZero>(Init)) {
191           Str = "";
192         }
193         //
194         // we need this call to ascertain
195         // that we are printing a string
196         // or a pointer. It takes out the
197         // specifiers and fills up the first
198         // arg
199         getConversionSpecifiers(OpConvSpecifiers, Str, NumOps - 1);
200       }
201       // Add metadata for the string
202       std::string AStreamHolder;
203       raw_string_ostream Sizes(AStreamHolder);
204       int Sum = DWORD_ALIGN;
205       Sizes << CI->arg_size() - 1;
206       Sizes << ':';
207       for (unsigned ArgCount = 1;
208            ArgCount < CI->arg_size() && ArgCount <= OpConvSpecifiers.size();
209            ArgCount++) {
210         Value *Arg = CI->getArgOperand(ArgCount);
211         Type *ArgType = Arg->getType();
212         unsigned ArgSize = TD->getTypeAllocSizeInBits(ArgType);
213         ArgSize = ArgSize / 8;
214         //
215         // ArgSize by design should be a multiple of DWORD_ALIGN,
216         // expand the arguments that do not follow this rule.
217         //
218         if (ArgSize % DWORD_ALIGN != 0) {
219           llvm::Type *ResType = llvm::Type::getInt32Ty(Ctx);
220           auto *LLVMVecType = llvm::dyn_cast<llvm::FixedVectorType>(ArgType);
221           int NumElem = LLVMVecType ? LLVMVecType->getNumElements() : 1;
222           if (LLVMVecType && NumElem > 1)
223             ResType = llvm::FixedVectorType::get(ResType, NumElem);
224           Builder.SetInsertPoint(CI);
225           Builder.SetCurrentDebugLocation(CI->getDebugLoc());
226           if (OpConvSpecifiers[ArgCount - 1] == 'x' ||
227               OpConvSpecifiers[ArgCount - 1] == 'X' ||
228               OpConvSpecifiers[ArgCount - 1] == 'u' ||
229               OpConvSpecifiers[ArgCount - 1] == 'o')
230             Arg = Builder.CreateZExt(Arg, ResType);
231           else
232             Arg = Builder.CreateSExt(Arg, ResType);
233           ArgType = Arg->getType();
234           ArgSize = TD->getTypeAllocSizeInBits(ArgType);
235           ArgSize = ArgSize / 8;
236           CI->setOperand(ArgCount, Arg);
237         }
238         if (OpConvSpecifiers[ArgCount - 1] == 'f') {
239           ConstantFP *FpCons = dyn_cast<ConstantFP>(Arg);
240           if (FpCons)
241             ArgSize = 4;
242           else {
243             FPExtInst *FpExt = dyn_cast<FPExtInst>(Arg);
244             if (FpExt && FpExt->getType()->isDoubleTy() &&
245                 FpExt->getOperand(0)->getType()->isFloatTy())
246               ArgSize = 4;
247           }
248         }
249         if (shouldPrintAsStr(OpConvSpecifiers[ArgCount - 1], ArgType)) {
250           if (auto *ConstExpr = dyn_cast<ConstantExpr>(Arg)) {
251             auto *GV = dyn_cast<GlobalVariable>(ConstExpr->getOperand(0));
252             if (GV && GV->hasInitializer()) {
253               Constant *Init = GV->getInitializer();
254               bool IsZeroValue = Init->isZeroValue();
255               auto *CA = dyn_cast<ConstantDataArray>(Init);
256               if (IsZeroValue || (CA && CA->isString())) {
257                 size_t SizeStr =
258                     IsZeroValue ? 1 : (strlen(CA->getAsCString().data()) + 1);
259                 size_t Rem = SizeStr % DWORD_ALIGN;
260                 size_t NSizeStr = 0;
261                 LLVM_DEBUG(dbgs() << "Printf string original size = " << SizeStr
262                                   << '\n');
263                 if (Rem) {
264                   NSizeStr = SizeStr + (DWORD_ALIGN - Rem);
265                 } else {
266                   NSizeStr = SizeStr;
267                 }
268                 ArgSize = NSizeStr;
269               }
270             } else {
271               ArgSize = sizeof(NonLiteralStr);
272             }
273           } else {
274             ArgSize = sizeof(NonLiteralStr);
275           }
276         }
277         LLVM_DEBUG(dbgs() << "Printf ArgSize (in buffer) = " << ArgSize
278                           << " for type: " << *ArgType << '\n');
279         Sizes << ArgSize << ':';
280         Sum += ArgSize;
281       }
282       LLVM_DEBUG(dbgs() << "Printf format string in source = " << Str.str()
283                         << '\n');
284       for (char C : Str) {
285         // Rest of the C escape sequences (e.g. \') are handled correctly
286         // by the MDParser
287         switch (C) {
288         case '\a':
289           Sizes << "\\a";
290           break;
291         case '\b':
292           Sizes << "\\b";
293           break;
294         case '\f':
295           Sizes << "\\f";
296           break;
297         case '\n':
298           Sizes << "\\n";
299           break;
300         case '\r':
301           Sizes << "\\r";
302           break;
303         case '\v':
304           Sizes << "\\v";
305           break;
306         case ':':
307           // ':' cannot be scanned by Flex, as it is defined as a delimiter
308           // Replace it with it's octal representation \72
309           Sizes << "\\72";
310           break;
311         default:
312           Sizes << C;
313           break;
314         }
315       }
316 
317       // Insert the printf_alloc call
318       Builder.SetInsertPoint(CI);
319       Builder.SetCurrentDebugLocation(CI->getDebugLoc());
320 
321       AttributeList Attr = AttributeList::get(Ctx, AttributeList::FunctionIndex,
322                                               Attribute::NoUnwind);
323 
324       Type *SizetTy = Type::getInt32Ty(Ctx);
325 
326       Type *Tys_alloc[1] = {SizetTy};
327       Type *I8Ty = Type::getInt8Ty(Ctx);
328       Type *I8Ptr = PointerType::get(I8Ty, 1);
329       FunctionType *FTy_alloc = FunctionType::get(I8Ptr, Tys_alloc, false);
330       FunctionCallee PrintfAllocFn =
331           M.getOrInsertFunction(StringRef("__printf_alloc"), FTy_alloc, Attr);
332 
333       LLVM_DEBUG(dbgs() << "Printf metadata = " << Sizes.str() << '\n');
334       std::string fmtstr = itostr(++UniqID) + ":" + Sizes.str();
335       MDString *fmtStrArray = MDString::get(Ctx, fmtstr);
336 
337       // Instead of creating global variables, the
338       // printf format strings are extracted
339       // and passed as metadata. This avoids
340       // polluting llvm's symbol tables in this module.
341       // Metadata is going to be extracted
342       // by the backend passes and inserted
343       // into the OpenCL binary as appropriate.
344       StringRef amd("llvm.printf.fmts");
345       NamedMDNode *metaD = M.getOrInsertNamedMetadata(amd);
346       MDNode *myMD = MDNode::get(Ctx, fmtStrArray);
347       metaD->addOperand(myMD);
348       Value *sumC = ConstantInt::get(SizetTy, Sum, false);
349       SmallVector<Value *, 1> alloc_args;
350       alloc_args.push_back(sumC);
351       CallInst *pcall =
352           CallInst::Create(PrintfAllocFn, alloc_args, "printf_alloc_fn", CI);
353 
354       //
355       // Insert code to split basicblock with a
356       // piece of hammock code.
357       // basicblock splits after buffer overflow check
358       //
359       ConstantPointerNull *zeroIntPtr =
360           ConstantPointerNull::get(PointerType::get(I8Ty, 1));
361       auto *cmp = cast<ICmpInst>(Builder.CreateICmpNE(pcall, zeroIntPtr, ""));
362       if (!CI->use_empty()) {
363         Value *result =
364             Builder.CreateSExt(Builder.CreateNot(cmp), I32Ty, "printf_res");
365         CI->replaceAllUsesWith(result);
366       }
367       SplitBlock(CI->getParent(), cmp);
368       Instruction *Brnch =
369           SplitBlockAndInsertIfThen(cmp, cmp->getNextNode(), false);
370 
371       Builder.SetInsertPoint(Brnch);
372 
373       // store unique printf id in the buffer
374       //
375       GetElementPtrInst *BufferIdx = GetElementPtrInst::Create(
376           I8Ty, pcall, ConstantInt::get(Ctx, APInt(32, 0)), "PrintBuffID",
377           Brnch);
378 
379       Type *idPointer = PointerType::get(I32Ty, AMDGPUAS::GLOBAL_ADDRESS);
380       Value *id_gep_cast =
381           new BitCastInst(BufferIdx, idPointer, "PrintBuffIdCast", Brnch);
382 
383       new StoreInst(ConstantInt::get(I32Ty, UniqID), id_gep_cast, Brnch);
384 
385       // 1st 4 bytes hold the printf_id
386       // the following GEP is the buffer pointer
387       BufferIdx = GetElementPtrInst::Create(
388           I8Ty, pcall, ConstantInt::get(Ctx, APInt(32, 4)), "PrintBuffGep",
389           Brnch);
390 
391       Type *Int32Ty = Type::getInt32Ty(Ctx);
392       Type *Int64Ty = Type::getInt64Ty(Ctx);
393       for (unsigned ArgCount = 1;
394            ArgCount < CI->arg_size() && ArgCount <= OpConvSpecifiers.size();
395            ArgCount++) {
396         Value *Arg = CI->getArgOperand(ArgCount);
397         Type *ArgType = Arg->getType();
398         SmallVector<Value *, 32> WhatToStore;
399         if (ArgType->isFPOrFPVectorTy() && !isa<VectorType>(ArgType)) {
400           Type *IType = (ArgType->isFloatTy()) ? Int32Ty : Int64Ty;
401           if (OpConvSpecifiers[ArgCount - 1] == 'f') {
402             if (auto *FpCons = dyn_cast<ConstantFP>(Arg)) {
403               APFloat Val(FpCons->getValueAPF());
404               bool Lost = false;
405               Val.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven,
406                           &Lost);
407               Arg = ConstantFP::get(Ctx, Val);
408               IType = Int32Ty;
409             } else if (auto *FpExt = dyn_cast<FPExtInst>(Arg)) {
410               if (FpExt->getType()->isDoubleTy() &&
411                   FpExt->getOperand(0)->getType()->isFloatTy()) {
412                 Arg = FpExt->getOperand(0);
413                 IType = Int32Ty;
414               }
415             }
416           }
417           Arg = new BitCastInst(Arg, IType, "PrintArgFP", Brnch);
418           WhatToStore.push_back(Arg);
419         } else if (ArgType->getTypeID() == Type::PointerTyID) {
420           if (shouldPrintAsStr(OpConvSpecifiers[ArgCount - 1], ArgType)) {
421             const char *S = NonLiteralStr;
422             if (auto *ConstExpr = dyn_cast<ConstantExpr>(Arg)) {
423               auto *GV = dyn_cast<GlobalVariable>(ConstExpr->getOperand(0));
424               if (GV && GV->hasInitializer()) {
425                 Constant *Init = GV->getInitializer();
426                 bool IsZeroValue = Init->isZeroValue();
427                 auto *CA = dyn_cast<ConstantDataArray>(Init);
428                 if (IsZeroValue || (CA && CA->isString())) {
429                   S = IsZeroValue ? "" : CA->getAsCString().data();
430                 }
431               }
432             }
433             size_t SizeStr = strlen(S) + 1;
434             size_t Rem = SizeStr % DWORD_ALIGN;
435             size_t NSizeStr = 0;
436             if (Rem) {
437               NSizeStr = SizeStr + (DWORD_ALIGN - Rem);
438             } else {
439               NSizeStr = SizeStr;
440             }
441             if (S[0]) {
442               char *MyNewStr = new char[NSizeStr]();
443               strcpy(MyNewStr, S);
444               int NumInts = NSizeStr / 4;
445               int CharC = 0;
446               while (NumInts) {
447                 int ANum = *(int *)(MyNewStr + CharC);
448                 CharC += 4;
449                 NumInts--;
450                 Value *ANumV = ConstantInt::get(Int32Ty, ANum, false);
451                 WhatToStore.push_back(ANumV);
452               }
453               delete[] MyNewStr;
454             } else {
455               // Empty string, give a hint to RT it is no NULL
456               Value *ANumV = ConstantInt::get(Int32Ty, 0xFFFFFF00, false);
457               WhatToStore.push_back(ANumV);
458             }
459           } else {
460             uint64_t Size = TD->getTypeAllocSizeInBits(ArgType);
461             assert((Size == 32 || Size == 64) && "unsupported size");
462             Type *DstType = (Size == 32) ? Int32Ty : Int64Ty;
463             Arg = new PtrToIntInst(Arg, DstType, "PrintArgPtr", Brnch);
464             WhatToStore.push_back(Arg);
465           }
466         } else if (isa<FixedVectorType>(ArgType)) {
467           Type *IType = nullptr;
468           uint32_t EleCount = cast<FixedVectorType>(ArgType)->getNumElements();
469           uint32_t EleSize = ArgType->getScalarSizeInBits();
470           uint32_t TotalSize = EleCount * EleSize;
471           if (EleCount == 3) {
472             ShuffleVectorInst *Shuffle =
473                 new ShuffleVectorInst(Arg, Arg, ArrayRef<int>{0, 1, 2, 2});
474             Shuffle->insertBefore(Brnch);
475             Arg = Shuffle;
476             ArgType = Arg->getType();
477             TotalSize += EleSize;
478           }
479           switch (EleSize) {
480           default:
481             EleCount = TotalSize / 64;
482             IType = Type::getInt64Ty(ArgType->getContext());
483             break;
484           case 8:
485             if (EleCount >= 8) {
486               EleCount = TotalSize / 64;
487               IType = Type::getInt64Ty(ArgType->getContext());
488             } else if (EleCount >= 3) {
489               EleCount = 1;
490               IType = Type::getInt32Ty(ArgType->getContext());
491             } else {
492               EleCount = 1;
493               IType = Type::getInt16Ty(ArgType->getContext());
494             }
495             break;
496           case 16:
497             if (EleCount >= 3) {
498               EleCount = TotalSize / 64;
499               IType = Type::getInt64Ty(ArgType->getContext());
500             } else {
501               EleCount = 1;
502               IType = Type::getInt32Ty(ArgType->getContext());
503             }
504             break;
505           }
506           if (EleCount > 1) {
507             IType = FixedVectorType::get(IType, EleCount);
508           }
509           Arg = new BitCastInst(Arg, IType, "PrintArgVect", Brnch);
510           WhatToStore.push_back(Arg);
511         } else {
512           WhatToStore.push_back(Arg);
513         }
514         for (unsigned I = 0, E = WhatToStore.size(); I != E; ++I) {
515           Value *TheBtCast = WhatToStore[I];
516           unsigned ArgSize =
517               TD->getTypeAllocSizeInBits(TheBtCast->getType()) / 8;
518           SmallVector<Value *, 1> BuffOffset;
519           BuffOffset.push_back(ConstantInt::get(I32Ty, ArgSize));
520 
521           Type *ArgPointer = PointerType::get(TheBtCast->getType(), 1);
522           Value *CastedGEP =
523               new BitCastInst(BufferIdx, ArgPointer, "PrintBuffPtrCast", Brnch);
524           StoreInst *StBuff = new StoreInst(TheBtCast, CastedGEP, Brnch);
525           LLVM_DEBUG(dbgs() << "inserting store to printf buffer:\n"
526                             << *StBuff << '\n');
527           (void)StBuff;
528           if (I + 1 == E && ArgCount + 1 == CI->arg_size())
529             break;
530           BufferIdx = GetElementPtrInst::Create(I8Ty, BufferIdx, BuffOffset,
531                                                 "PrintBuffNextPtr", Brnch);
532           LLVM_DEBUG(dbgs() << "inserting gep to the printf buffer:\n"
533                             << *BufferIdx << '\n');
534         }
535       }
536     }
537   }
538 
539   // erase the printf calls
540   for (auto CI : Printfs)
541     CI->eraseFromParent();
542 
543   Printfs.clear();
544   return true;
545 }
546 
547 bool AMDGPUPrintfRuntimeBindingImpl::run(Module &M) {
548   Triple TT(M.getTargetTriple());
549   if (TT.getArch() == Triple::r600)
550     return false;
551 
552   auto PrintfFunction = M.getFunction("printf");
553   if (!PrintfFunction)
554     return false;
555 
556   for (auto &U : PrintfFunction->uses()) {
557     if (auto *CI = dyn_cast<CallInst>(U.getUser())) {
558       if (CI->isCallee(&U))
559         Printfs.push_back(CI);
560     }
561   }
562 
563   if (Printfs.empty())
564     return false;
565 
566   TD = &M.getDataLayout();
567 
568   return lowerPrintfForGpu(M);
569 }
570 
571 bool AMDGPUPrintfRuntimeBinding::runOnModule(Module &M) {
572   auto GetDT = [this](Function &F) -> DominatorTree & {
573     return this->getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
574   };
575   auto GetTLI = [this](Function &F) -> TargetLibraryInfo & {
576     return this->getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
577   };
578 
579   return AMDGPUPrintfRuntimeBindingImpl(GetDT, GetTLI).run(M);
580 }
581 
582 PreservedAnalyses
583 AMDGPUPrintfRuntimeBindingPass::run(Module &M, ModuleAnalysisManager &AM) {
584   FunctionAnalysisManager &FAM =
585       AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
586   auto GetDT = [&FAM](Function &F) -> DominatorTree & {
587     return FAM.getResult<DominatorTreeAnalysis>(F);
588   };
589   auto GetTLI = [&FAM](Function &F) -> TargetLibraryInfo & {
590     return FAM.getResult<TargetLibraryAnalysis>(F);
591   };
592   bool Changed = AMDGPUPrintfRuntimeBindingImpl(GetDT, GetTLI).run(M);
593   return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
594 }
595