contrib/llvm-project/llvm/lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

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