Coverage Report

Created: 2021-01-26 06:56

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGCUDARuntime.h
Line
Count
Source
1
//===----- CGCUDARuntime.h - Interface to CUDA Runtimes ---------*- C++ -*-===//
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
// This provides an abstract class for CUDA code generation.  Concrete
10
// subclasses of this implement code generation for specific CUDA
11
// runtime libraries.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CLANG_LIB_CODEGEN_CGCUDARUNTIME_H
16
#define LLVM_CLANG_LIB_CODEGEN_CGCUDARUNTIME_H
17
18
#include "llvm/ADT/StringRef.h"
19
20
namespace llvm {
21
class Function;
22
class GlobalVariable;
23
}
24
25
namespace clang {
26
27
class CUDAKernelCallExpr;
28
class NamedDecl;
29
class VarDecl;
30
31
namespace CodeGen {
32
33
class CodeGenFunction;
34
class CodeGenModule;
35
class FunctionArgList;
36
class ReturnValueSlot;
37
class RValue;
38
39
class CGCUDARuntime {
40
protected:
41
  CodeGenModule &CGM;
42
43
public:
44
  // Global variable properties that must be passed to CUDA runtime.
45
  class DeviceVarFlags {
46
  public:
47
    enum DeviceVarKind {
48
      Variable, // Variable
49
      Surface,  // Builtin surface
50
      Texture,  // Builtin texture
51
    };
52
53
  private:
54
    unsigned Kind : 2;
55
    unsigned Extern : 1;
56
    unsigned Constant : 1;   // Constant variable.
57
    unsigned Managed : 1;    // Managed variable.
58
    unsigned Normalized : 1; // Normalized texture.
59
    int SurfTexType;         // Type of surface/texutre.
60
61
  public:
62
    DeviceVarFlags(DeviceVarKind K, bool E, bool C, bool M, bool N, int T)
63
        : Kind(K), Extern(E), Constant(C), Managed(M), Normalized(N),
64
89
          SurfTexType(T) {}
65
66
53
    DeviceVarKind getKind() const { return static_cast<DeviceVarKind>(Kind); }
67
47
    bool isExtern() const { return Extern; }
68
44
    bool isConstant() const { return Constant; }
69
50
    bool isManaged() const { return Managed; }
70
2
    bool isNormalized() const { return Normalized; }
71
3
    int getSurfTexType() const { return SurfTexType; }
72
  };
73
74
181
  CGCUDARuntime(CodeGenModule &CGM) : CGM(CGM) {}
75
  virtual ~CGCUDARuntime();
76
77
  virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
78
                                        const CUDAKernelCallExpr *E,
79
                                        ReturnValueSlot ReturnValue);
80
81
  /// Emits a kernel launch stub.
82
  virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args) = 0;
83
  virtual void registerDeviceVar(const VarDecl *VD, llvm::GlobalVariable &Var,
84
                                 bool Extern, bool Constant) = 0;
85
  virtual void registerDeviceSurf(const VarDecl *VD, llvm::GlobalVariable &Var,
86
                                  bool Extern, int Type) = 0;
87
  virtual void registerDeviceTex(const VarDecl *VD, llvm::GlobalVariable &Var,
88
                                 bool Extern, int Type, bool Normalized) = 0;
89
90
  /// Constructs and returns a module initialization function or nullptr if it's
91
  /// not needed. Must be called after all kernels have been emitted.
92
  virtual llvm::Function *makeModuleCtorFunction() = 0;
93
94
  /// Returns a module cleanup function or nullptr if it's not needed.
95
  /// Must be called after ModuleCtorFunction
96
  virtual llvm::Function *makeModuleDtorFunction() = 0;
97
98
  /// Returns function or variable name on device side even if the current
99
  /// compilation is for host.
100
  virtual std::string getDeviceSideName(const NamedDecl *ND) = 0;
101
};
102
103
/// Creates an instance of a CUDA runtime class.
104
CGCUDARuntime *CreateNVCUDARuntime(CodeGenModule &CGM);
105
106
}
107
}
108
109
#endif