Coverage Report

Created: 2022-05-14 11:35

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/CodeGen/CGCUDARuntime.h
Line
Count
Source (jump to first uncovered line)
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 "clang/AST/GlobalDecl.h"
19
#include "llvm/ADT/StringRef.h"
20
#include "llvm/IR/GlobalValue.h"
21
22
namespace llvm {
23
class Function;
24
class GlobalVariable;
25
}
26
27
namespace clang {
28
29
class CUDAKernelCallExpr;
30
class NamedDecl;
31
class VarDecl;
32
33
namespace CodeGen {
34
35
class CodeGenFunction;
36
class CodeGenModule;
37
class FunctionArgList;
38
class ReturnValueSlot;
39
class RValue;
40
41
class CGCUDARuntime {
42
protected:
43
  CodeGenModule &CGM;
44
45
public:
46
  // Global variable properties that must be passed to CUDA runtime.
47
  class DeviceVarFlags {
48
  public:
49
    enum DeviceVarKind {
50
      Variable, // Variable
51
      Surface,  // Builtin surface
52
      Texture,  // Builtin texture
53
    };
54
55
    /// The kind flag for an offloading entry.
56
    enum OffloadEntryKindFlag : uint32_t {
57
      /// Mark the entry as a global entry. This indicates the presense of a
58
      /// kernel if the size size field is zero and a variable otherwise.
59
      OffloadGlobalEntry = 0x0,
60
      /// Mark the entry as a managed global variable.
61
      OffloadGlobalManagedEntry = 0x1,
62
      /// Mark the entry as a surface variable.
63
      OffloadGlobalSurfaceEntry = 0x2,
64
      /// Mark the entry as a texture variable.
65
      OffloadGlobalTextureEntry = 0x3,
66
    };
67
68
  private:
69
    unsigned Kind : 2;
70
    unsigned Extern : 1;
71
    unsigned Constant : 1;   // Constant variable.
72
    unsigned Managed : 1;    // Managed variable.
73
    unsigned Normalized : 1; // Normalized texture.
74
    int SurfTexType;         // Type of surface/texutre.
75
76
  public:
77
    DeviceVarFlags(DeviceVarKind K, bool E, bool C, bool M, bool N, int T)
78
        : Kind(K), Extern(E), Constant(C), Managed(M), Normalized(N),
79
172
          SurfTexType(T) {}
80
81
245
    DeviceVarKind getKind() const { return static_cast<DeviceVarKind>(Kind); }
82
60
    bool isExtern() const { return Extern; }
83
60
    bool isConstant() const { return Constant; }
84
165
    bool isManaged() const { return Managed; }
85
0
    bool isNormalized() const { return Normalized; }
86
0
    int getSurfTexType() const { return SurfTexType; }
87
  };
88
89
167
  CGCUDARuntime(CodeGenModule &CGM) : CGM(CGM) {}
90
  virtual ~CGCUDARuntime();
91
92
  virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
93
                                        const CUDAKernelCallExpr *E,
94
                                        ReturnValueSlot ReturnValue);
95
96
  /// Emits a kernel launch stub.
97
  virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args) = 0;
98
99
  /// Check whether a variable is a device variable and register it if true.
100
  virtual void handleVarRegistration(const VarDecl *VD,
101
                                     llvm::GlobalVariable &Var) = 0;
102
103
  /// Finalize generated LLVM module. Returns a module constructor function
104
  /// to be added or a null pointer.
105
  virtual llvm::Function *finalizeModule() = 0;
106
107
  /// Returns function or variable name on device side even if the current
108
  /// compilation is for host.
109
  virtual std::string getDeviceSideName(const NamedDecl *ND) = 0;
110
111
  /// Get kernel handle by stub function.
112
  virtual llvm::GlobalValue *getKernelHandle(llvm::Function *Stub,
113
                                             GlobalDecl GD) = 0;
114
115
  /// Get kernel stub by kernel handle.
116
  virtual llvm::Function *getKernelStub(llvm::GlobalValue *Handle) = 0;
117
118
  /// Adjust linkage of shadow variables in host compilation.
119
  virtual void
120
  internalizeDeviceSideVar(const VarDecl *D,
121
                           llvm::GlobalValue::LinkageTypes &Linkage) = 0;
122
};
123
124
/// Creates an instance of a CUDA runtime class.
125
CGCUDARuntime *CreateNVCUDARuntime(CodeGenModule &CGM);
126
127
}
128
}
129
130
#endif