contrib/llvm-project/clang/lib/CodeGen/CGGPUBuiltin.cpp

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