llvm-project

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