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