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::PointerType::getUnqual(M.getContext()), 27 llvm::PointerType::getUnqual(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::PointerType::getUnqual(M.getContext()), 49 llvm::PointerType::getUnqual(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 = 103 llvm::ConstantPointerNull::get(llvm::PointerType::getUnqual(Ctx)); 104 return {BufferPtr, llvm::TypeSize::getFixed(0)}; 105 } else { 106 llvm::SmallVector<llvm::Type *, 8> ArgTypes; 107 for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) 108 ArgTypes.push_back(Args[I].getRValue(*CGF).getScalarVal()->getType()); 109 110 // Using llvm::StructType is correct only because printf doesn't accept 111 // aggregates. If we had to handle aggregates here, we'd have to manually 112 // compute the offsets within the alloca -- we wouldn't be able to assume 113 // that the alignment of the llvm type was the same as the alignment of the 114 // clang type. 115 llvm::Type *AllocaTy = llvm::StructType::create(ArgTypes, "printf_args"); 116 llvm::Value *Alloca = CGF->CreateTempAlloca(AllocaTy); 117 118 for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) { 119 llvm::Value *P = Builder.CreateStructGEP(AllocaTy, Alloca, I - 1); 120 llvm::Value *Arg = Args[I].getRValue(*CGF).getScalarVal(); 121 Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlign(Arg->getType())); 122 } 123 llvm::Value *BufferPtr = 124 Builder.CreatePointerCast(Alloca, llvm::PointerType::getUnqual(Ctx)); 125 return {BufferPtr, DL.getTypeAllocSize(AllocaTy)}; 126 } 127 } 128 129 bool containsNonScalarVarargs(CodeGenFunction *CGF, const CallArgList &Args) { 130 return llvm::any_of(llvm::drop_begin(Args), [&](const CallArg &A) { 131 return !A.getRValue(*CGF).isScalar(); 132 }); 133 } 134 135 RValue EmitDevicePrintfCallExpr(const CallExpr *E, CodeGenFunction *CGF, 136 llvm::Function *Decl, bool WithSizeArg) { 137 CodeGenModule &CGM = CGF->CGM; 138 CGBuilderTy &Builder = CGF->Builder; 139 assert(E->getBuiltinCallee() == Builtin::BIprintf || 140 E->getBuiltinCallee() == Builtin::BI__builtin_printf); 141 assert(E->getNumArgs() >= 1); // printf always has at least one arg. 142 143 // Uses the same format as nvptx for the argument packing, but also passes 144 // an i32 for the total size of the passed pointer 145 CallArgList Args; 146 CGF->EmitCallArgs(Args, 147 E->getDirectCallee()->getType()->getAs<FunctionProtoType>(), 148 E->arguments(), E->getDirectCallee(), 149 /* ParamsToSkip = */ 0); 150 151 // We don't know how to emit non-scalar varargs. 152 if (containsNonScalarVarargs(CGF, Args)) { 153 CGM.ErrorUnsupported(E, "non-scalar arg to printf"); 154 return RValue::get(llvm::ConstantInt::get(CGF->IntTy, 0)); 155 } 156 157 auto r = packArgsIntoNVPTXFormatBuffer(CGF, Args); 158 llvm::Value *BufferPtr = r.first; 159 160 llvm::SmallVector<llvm::Value *, 3> Vec = { 161 Args[0].getRValue(*CGF).getScalarVal(), BufferPtr}; 162 if (WithSizeArg) { 163 // Passing > 32bit of data as a local alloca doesn't work for nvptx or 164 // amdgpu 165 llvm::Constant *Size = 166 llvm::ConstantInt::get(llvm::Type::getInt32Ty(CGM.getLLVMContext()), 167 static_cast<uint32_t>(r.second.getFixedValue())); 168 169 Vec.push_back(Size); 170 } 171 return RValue::get(Builder.CreateCall(Decl, Vec)); 172 } 173 } // namespace 174 175 RValue CodeGenFunction::EmitNVPTXDevicePrintfCallExpr(const CallExpr *E) { 176 assert(getTarget().getTriple().isNVPTX()); 177 return EmitDevicePrintfCallExpr( 178 E, this, GetVprintfDeclaration(CGM.getModule()), false); 179 } 180 181 RValue CodeGenFunction::EmitAMDGPUDevicePrintfCallExpr(const CallExpr *E) { 182 assert(getTarget().getTriple().isAMDGCN() || 183 (getTarget().getTriple().isSPIRV() && 184 getTarget().getTriple().getVendor() == llvm::Triple::AMD)); 185 assert(E->getBuiltinCallee() == Builtin::BIprintf || 186 E->getBuiltinCallee() == Builtin::BI__builtin_printf); 187 assert(E->getNumArgs() >= 1); // printf always has at least one arg. 188 189 CallArgList CallArgs; 190 EmitCallArgs(CallArgs, 191 E->getDirectCallee()->getType()->getAs<FunctionProtoType>(), 192 E->arguments(), E->getDirectCallee(), 193 /* ParamsToSkip = */ 0); 194 195 SmallVector<llvm::Value *, 8> Args; 196 for (const auto &A : CallArgs) { 197 // We don't know how to emit non-scalar varargs. 198 if (!A.getRValue(*this).isScalar()) { 199 CGM.ErrorUnsupported(E, "non-scalar arg to printf"); 200 return RValue::get(llvm::ConstantInt::get(IntTy, -1)); 201 } 202 203 llvm::Value *Arg = A.getRValue(*this).getScalarVal(); 204 Args.push_back(Arg); 205 } 206 207 llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint()); 208 IRB.SetCurrentDebugLocation(Builder.getCurrentDebugLocation()); 209 210 bool isBuffered = (CGM.getTarget().getTargetOpts().AMDGPUPrintfKindVal == 211 clang::TargetOptions::AMDGPUPrintfKind::Buffered); 212 auto Printf = llvm::emitAMDGPUPrintfCall(IRB, Args, isBuffered); 213 Builder.SetInsertPoint(IRB.GetInsertBlock(), IRB.GetInsertPoint()); 214 return RValue::get(Printf); 215 } 216 217 RValue CodeGenFunction::EmitOpenMPDevicePrintfCallExpr(const CallExpr *E) { 218 assert(getTarget().getTriple().isNVPTX() || 219 getTarget().getTriple().isAMDGCN()); 220 return EmitDevicePrintfCallExpr(E, this, GetOpenMPVprintfDeclaration(CGM), 221 true); 222 } 223