contrib/llvm/tools/clang/lib/CodeGen/CGCUDABuiltin.cpp

   1 //===----- CGCUDABuiltin.cpp - Codegen for CUDA builtins ------------------===//
   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 // Generates code for built-in CUDA calls which are not runtime-specific.
  11 // (Runtime-specific codegen lives in CGCUDARuntime.)
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CodeGenFunction.h"
  16 #include "clang/Basic/Builtins.h"
  17 #include "llvm/IR/DataLayout.h"
  18 #include "llvm/IR/Instruction.h"
  19 #include "llvm/Support/MathExtras.h"
  20
  21 using namespace clang;
  22 using namespace CodeGen;
  23
  24 static llvm::Function *GetVprintfDeclaration(llvm::Module &M) {
  25   llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()),
  26                             llvm::Type::getInt8PtrTy(M.getContext())};
  27   llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get(
  28       llvm::Type::getInt32Ty(M.getContext()), ArgTypes, false);
  29
  30   if (auto* F = M.getFunction("vprintf")) {
  31     // Our CUDA system header declares vprintf with the right signature, so
  32     // nobody else should have been able to declare vprintf with a bogus
  33     // signature.
  34     assert(F->getFunctionType() == VprintfFuncType);
  35     return F;
  36   }
  37
  38   // vprintf doesn't already exist; create a declaration and insert it into the
  39   // module.
  40   return llvm::Function::Create(
  41       VprintfFuncType, llvm::GlobalVariable::ExternalLinkage, "vprintf", &M);
  42 }
  43
  44 // Transforms a call to printf into a call to the NVPTX vprintf syscall (which
  45 // isn't particularly special; it's invoked just like a regular function).
  46 // vprintf takes two args: A format string, and a pointer to a buffer containing
  47 // the varargs.
  48 //
  49 // For example, the call
  50 //
  51 //   printf("format string", arg1, arg2, arg3);
  52 //
  53 // is converted into something resembling
  54 //
  55 //   struct Tmp {
  56 //     Arg1 a1;
  57 //     Arg2 a2;
  58 //     Arg3 a3;
  59 //   };
  60 //   char* buf = alloca(sizeof(Tmp));
  61 //   *(Tmp*)buf = {a1, a2, a3};
  62 //   vprintf("format string", buf);
  63 //
  64 // buf is aligned to the max of {alignof(Arg1), ...}.  Furthermore, each of the
  65 // args is itself aligned to its preferred alignment.
  66 //
  67 // Note that by the time this function runs, E's args have already undergone the
  68 // standard C vararg promotion (short -> int, float -> double, etc.).
  69 RValue
  70 CodeGenFunction::EmitCUDADevicePrintfCallExpr(const CallExpr *E,
  71                                               ReturnValueSlot ReturnValue) {
  72   assert(getLangOpts().CUDA);
  73   assert(getLangOpts().CUDAIsDevice);
  74   assert(E->getBuiltinCallee() == Builtin::BIprintf);
  75   assert(E->getNumArgs() >= 1); // printf always has at least one arg.
  76
  77   const llvm::DataLayout &DL = CGM.getDataLayout();
  78   llvm::LLVMContext &Ctx = CGM.getLLVMContext();
  79
  80   CallArgList Args;
  81   EmitCallArgs(Args,
  82                E->getDirectCallee()->getType()->getAs<FunctionProtoType>(),
  83                E->arguments(), E->getDirectCallee(),
  84                /* ParamsToSkip = */ 0);
  85
  86   // We don't know how to emit non-scalar varargs.
  87   if (std::any_of(Args.begin() + 1, Args.end(),
  88                   [](const CallArg &A) { return !A.RV.isScalar(); })) {
  89     CGM.ErrorUnsupported(E, "non-scalar arg to printf");
  90     return RValue::get(llvm::ConstantInt::get(IntTy, 0));
  91   }
  92
  93   // Construct and fill the args buffer that we'll pass to vprintf.
  94   llvm::Value *BufferPtr;
  95   if (Args.size() <= 1) {
  96     // If there are no args, pass a null pointer to vprintf.
  97     BufferPtr = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(Ctx));
  98   } else {
  99     llvm::SmallVector<llvm::Type *, 8> ArgTypes;
 100     for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I)
 101       ArgTypes.push_back(Args[I].RV.getScalarVal()->getType());
 102     llvm::Type *AllocaTy = llvm::StructType::create(ArgTypes, "printf_args");
 103     llvm::Value *Alloca = CreateTempAlloca(AllocaTy);
 104
 105     for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) {
 106       llvm::Value *P = Builder.CreateStructGEP(AllocaTy, Alloca, I - 1);
 107       llvm::Value *Arg = Args[I].RV.getScalarVal();
 108       Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlignment(Arg->getType()));
 109     }
 110     BufferPtr = Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx));
 111   }
 112
 113   // Invoke vprintf and return.
 114   llvm::Function* VprintfFunc = GetVprintfDeclaration(CGM.getModule());
 115   return RValue::get(
 116       Builder.CreateCall(VprintfFunc, {Args[0].RV.getScalarVal(), BufferPtr}));
 117 }