Clang Project

clang_source_code/lib/CodeGen/CGGPUBuiltin.cpp
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
20using namespace clang;
21using namespace CodeGen;
22
23static 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    getFunctionType() == VprintfFuncType", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGGPUBuiltin.cpp", 33, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">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.).
68RValue
69CodeGenFunction::EmitNVPTXDevicePrintfCallExpr(const CallExpr *E,
70                                               ReturnValueSlot ReturnValue) {
71  assert(getTarget().getTriple().isNVPTX());
72  getBuiltinCallee() == Builtin..BIprintf", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGGPUBuiltin.cpp", 72, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">assert(E->getBuiltinCallee() == Builtin::BIprintf);
73  getNumArgs() >= 1", "/home/seafit/code_projects/clang_source/clang/lib/CodeGen/CGGPUBuiltin.cpp", 73, __PRETTY_FUNCTION__))" file_link="../../../include/assert.h.html#88" macro="true">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
clang::CodeGen::CodeGenFunction::EmitNVPTXDevicePrintfCallExpr
CodeThinker, Enjoy your reading code