| 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 |
#include "llvm/Transforms/Utils/AMDGPUEmitPrintf.h" |
| 20 |
|
| 21 |
using namespace clang; |
| 22 |
using namespace CodeGen; |
| 23 |
|
| 24 |
namespace { |
| 25 |
llvm::Function *GetVprintfDeclaration(llvm::Module &M) { |
| 26 |
llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()), |
| 27 |
llvm::Type::getInt8PtrTy(M.getContext())}; |
| 28 |
llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get( |
| 29 |
llvm::Type::getInt32Ty(M.getContext()), ArgTypes, false); |
| 30 |
|
| 31 |
if (auto *F = M.getFunction("vprintf")) { |
| 32 |
// Our CUDA system header declares vprintf with the right signature, so |
| 33 |
// nobody else should have been able to declare vprintf with a bogus |
| 34 |
// signature. |
| 35 |
assert(F->getFunctionType() == VprintfFuncType); |
| 36 |
return F; |
| 37 |
} |
| 38 |
|
| 39 |
// vprintf doesn't already exist; create a declaration and insert it into the |
| 40 |
// module. |
| 41 |
return llvm::Function::Create( |
| 42 |
VprintfFuncType, llvm::GlobalVariable::ExternalLinkage, "vprintf", &M); |
| 43 |
} |
| 44 |
|
| 45 |
llvm::Function *GetOpenMPVprintfDeclaration(CodeGenModule &CGM) { |
| 46 |
const char *Name = "__llvm_omp_vprintf"; |
| 47 |
llvm::Module &M = CGM.getModule(); |
| 48 |
llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()), |
| 49 |
llvm::Type::getInt8PtrTy(M.getContext()), |
| 50 |
llvm::Type::getInt32Ty(M.getContext())}; |
| 51 |
llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get( |
| 52 |
llvm::Type::getInt32Ty(M.getContext()), ArgTypes, false); |
| 53 |
|
| 54 |
if (auto *F = M.getFunction(Name)) { |
| 55 |
if (F->getFunctionType() != VprintfFuncType) { |
| 56 |
CGM.Error(SourceLocation(), |
| 57 |
"Invalid type declaration for __llvm_omp_vprintf"); |
| 58 |
return nullptr; |
| 59 |
} |
| 60 |
return F; |
| 61 |
} |
| 62 |
|
| 63 |
return llvm::Function::Create( |
| 64 |
VprintfFuncType, llvm::GlobalVariable::ExternalLinkage, Name, &M); |
| 65 |
} |
| 66 |
|
| 67 |
// Transforms a call to printf into a call to the NVPTX vprintf syscall (which |
| 68 |
// isn't particularly special; it's invoked just like a regular function). |
| 69 |
// vprintf takes two args: A format string, and a pointer to a buffer containing |
| 70 |
// the varargs. |
| 71 |
// |
| 72 |
// For example, the call |
| 73 |
// |
| 74 |
// printf("format string", arg1, arg2, arg3); |
| 75 |
// |
| 76 |
// is converted into something resembling |
| 77 |
// |
| 78 |
// struct Tmp { |
| 79 |
// Arg1 a1; |
| 80 |
// Arg2 a2; |
| 81 |
// Arg3 a3; |
| 82 |
// }; |
| 83 |
// char* buf = alloca(sizeof(Tmp)); |
| 84 |
// *(Tmp*)buf = {a1, a2, a3}; |
| 85 |
// vprintf("format string", buf); |
| 86 |
// |
| 87 |
// buf is aligned to the max of {alignof(Arg1), ...}. Furthermore, each of the |
| 88 |
// args is itself aligned to its preferred alignment. |
| 89 |
// |
| 90 |
// Note that by the time this function runs, E's args have already undergone the |
| 91 |
// standard C vararg promotion (short -> int, float -> double, etc.). |
| 92 |
|
| 93 |
std::pair<llvm::Value *, llvm::TypeSize> |
| 94 |
packArgsIntoNVPTXFormatBuffer(CodeGenFunction *CGF, const CallArgList &Args) { |
| 95 |
const llvm::DataLayout &DL = CGF->CGM.getDataLayout(); |
| 96 |
llvm::LLVMContext &Ctx = CGF->CGM.getLLVMContext(); |
| 97 |
CGBuilderTy &Builder = CGF->Builder; |
| 98 |
|
| 99 |
// Construct and fill the args buffer that we'll pass to vprintf. |
| 100 |
if (Args.size() <= 1) { |
| 101 |
// If there are no args, pass a null pointer and size 0 |
| 102 |
llvm::Value * BufferPtr = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(Ctx)); |
| 103 |
return {BufferPtr, llvm::TypeSize::Fixed(0)}; |
| 104 |
} else { |
| 105 |
llvm::SmallVector<llvm::Type *, 8> ArgTypes; |
| 106 |
for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) |
| 107 |
ArgTypes.push_back(Args[I].getRValue(*CGF).getScalarVal()->getType()); |
| 108 |
|
| 109 |
// Using llvm::StructType is correct only because printf doesn't accept |
| 110 |
// aggregates. If we had to handle aggregates here, we'd have to manually |
| 111 |
// compute the offsets within the alloca -- we wouldn't be able to assume |
| 112 |
// that the alignment of the llvm type was the same as the alignment of the |
| 113 |
// clang type. |
| 114 |
llvm::Type *AllocaTy = llvm::StructType::create(ArgTypes, "printf_args"); |
| 115 |
llvm::Value *Alloca = CGF->CreateTempAlloca(AllocaTy); |
| 116 |
|
| 117 |
for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) { |
| 118 |
llvm::Value *P = Builder.CreateStructGEP(AllocaTy, Alloca, I - 1); |
| 119 |
llvm::Value *Arg = Args[I].getRValue(*CGF).getScalarVal(); |
| 120 |
Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlign(Arg->getType())); |
| 121 |
} |
| 122 |
llvm::Value *BufferPtr = |
| 123 |
Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx)); |
| 124 |
return {BufferPtr, DL.getTypeAllocSize(AllocaTy)}; |
| 125 |
} |
| 126 |
} |
| 127 |
|
| 128 |
bool containsNonScalarVarargs(CodeGenFunction *CGF, CallArgList Args) { |
| 129 |
return llvm::any_of(llvm::drop_begin(Args), [&](const CallArg &A) { |
| 130 |
return !A.getRValue(*CGF).isScalar(); |
| 131 |
}); |
| 132 |
} |
| 133 |
|
| 134 |
RValue EmitDevicePrintfCallExpr(const CallExpr *E, CodeGenFunction *CGF, |
| 135 |
llvm::Function *Decl, bool WithSizeArg) { |
| 136 |
CodeGenModule &CGM = CGF->CGM; |
| 137 |
CGBuilderTy &Builder = CGF->Builder; |
| 138 |
assert(E->getBuiltinCallee() == Builtin::BIprintf); |
| 139 |
assert(E->getNumArgs() >= 1); // printf always has at least one arg. |
| 140 |
|
| 141 |
// Uses the same format as nvptx for the argument packing, but also passes |
| 142 |
// an i32 for the total size of the passed pointer |
| 143 |
CallArgList Args; |
| 144 |
CGF->EmitCallArgs(Args, |
| 145 |
E->getDirectCallee()->getType()->getAs<FunctionProtoType>(), |
| 146 |
E->arguments(), E->getDirectCallee(), |
| 147 |
/* ParamsToSkip = */ 0); |
| 148 |
|
| 149 |
// We don't know how to emit non-scalar varargs. |
| 150 |
if (containsNonScalarVarargs(CGF, Args)) { |
| 151 |
CGM.ErrorUnsupported(E, "non-scalar arg to printf"); |
| 152 |
return RValue::get(llvm::ConstantInt::get(CGF->IntTy, 0)); |
| 153 |
} |
| 154 |
|
| 155 |
auto r = packArgsIntoNVPTXFormatBuffer(CGF, Args); |
| 156 |
llvm::Value *BufferPtr = r.first; |
| 157 |
|
| 158 |
llvm::SmallVector<llvm::Value *, 3> Vec = { |
| 159 |
Args[0].getRValue(*CGF).getScalarVal(), BufferPtr}; |
| 160 |
if (WithSizeArg) { |
| 161 |
// Passing > 32bit of data as a local alloca doesn't work for nvptx or |
| 162 |
// amdgpu |
| 163 |
llvm::Constant *Size = |
| 164 |
llvm::ConstantInt::get(llvm::Type::getInt32Ty(CGM.getLLVMContext()), |
| 165 |
static_cast<uint32_t>(r.second.getFixedValue())); |
| 166 |
|
| 167 |
Vec.push_back(Size); |
| 168 |
} |
| 169 |
return RValue::get(Builder.CreateCall(Decl, Vec)); |
| 170 |
} |
| 171 |
} // namespace |
| 172 |
|
| 173 |
RValue CodeGenFunction::EmitNVPTXDevicePrintfCallExpr(const CallExpr *E) { |
| 174 |
assert(getTarget().getTriple().isNVPTX()); |
| 175 |
return EmitDevicePrintfCallExpr( |
| 176 |
E, this, GetVprintfDeclaration(CGM.getModule()), false); |
| 177 |
} |
| 178 |
|
| 179 |
RValue CodeGenFunction::EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E) { |
| 180 |
assert(getTarget().getTriple().getArch() == llvm::Triple::amdgcn); |
| 181 |
assert(E->getBuiltinCallee() == Builtin::BIprintf || |
| 182 |
E->getBuiltinCallee() == Builtin::BI__builtin_printf); |
| 183 |
assert(E->getNumArgs() >= 1); // printf always has at least one arg. |
| 184 |
|
| 185 |
CallArgList CallArgs; |
| 186 |
EmitCallArgs(CallArgs, |
| 187 |
E->getDirectCallee()->getType()->getAs<FunctionProtoType>(), |
| 188 |
E->arguments(), E->getDirectCallee(), |
| 189 |
/* ParamsToSkip = */ 0); |
| 190 |
|
| 191 |
SmallVector<llvm::Value *, 8> Args; |
| 192 |
for (auto A : CallArgs) { |
| 193 |
// We don't know how to emit non-scalar varargs. |
| 194 |
if (!A.getRValue(*this).isScalar()) { |
| 195 |
CGM.ErrorUnsupported(E, "non-scalar arg to printf"); |
| 196 |
return RValue::get(llvm::ConstantInt::get(IntTy, -1)); |
| 197 |
} |
| 198 |
|
| 199 |
llvm::Value *Arg = A.getRValue(*this).getScalarVal(); |
| 200 |
Args.push_back(Arg); |
| 201 |
} |
| 202 |
|
| 203 |
llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint()); |
| 204 |
IRB.SetCurrentDebugLocation(Builder.getCurrentDebugLocation()); |
| 205 |
auto Printf = llvm::emitAMDGPUPrintfCall(IRB, Args); |
| 206 |
Builder.SetInsertPoint(IRB.GetInsertBlock(), IRB.GetInsertPoint()); |
| 207 |
return RValue::get(Printf); |
| 208 |
} |
| 209 |
|
| 210 |
RValue CodeGenFunction::EmitOpenMPDevicePrintfCallExpr(const CallExpr *E) { |
| 211 |
assert(getTarget().getTriple().isNVPTX() || |
| 212 |
getTarget().getTriple().isAMDGCN()); |
| 213 |
return EmitDevicePrintfCallExpr(E, this, GetOpenMPVprintfDeclaration(CGM), |
| 214 |
true); |
| 215 |
} |