mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-06 07:06:06 +00:00
e56360a2cd
Summary: Before this patch, we computed the offsets in memory of args passed to GPU kernel functions by throwing all of the args into an LLVM struct. clang emits packed llvm structs basically whenever it feels like it, and packed structs have alignment 1. So we cannot rely on the llvm type's alignment matching the C++ type's alignment. This patch fixes our codegen so we always respect the clang types' alignments. Reviewers: rnk Subscribers: cfe-commits, tra Differential Revision: https://reviews.llvm.org/D22879 llvm-svn: 276927
124 lines
4.8 KiB
C++
124 lines
4.8 KiB
C++
//===----- CGCUDABuiltin.cpp - Codegen for CUDA builtins ------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Generates code for built-in CUDA calls which are not runtime-specific.
|
|
// (Runtime-specific codegen lives in CGCUDARuntime.)
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "CodeGenFunction.h"
|
|
#include "clang/Basic/Builtins.h"
|
|
#include "llvm/IR/DataLayout.h"
|
|
#include "llvm/IR/Instruction.h"
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
using namespace clang;
|
|
using namespace CodeGen;
|
|
|
|
static llvm::Function *GetVprintfDeclaration(llvm::Module &M) {
|
|
llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()),
|
|
llvm::Type::getInt8PtrTy(M.getContext())};
|
|
llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get(
|
|
llvm::Type::getInt32Ty(M.getContext()), ArgTypes, false);
|
|
|
|
if (auto* F = M.getFunction("vprintf")) {
|
|
// Our CUDA system header declares vprintf with the right signature, so
|
|
// nobody else should have been able to declare vprintf with a bogus
|
|
// signature.
|
|
assert(F->getFunctionType() == VprintfFuncType);
|
|
return F;
|
|
}
|
|
|
|
// vprintf doesn't already exist; create a declaration and insert it into the
|
|
// module.
|
|
return llvm::Function::Create(
|
|
VprintfFuncType, llvm::GlobalVariable::ExternalLinkage, "vprintf", &M);
|
|
}
|
|
|
|
// Transforms a call to printf into a call to the NVPTX vprintf syscall (which
|
|
// isn't particularly special; it's invoked just like a regular function).
|
|
// vprintf takes two args: A format string, and a pointer to a buffer containing
|
|
// the varargs.
|
|
//
|
|
// For example, the call
|
|
//
|
|
// printf("format string", arg1, arg2, arg3);
|
|
//
|
|
// is converted into something resembling
|
|
//
|
|
// struct Tmp {
|
|
// Arg1 a1;
|
|
// Arg2 a2;
|
|
// Arg3 a3;
|
|
// };
|
|
// char* buf = alloca(sizeof(Tmp));
|
|
// *(Tmp*)buf = {a1, a2, a3};
|
|
// vprintf("format string", buf);
|
|
//
|
|
// buf is aligned to the max of {alignof(Arg1), ...}. Furthermore, each of the
|
|
// args is itself aligned to its preferred alignment.
|
|
//
|
|
// Note that by the time this function runs, E's args have already undergone the
|
|
// standard C vararg promotion (short -> int, float -> double, etc.).
|
|
RValue
|
|
CodeGenFunction::EmitCUDADevicePrintfCallExpr(const CallExpr *E,
|
|
ReturnValueSlot ReturnValue) {
|
|
assert(getLangOpts().CUDA);
|
|
assert(getLangOpts().CUDAIsDevice);
|
|
assert(E->getBuiltinCallee() == Builtin::BIprintf);
|
|
assert(E->getNumArgs() >= 1); // printf always has at least one arg.
|
|
|
|
const llvm::DataLayout &DL = CGM.getDataLayout();
|
|
llvm::LLVMContext &Ctx = CGM.getLLVMContext();
|
|
|
|
CallArgList Args;
|
|
EmitCallArgs(Args,
|
|
E->getDirectCallee()->getType()->getAs<FunctionProtoType>(),
|
|
E->arguments(), E->getDirectCallee(),
|
|
/* ParamsToSkip = */ 0);
|
|
|
|
// We don't know how to emit non-scalar varargs.
|
|
if (std::any_of(Args.begin() + 1, Args.end(),
|
|
[](const CallArg &A) { return !A.RV.isScalar(); })) {
|
|
CGM.ErrorUnsupported(E, "non-scalar arg to printf");
|
|
return RValue::get(llvm::ConstantInt::get(IntTy, 0));
|
|
}
|
|
|
|
// Construct and fill the args buffer that we'll pass to vprintf.
|
|
llvm::Value *BufferPtr;
|
|
if (Args.size() <= 1) {
|
|
// If there are no args, pass a null pointer to vprintf.
|
|
BufferPtr = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(Ctx));
|
|
} else {
|
|
llvm::SmallVector<llvm::Type *, 8> ArgTypes;
|
|
for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I)
|
|
ArgTypes.push_back(Args[I].RV.getScalarVal()->getType());
|
|
|
|
// Using llvm::StructType is correct only because printf doesn't accept
|
|
// aggregates. If we had to handle aggregates here, we'd have to manually
|
|
// compute the offsets within the alloca -- we wouldn't be able to assume
|
|
// that the alignment of the llvm type was the same as the alignment of the
|
|
// clang type.
|
|
llvm::Type *AllocaTy = llvm::StructType::create(ArgTypes, "printf_args");
|
|
llvm::Value *Alloca = CreateTempAlloca(AllocaTy);
|
|
|
|
for (unsigned I = 1, NumArgs = Args.size(); I < NumArgs; ++I) {
|
|
llvm::Value *P = Builder.CreateStructGEP(AllocaTy, Alloca, I - 1);
|
|
llvm::Value *Arg = Args[I].RV.getScalarVal();
|
|
Builder.CreateAlignedStore(Arg, P, DL.getPrefTypeAlignment(Arg->getType()));
|
|
}
|
|
BufferPtr = Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx));
|
|
}
|
|
|
|
// Invoke vprintf and return.
|
|
llvm::Function* VprintfFunc = GetVprintfDeclaration(CGM.getModule());
|
|
return RValue::get(
|
|
Builder.CreateCall(VprintfFunc, {Args[0].RV.getScalarVal(), BufferPtr}));
|
|
}
|