clang/lib/CodeGen/CGCUDARuntime.h

   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