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 } 123