1 // RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -Wno-unused -Wunevaluated-expression -triple x86_64-gnu-linux
2 
3 template<int Bounds>
4 struct HasExtInt {
5   _BitInt(Bounds) b;
6   unsigned _BitInt(Bounds) b2;
7 };
8 
9 // Delcaring variables:
10 _BitInt(33) Declarations(_BitInt(48) &Param) { // Useable in params and returns.
11   short _BitInt(43) a; // expected-error {{'short _BitInt' is invalid}}
12   _BitInt(43) long b;  // expected-error {{'long _BitInt' is invalid}}
13 
14   // These should all be fine:
15   const _BitInt(5) c = 3;
16   const unsigned _BitInt(5) d; // expected-error {{default initialization of an object of const type 'const unsigned _BitInt(5)'}}
17   unsigned _BitInt(5) e = 5;
18   _BitInt(5) unsigned f;
19 
20   _BitInt(-3) g; // expected-error{{signed _BitInt of bit sizes greater than 128 not supported}}
21   _BitInt(0) h; // expected-error{{signed _BitInt must have a bit size of at least 2}}
22   _BitInt(1) i; // expected-error{{signed _BitInt must have a bit size of at least 2}}
23   _BitInt(2) j;;
24   unsigned _BitInt(0) k;// expected-error{{unsigned _BitInt must have a bit size of at least 1}}
25   unsigned _BitInt(1) l;
26   signed _BitInt(1) m; // expected-error{{signed _BitInt must have a bit size of at least 2}}
27 
28   constexpr _BitInt(6) n = 33; // expected-warning{{implicit conversion from 'int' to 'const _BitInt(6)' changes value from 33 to -31}}
29   constexpr _BitInt(7) o = 33;
30 
31   // Check imposed max size.
32   _BitInt(129) p;               // expected-error {{signed _BitInt of bit sizes greater than 128 not supported}}
33   unsigned _BitInt(0xFFFFFFFFFF) q; // expected-error {{unsigned _BitInt of bit sizes greater than 128 not supported}}
34 
35 // Ensure template params are instantiated correctly.
36   // expected-error@5{{signed _BitInt of bit sizes greater than 128 not supported}}
37   // expected-error@6{{unsigned _BitInt of bit sizes greater than 128 not supported}}
38   // expected-note@+1{{in instantiation of template class }}
39   HasExtInt<-1> r;
40   // expected-error@5{{signed _BitInt must have a bit size of at least 2}}
41   // expected-error@6{{unsigned _BitInt must have a bit size of at least 1}}
42   // expected-note@+1{{in instantiation of template class }}
43   HasExtInt<0> s;
44   // expected-error@5{{signed _BitInt must have a bit size of at least 2}}
45   // expected-note@+1{{in instantiation of template class }}
46   HasExtInt<1> t;
47   HasExtInt<2> u;
48 
49   _BitInt(-3.0) v; // expected-error {{integral constant expression must have integral or unscoped enumeration type, not 'double'}}
50   _BitInt(3.0) x; // expected-error {{integral constant expression must have integral or unscoped enumeration type, not 'double'}}
51 
52   return 0;
53 }
54 
55 template <_BitInt(5) I>
56 struct ExtIntTemplParam {
57   static constexpr _BitInt(5) Var = I;
58 };
59 
60 template<typename T>
61 void deduced_whole_type(T){}
62 template<int I>
63 void deduced_bound(_BitInt(I)){}
64 
65 // Ensure ext-int can be used in template places.
66 void Templates() {
67   ExtIntTemplParam<13> a;
68   constexpr _BitInt(3) b = 1;
69   ExtIntTemplParam<b> c;
70   constexpr _BitInt(9) d = 1;
71   ExtIntTemplParam<b> e;
72 
73   deduced_whole_type(b);
74   deduced_bound(b);
75 }
76 
77 template <typename T, typename U>
78 struct is_same {
79   static constexpr bool value = false;
80 };
81 template <typename T>
82 struct is_same<T,T> {
83   static constexpr bool value = true;
84 };
85 
86 // Reject vector types:
87 // expected-error@+1{{invalid vector element type '_BitInt(32)'}}
88 typedef _BitInt(32) __attribute__((vector_size(16))) VecTy;
89 
90 // Allow _Complex:
91 _Complex _BitInt(3) Cmplx;
92 
93 // Reject cases of _Atomic:
94 // expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(4)'}}
95 _Atomic _BitInt(4) TooSmallAtomic;
96 // expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(9)'}}
97 _Atomic _BitInt(9) NotPow2Atomic;
98 // expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(128)'}}
99 _Atomic _BitInt(128) JustRightAtomic;
100 
101 // Test result types of Unary/Bitwise/Binary Operations:
102 void Ops() {
103   _BitInt(43) x43_s = 1, y43_s = 1;
104   _BitInt(sizeof(int) * 8) x32_s = 1, y32_s = 1;
105   unsigned _BitInt(sizeof(unsigned) * 8) x32_u = 1, y32_u = 1;
106   _BitInt(4) x4_s = 1, y4_s = 1;
107   unsigned _BitInt(43) x43_u = 1, y43_u = 1;
108   unsigned _BitInt(4) x4_u = 1, y4_u = 1;
109   int x_int = 1, y_int = 1;
110   unsigned x_uint = 1, y_uint = 1;
111   bool b;
112 
113   // Signed/unsigned mixed.
114   x43_u + y43_s;
115   x4_s - y4_u;
116   x43_s * y43_u;
117   x4_u / y4_s;
118 
119   // Different Sizes.
120   x43_s + y4_s;
121   x43_s - y4_u;
122   x43_u * y4_u;
123   x4_u / y43_u;
124 
125   // Mixed with standard types.
126   x43_s + x_int;
127   x43_u - x_int;
128   x32_s * x_int;
129   x32_u / x_int;
130   x32_s * x_uint;
131   x32_u / x_uint;
132   x4_s + x_int;
133   x4_u - x_int;
134   x4_s + b;
135   x4_u - b;
136   x43_s + b;
137   x43_u - b;
138   static_assert(is_same<decltype(x43_s + x_int), _BitInt(43)>::value, "");
139   static_assert(is_same<decltype(x43_u + x_int), unsigned _BitInt(43)>::value, "");
140   static_assert(is_same<decltype(x32_s + x_int), int>::value, "");
141   static_assert(is_same<decltype(x32_u + x_int), unsigned int>::value, "");
142   static_assert(is_same<decltype(x32_s + x_uint), unsigned int>::value, "");
143   static_assert(is_same<decltype(x32_u + x_uint), unsigned int>::value, "");
144   static_assert(is_same<decltype(x4_s + x_int), int>::value, "");
145   static_assert(is_same<decltype(x4_u + x_int), int>::value, "");
146   static_assert(is_same<decltype(x4_s + x_uint), unsigned int>::value, "");
147   static_assert(is_same<decltype(x4_u + x_uint), unsigned int>::value, "");
148 
149   // Bitwise checks.
150   x43_s % y4_u;
151   x43_u % y4_s;
152   x4_s | y43_u;
153   x4_u | y43_s;
154 
155   // compassign.
156   x43_s += 33;
157 
158   // Comparisons.
159   x43_s > 33;
160   x4_s > 33; // expected-warning {{result of comparison of constant 33 with expression of type '_BitInt(4)' is always false}}
161 
162   // Same size/sign ops don't change type.
163   static_assert(is_same<decltype(x43_s + y43_s), _BitInt(43)>::value,"");
164   static_assert(is_same<decltype(x4_s - y4_s), _BitInt(4)>::value,"");
165   static_assert(is_same<decltype(x43_u * y43_u), unsigned _BitInt(43)>::value,"");
166   static_assert(is_same<decltype(x4_u / y4_u), unsigned _BitInt(4)>::value,"");
167 
168   // Unary ops shouldn't go through integer promotions.
169   static_assert(is_same<decltype(~x43_s), _BitInt(43)>::value,"");
170   static_assert(is_same<decltype(~x4_s), _BitInt(4)>::value,"");
171   static_assert(is_same<decltype(+x43_s), _BitInt(43)>::value,"");
172   static_assert(is_same<decltype(+x4_s), _BitInt(4)>::value,"");
173   static_assert(is_same<decltype(-x43_u), unsigned _BitInt(43)>::value,"");
174   static_assert(is_same<decltype(-x4_u), unsigned _BitInt(4)>::value,"");
175   // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}
176   static_assert(is_same<decltype(++x43_s), _BitInt(43)&>::value,"");
177   // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}
178   static_assert(is_same<decltype(--x4_s), _BitInt(4)&>::value,"");
179   // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}
180   static_assert(is_same<decltype(x43_s--), _BitInt(43)>::value,"");
181   // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}
182   static_assert(is_same<decltype(x4_s++), _BitInt(4)>::value,"");
183   static_assert(is_same<decltype(x4_s >> 1), _BitInt(4)>::value,"");
184   static_assert(is_same<decltype(x4_u << 1), unsigned _BitInt(4)>::value,"");
185 
186   static_assert(sizeof(x43_s) == 8, "");
187   static_assert(sizeof(x4_s) == 1, "");
188 
189   static_assert(alignof(decltype(x43_s)) == 8, "");
190   static_assert(alignof(decltype(x4_s)) == 1, "");
191 }
192 
193 constexpr int func() { return 42;}
194 
195 void ConstexprBitsize() {
196   _BitInt(func()) F;
197   static_assert(is_same<decltype(F), _BitInt(42)>::value, "");
198 }
199 
200 // Useable as an underlying type.
201 enum AsEnumUnderlyingType : _BitInt(33) {
202 };
203 
204 void overloaded(int);
205 void overloaded(_BitInt(32));
206 void overloaded(_BitInt(33));
207 void overloaded(short);
208 //expected-note@+1{{candidate function}}
209 void overloaded2(_BitInt(32));
210 //expected-note@+1{{candidate function}}
211 void overloaded2(_BitInt(33));
212 //expected-note@+1{{candidate function}}
213 void overloaded2(short);
214 
215 void overload_use() {
216   int i;
217   _BitInt(32) i32;
218   _BitInt(33) i33;
219   short s;
220 
221   // All of these get their corresponding exact matches.
222   overloaded(i);
223   overloaded(i32);
224   overloaded(i33);
225   overloaded(s);
226 
227   overloaded2(i); // expected-error{{call to 'overloaded2' is ambiguous}}
228 
229   overloaded2(i32);
230 
231   overloaded2(s);
232 }
233 
234 // no errors expected, this should 'just work'.
235 struct UsedAsBitField {
236   _BitInt(3) F : 3;
237   _BitInt(3) G : 3;
238   _BitInt(3) H : 3;
239 };
240 
241 struct CursedBitField {
242   _BitInt(4) A : 8; // expected-warning {{width of bit-field 'A' (8 bits) exceeds the width of its type; value will be truncated to 4 bits}}
243 };
244 
245 // expected-error@+1{{mode attribute only supported for integer and floating-point types}}
246 typedef _BitInt(33) IllegalMode __attribute__((mode(DI)));
247 
248 void ImplicitCasts(_BitInt(31) s31, _BitInt(33) s33, int i) {
249   // expected-warning@+1{{implicit conversion loses integer precision}}
250   s31 = i;
251   // expected-warning@+1{{implicit conversion loses integer precision}}
252   s31 = s33;
253   s33 = i;
254   s33 = s31;
255   i = s31;
256   // expected-warning@+1{{implicit conversion loses integer precision}}
257   i = s33;
258 }
259 
260 void Ternary(_BitInt(30) s30, _BitInt(31) s31a, _BitInt(31) s31b,
261              _BitInt(32) s32, bool b) {
262   b ? s30 : s31a;
263   b ? s31a : s30;
264   b ? s32 : (int)0;
265   (void)(b ? s31a : s31b);
266   (void)(s30 ? s31a : s31b);
267 
268   static_assert(is_same<decltype(b ? s30 : s31a), _BitInt(31)>::value, "");
269   static_assert(is_same<decltype(b ? s32 : s30), _BitInt(32)>::value, "");
270   static_assert(is_same<decltype(b ? s30 : 0), int>::value, "");
271 }
272 
273 void FromPaper1() {
274   // Test the examples of conversion and promotion rules from C2x 6.3.1.8.
275   _BitInt(2) a2 = 1;
276   _BitInt(3) a3 = 2;
277   _BitInt(33) a33 = 1;
278   char c = 3;
279 
280   static_assert(is_same<decltype(a2 * a3), _BitInt(3)>::value, "");
281   static_assert(is_same<decltype(a2 * c), int>::value, "");
282   static_assert(is_same<decltype(a33 * c), _BitInt(33)>::value, "");
283 }
284 
285 void FromPaper2(_BitInt(8) a1, _BitInt(24) a2) {
286   static_assert(is_same<decltype(a1 * (_BitInt(32))a2), _BitInt(32)>::value, "");
287 }
288