Home | History | Annotate | Line # | Download | only in CodeGen 
      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   private:
     56     unsigned Kind : 2;
     57     unsigned Extern : 1;
     58     unsigned Constant : 1;   // Constant variable.
     59     unsigned Managed : 1;    // Managed variable.
     60     unsigned Normalized : 1; // Normalized texture.
     61     int SurfTexType;         // Type of surface/texutre.
     62 
     63   public:
     64     DeviceVarFlags(DeviceVarKind K, bool E, bool C, bool M, bool N, int T)
     65         : Kind(K), Extern(E), Constant(C), Managed(M), Normalized(N),
     66           SurfTexType(T) {}
     67 
     68     DeviceVarKind getKind() const { return static_cast<DeviceVarKind>(Kind); }
     69     bool isExtern() const { return Extern; }
     70     bool isConstant() const { return Constant; }
     71     bool isManaged() const { return Managed; }
     72     bool isNormalized() const { return Normalized; }
     73     int getSurfTexType() const { return SurfTexType; }
     74   };
     75 
     76   CGCUDARuntime(CodeGenModule &CGM) : CGM(CGM) {}
     77   virtual ~CGCUDARuntime();
     78 
     79   virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
     80                                         const CUDAKernelCallExpr *E,
     81                                         ReturnValueSlot ReturnValue);
     82 
     83   /// Emits a kernel launch stub.
     84   virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args) = 0;
     85 
     86   /// Check whether a variable is a device variable and register it if true.
     87   virtual void handleVarRegistration(const VarDecl *VD,
     88                                      llvm::GlobalVariable &Var) = 0;
     89 
     90   /// Finalize generated LLVM module. Returns a module constructor function
     91   /// to be added or a null pointer.
     92   virtual llvm::Function *finalizeModule() = 0;
     93 
     94   /// Returns function or variable name on device side even if the current
     95   /// compilation is for host.
     96   virtual std::string getDeviceSideName(const NamedDecl *ND) = 0;
     97 
     98   /// Get kernel handle by stub function.
     99   virtual llvm::GlobalValue *getKernelHandle(llvm::Function *Stub,
    100                                              GlobalDecl GD) = 0;
    101 
    102   /// Get kernel stub by kernel handle.
    103   virtual llvm::Function *getKernelStub(llvm::GlobalValue *Handle) = 0;
    104 
    105   /// Adjust linkage of shadow variables in host compilation.
    106   virtual void
    107   internalizeDeviceSideVar(const VarDecl *D,
    108                            llvm::GlobalValue::LinkageTypes &Linkage) = 0;
    109 };
    110 
    111 /// Creates an instance of a CUDA runtime class.
    112 CGCUDARuntime *CreateNVCUDARuntime(CodeGenModule &CGM);
    113 
    114 }
    115 }
    116 
    117 #endif
    118