146 lines
2.7 KiB
C++
146 lines
2.7 KiB
C++
// CUDA struct types with interesting initialization properties.
|
|
// Keep in sync with ../SemaCUDA/Inputs/cuda-initializers.h.
|
|
|
|
// Base classes with different initializer variants.
|
|
|
|
// trivial constructor -- allowed
|
|
struct T {
|
|
int t;
|
|
};
|
|
|
|
// empty constructor
|
|
struct EC {
|
|
int ec;
|
|
__device__ EC() {} // -- allowed
|
|
__device__ EC(int) {} // -- not allowed
|
|
};
|
|
|
|
// empty destructor
|
|
struct ED {
|
|
__device__ ~ED() {} // -- allowed
|
|
};
|
|
|
|
struct ECD {
|
|
__device__ ECD() {} // -- allowed
|
|
__device__ ~ECD() {} // -- allowed
|
|
};
|
|
|
|
// empty templated constructor -- allowed with no arguments
|
|
struct ETC {
|
|
template <typename... T> __device__ ETC(T...) {}
|
|
};
|
|
|
|
// undefined constructor -- not allowed
|
|
struct UC {
|
|
int uc;
|
|
__device__ UC();
|
|
};
|
|
|
|
// undefined destructor -- not allowed
|
|
struct UD {
|
|
int ud;
|
|
__device__ ~UD();
|
|
};
|
|
|
|
// empty constructor w/ initializer list -- not allowed
|
|
struct ECI {
|
|
int eci;
|
|
__device__ ECI() : eci(1) {}
|
|
};
|
|
|
|
// non-empty constructor -- not allowed
|
|
struct NEC {
|
|
int nec;
|
|
__device__ NEC() { nec = 1; }
|
|
};
|
|
|
|
// non-empty destructor -- not allowed
|
|
struct NED {
|
|
int ned;
|
|
__device__ ~NED() { ned = 1; }
|
|
};
|
|
|
|
// no-constructor, virtual method -- not allowed
|
|
struct NCV {
|
|
int ncv;
|
|
__device__ virtual void vm() {}
|
|
};
|
|
|
|
// virtual destructor -- not allowed.
|
|
struct VD {
|
|
__device__ virtual ~VD() {}
|
|
};
|
|
|
|
// dynamic in-class field initializer -- not allowed
|
|
__device__ int f();
|
|
struct NCF {
|
|
int ncf = f();
|
|
};
|
|
|
|
// static in-class field initializer. NVCC does not allow it, but
|
|
// clang generates static initializer for this, so we'll accept it.
|
|
// We still can't use it on __shared__ vars as they don't allow *any*
|
|
// initializers.
|
|
struct NCFS {
|
|
int ncfs = 3;
|
|
};
|
|
|
|
// undefined templated constructor -- not allowed
|
|
struct UTC {
|
|
template <typename... T> __device__ UTC(T...);
|
|
};
|
|
|
|
// non-empty templated constructor -- not allowed
|
|
struct NETC {
|
|
int netc;
|
|
template <typename... T> __device__ NETC(T...) { netc = 1; }
|
|
};
|
|
|
|
// Regular base class -- allowed
|
|
struct T_B_T : T {};
|
|
|
|
// Incapsulated object of allowed class -- allowed
|
|
struct T_F_T {
|
|
T t;
|
|
};
|
|
|
|
// array of allowed objects -- allowed
|
|
struct T_FA_T {
|
|
T t[2];
|
|
};
|
|
|
|
|
|
// Calling empty base class initializer is OK
|
|
struct EC_I_EC : EC {
|
|
__device__ EC_I_EC() : EC() {}
|
|
};
|
|
|
|
// .. though passing arguments is not allowed.
|
|
struct EC_I_EC1 : EC {
|
|
__device__ EC_I_EC1() : EC(1) {}
|
|
};
|
|
|
|
// Virtual base class -- not allowed
|
|
struct T_V_T : virtual T {};
|
|
|
|
// Inherited from or incapsulated class with non-empty constructor --
|
|
// not allowed
|
|
struct T_B_NEC : NEC {};
|
|
struct T_F_NEC {
|
|
NEC nec;
|
|
};
|
|
struct T_FA_NEC {
|
|
NEC nec[2];
|
|
};
|
|
|
|
|
|
// Inherited from or incapsulated class with non-empty desstructor --
|
|
// not allowed
|
|
struct T_B_NED : NED {};
|
|
struct T_F_NED {
|
|
NED ned;
|
|
};
|
|
struct T_FA_NED {
|
|
NED ned[2];
|
|
};
|