mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-16 22:36:04 +00:00
97f3be2c5a
Summary: This patch adds support for registering texture / surface variables from CUDA / HIP. Additionally, we now properly track the `extern` and `const` flags that are also used in these runtime functions. This does not implement the `managed` variables yet as those seem to require some extra handling I'm not familiar with. The issue is that the current offload entry isn't large enough to carry size and alignment information along with an extra global.
119 lines
3.7 KiB
C++
119 lines
3.7 KiB
C++
//===----- CGCUDARuntime.h - Interface to CUDA Runtimes ---------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This provides an abstract class for CUDA code generation. Concrete
|
|
// subclasses of this implement code generation for specific CUDA
|
|
// runtime libraries.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_LIB_CODEGEN_CGCUDARUNTIME_H
|
|
#define LLVM_CLANG_LIB_CODEGEN_CGCUDARUNTIME_H
|
|
|
|
#include "clang/AST/GlobalDecl.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Frontend/Offloading/Utility.h"
|
|
#include "llvm/IR/GlobalValue.h"
|
|
|
|
namespace llvm {
|
|
class Function;
|
|
class GlobalVariable;
|
|
}
|
|
|
|
namespace clang {
|
|
|
|
class CUDAKernelCallExpr;
|
|
class NamedDecl;
|
|
class VarDecl;
|
|
|
|
namespace CodeGen {
|
|
|
|
class CodeGenFunction;
|
|
class CodeGenModule;
|
|
class FunctionArgList;
|
|
class ReturnValueSlot;
|
|
class RValue;
|
|
|
|
class CGCUDARuntime {
|
|
protected:
|
|
CodeGenModule &CGM;
|
|
|
|
public:
|
|
// Global variable properties that must be passed to CUDA runtime.
|
|
class DeviceVarFlags {
|
|
public:
|
|
enum DeviceVarKind {
|
|
Variable, // Variable
|
|
Surface, // Builtin surface
|
|
Texture, // Builtin texture
|
|
};
|
|
|
|
private:
|
|
unsigned Kind : 2;
|
|
unsigned Extern : 1;
|
|
unsigned Constant : 1; // Constant variable.
|
|
unsigned Managed : 1; // Managed variable.
|
|
unsigned Normalized : 1; // Normalized texture.
|
|
int SurfTexType; // Type of surface/texutre.
|
|
|
|
public:
|
|
DeviceVarFlags(DeviceVarKind K, bool E, bool C, bool M, bool N, int T)
|
|
: Kind(K), Extern(E), Constant(C), Managed(M), Normalized(N),
|
|
SurfTexType(T) {}
|
|
|
|
DeviceVarKind getKind() const { return static_cast<DeviceVarKind>(Kind); }
|
|
bool isExtern() const { return Extern; }
|
|
bool isConstant() const { return Constant; }
|
|
bool isManaged() const { return Managed; }
|
|
bool isNormalized() const { return Normalized; }
|
|
int getSurfTexType() const { return SurfTexType; }
|
|
};
|
|
|
|
CGCUDARuntime(CodeGenModule &CGM) : CGM(CGM) {}
|
|
virtual ~CGCUDARuntime();
|
|
|
|
virtual RValue EmitCUDAKernelCallExpr(CodeGenFunction &CGF,
|
|
const CUDAKernelCallExpr *E,
|
|
ReturnValueSlot ReturnValue);
|
|
|
|
/// Emits a kernel launch stub.
|
|
virtual void emitDeviceStub(CodeGenFunction &CGF, FunctionArgList &Args) = 0;
|
|
|
|
/// Check whether a variable is a device variable and register it if true.
|
|
virtual void handleVarRegistration(const VarDecl *VD,
|
|
llvm::GlobalVariable &Var) = 0;
|
|
|
|
/// Finalize generated LLVM module. Returns a module constructor function
|
|
/// to be added or a null pointer.
|
|
virtual llvm::Function *finalizeModule() = 0;
|
|
|
|
/// Returns function or variable name on device side even if the current
|
|
/// compilation is for host.
|
|
virtual std::string getDeviceSideName(const NamedDecl *ND) = 0;
|
|
|
|
/// Get kernel handle by stub function.
|
|
virtual llvm::GlobalValue *getKernelHandle(llvm::Function *Stub,
|
|
GlobalDecl GD) = 0;
|
|
|
|
/// Get kernel stub by kernel handle.
|
|
virtual llvm::Function *getKernelStub(llvm::GlobalValue *Handle) = 0;
|
|
|
|
/// Adjust linkage of shadow variables in host compilation.
|
|
virtual void
|
|
internalizeDeviceSideVar(const VarDecl *D,
|
|
llvm::GlobalValue::LinkageTypes &Linkage) = 0;
|
|
};
|
|
|
|
/// Creates an instance of a CUDA runtime class.
|
|
CGCUDARuntime *CreateNVCUDARuntime(CodeGenModule &CGM);
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|