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 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 SurfTexType(T) {} 80 81 DeviceVarKind getKind() const { return static_cast<DeviceVarKind>(Kind); } 82 bool isExtern() const { return Extern; } 83 bool isConstant() const { return Constant; } 84 bool isManaged() const { return Managed; } 85 bool isNormalized() const { return Normalized; } 86 int getSurfTexType() const { return SurfTexType; } 87 }; 88 89 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 131