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
GetVprintfDeclaration(llvm::Module & M)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
EmitCUDADevicePrintfCallExpr(const CallExpr * E,ReturnValueSlot ReturnValue)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 }
118