Clang Project

clang_source_code/test/SemaCUDA/Inputs/cuda-initializers.h
1// CUDA struct types with interesting initialization properties.
2// Keep in sync with ../CodeGenCUDA/Inputs/cuda-initializers.h.
3
4// Base classes with different initializer variants.
5
6// trivial constructor -- allowed
7struct T {
8  int t;
9};
10
11// empty constructor
12struct EC {
13  int ec;
14  __device__ EC() {}     // -- allowed
15  __device__ EC(int) {}  // -- not allowed
16};
17
18// empty destructor
19struct ED {
20  __device__ ~ED() {}     // -- allowed
21};
22
23struct ECD {
24  __device__ ECD() {}     // -- allowed
25  __device__ ~ECD() {}    // -- allowed
26};
27
28// empty templated constructor -- allowed with no arguments
29struct ETC {
30  template <typename... T> __device__ ETC(T...) {}
31};
32
33// undefined constructor -- not allowed
34struct UC {
35  int uc;
36  __device__ UC();
37};
38
39// undefined destructor -- not allowed
40struct UD {
41  int ud;
42  __device__ ~UD();
43};
44
45// empty constructor w/ initializer list -- not allowed
46struct ECI {
47  int eci;
48  __device__ ECI() : eci(1) {}
49};
50
51// non-empty constructor -- not allowed
52struct NEC {
53  int nec;
54  __device__ NEC() { nec = 1; }
55};
56
57// non-empty destructor -- not allowed
58struct NED {
59  int ned;
60  __device__ ~NED() { ned = 1; }
61};
62
63// no-constructor,  virtual method -- not allowed
64struct NCV {
65  int ncv;
66  __device__ virtual void vm() {}
67};
68
69// virtual destructor -- not allowed.
70struct VD {
71  __device__ virtual ~VD() {}
72};
73
74// dynamic in-class field initializer -- not allowed
75__device__ int f();
76struct NCF {
77  int ncf = f();
78};
79
80// static in-class field initializer.  NVCC does not allow it, but
81// clang generates static initializer for this, so we'll accept it.
82// We still can't use it on __shared__ vars as they don't allow *any*
83// initializers.
84struct NCFS {
85  int ncfs = 3;
86};
87
88// undefined templated constructor -- not allowed
89struct UTC {
90  template <typename... T> __device__ UTC(T...);
91};
92
93// non-empty templated constructor -- not allowed
94struct NETC {
95  int netc;
96  template <typename... T> __device__ NETC(T...) { netc = 1; }
97};
98
99// Regular base class -- allowed
100struct T_B_T : T {};
101
102// Incapsulated object of allowed class -- allowed
103struct T_F_T {
104  T t;
105};
106
107// array of allowed objects -- allowed
108struct T_FA_T {
109  T t[2];
110};
111
112
113// Calling empty base class initializer is OK
114struct EC_I_EC : EC {
115  __device__ EC_I_EC() : EC() {}
116};
117
118// .. though passing arguments is not allowed.
119struct EC_I_EC1 : EC {
120  __device__ EC_I_EC1() : EC(1) {}
121};
122
123// Virtual base class -- not allowed
124struct T_V_T : virtual T {};
125
126// Inherited from or incapsulated class with non-empty constructor --
127// not allowed
128struct T_B_NEC : NEC {};
129struct T_F_NEC {
130  NEC nec;
131};
132struct T_FA_NEC {
133  NEC nec[2];
134};
135
136
137// Inherited from or incapsulated class with non-empty desstructor --
138// not allowed
139struct T_B_NED : NED {};
140struct T_F_NED {
141  NED ned;
142};
143struct T_FA_NED {
144  NED ned[2];
145};
146
CodeThinker, Enjoy your reading code