296 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s -Wimplicit-int-conversion -Wno-unused -Wunevaluated-expression -triple aarch64-unknown-unknown2 3template<int Bounds>4struct 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 55template <_BitInt(5) I>56struct ExtIntTemplParam {57 static constexpr _BitInt(5) Var = I;58};59 60template<typename T>61void deduced_whole_type(T){}62template<int I>63void deduced_bound(_BitInt(I)){}64 65// Ensure ext-int can be used in template places.66void 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 77template <typename T, typename U>78struct is_same {79 static constexpr bool value = false;80};81template <typename T>82struct is_same<T,T> {83 static constexpr bool value = true;84};85 86// Reject vector types:87// expected-error@+1{{'_BitInt' vector element width must be a power of 2}}88typedef _BitInt(5) __attribute__((vector_size(16))) VecTy3;89// expected-error@+1{{'_BitInt' vector element width must be a power of 2}}90typedef _BitInt(5) __attribute__((ext_vector_type(32))) OtherVecTy3;91// expected-error@+1{{'_BitInt' vector element width must be a power of 2}}92typedef _BitInt(37) __attribute__((vector_size(16))) VecTy4;93// expected-error@+1{{'_BitInt' vector element width must be a power of 2}}94typedef _BitInt(37) __attribute__((ext_vector_type(32))) OtherVecTy4;95 96// expected-error@+1{{'_Complex _BitInt' is invalid}}97_Complex _BitInt(3) Cmplx;98// expected-error@+1{{'_Complex _BitInt' is invalid}}99typedef _Complex _BitInt(3) Cmp;100 101// Reject cases of _Atomic:102// expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(4)'}}103_Atomic _BitInt(4) TooSmallAtomic;104// expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(9)'}}105_Atomic _BitInt(9) NotPow2Atomic;106// expected-error@+1{{_Atomic cannot be applied to integer type '_BitInt(128)'}}107_Atomic _BitInt(128) JustRightAtomic;108 109// Test result types of Unary/Bitwise/Binary Operations:110void Ops() {111 _BitInt(43) x43_s = 1, y43_s = 1;112 _BitInt(sizeof(int) * 8) x32_s = 1, y32_s = 1;113 unsigned _BitInt(sizeof(unsigned) * 8) x32_u = 1, y32_u = 1;114 _BitInt(4) x4_s = 1, y4_s = 1;115 unsigned _BitInt(43) x43_u = 1, y43_u = 1;116 unsigned _BitInt(4) x4_u = 1, y4_u = 1;117 int x_int = 1, y_int = 1;118 unsigned x_uint = 1, y_uint = 1;119 bool b;120 121 // Signed/unsigned mixed.122 x43_u + y43_s;123 x4_s - y4_u;124 x43_s * y43_u;125 x4_u / y4_s;126 127 // Different Sizes.128 x43_s + y4_s;129 x43_s - y4_u;130 x43_u * y4_u;131 x4_u / y43_u;132 133 // Mixed with standard types.134 x43_s + x_int;135 x43_u - x_int;136 x32_s * x_int;137 x32_u / x_int;138 x32_s * x_uint;139 x32_u / x_uint;140 x4_s + x_int;141 x4_u - x_int;142 x4_s + b;143 x4_u - b;144 x43_s + b;145 x43_u - b;146 static_assert(is_same<decltype(x43_s + x_int), _BitInt(43)>::value, "");147 static_assert(is_same<decltype(x43_u + x_int), unsigned _BitInt(43)>::value, "");148 static_assert(is_same<decltype(x32_s + x_int), int>::value, "");149 static_assert(is_same<decltype(x32_u + x_int), unsigned int>::value, "");150 static_assert(is_same<decltype(x32_s + x_uint), unsigned int>::value, "");151 static_assert(is_same<decltype(x32_u + x_uint), unsigned int>::value, "");152 static_assert(is_same<decltype(x4_s + x_int), int>::value, "");153 static_assert(is_same<decltype(x4_u + x_int), int>::value, "");154 static_assert(is_same<decltype(x4_s + x_uint), unsigned int>::value, "");155 static_assert(is_same<decltype(x4_u + x_uint), unsigned int>::value, "");156 157 // Bitwise checks.158 x43_s % y4_u;159 x43_u % y4_s;160 x4_s | y43_u;161 x4_u | y43_s;162 163 // compassign.164 x43_s += 33;165 166 // Comparisons.167 x43_s > 33;168 x4_s > 33; // expected-warning {{result of comparison of constant 33 with expression of type '_BitInt(4)' is always false}}169 170 // Same size/sign ops don't change type.171 static_assert(is_same<decltype(x43_s + y43_s), _BitInt(43)>::value,"");172 static_assert(is_same<decltype(x4_s - y4_s), _BitInt(4)>::value,"");173 static_assert(is_same<decltype(x43_u * y43_u), unsigned _BitInt(43)>::value,"");174 static_assert(is_same<decltype(x4_u / y4_u), unsigned _BitInt(4)>::value,"");175 176 // Unary ops shouldn't go through integer promotions.177 static_assert(is_same<decltype(~x43_s), _BitInt(43)>::value,"");178 static_assert(is_same<decltype(~x4_s), _BitInt(4)>::value,"");179 static_assert(is_same<decltype(+x43_s), _BitInt(43)>::value,"");180 static_assert(is_same<decltype(+x4_s), _BitInt(4)>::value,"");181 static_assert(is_same<decltype(-x43_u), unsigned _BitInt(43)>::value,"");182 static_assert(is_same<decltype(-x4_u), unsigned _BitInt(4)>::value,"");183 // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}184 static_assert(is_same<decltype(++x43_s), _BitInt(43)&>::value,"");185 // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}186 static_assert(is_same<decltype(--x4_s), _BitInt(4)&>::value,"");187 // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}188 static_assert(is_same<decltype(x43_s--), _BitInt(43)>::value,"");189 // expected-warning@+1{{expression with side effects has no effect in an unevaluated context}}190 static_assert(is_same<decltype(x4_s++), _BitInt(4)>::value,"");191 static_assert(is_same<decltype(x4_s >> 1), _BitInt(4)>::value,"");192 static_assert(is_same<decltype(x4_u << 1), unsigned _BitInt(4)>::value,"");193 194 static_assert(sizeof(x43_s) == 8, "");195 static_assert(sizeof(x4_s) == 1, "");196 197 static_assert(alignof(decltype(x43_s)) == 8, "");198 static_assert(alignof(decltype(x4_s)) == 1, "");199}200 201constexpr int func() { return 42;}202 203void ConstexprBitsize() {204 _BitInt(func()) F;205 static_assert(is_same<decltype(F), _BitInt(42)>::value, "");206}207 208// Not useable as an underlying type.209enum AsEnumUnderlyingType : _BitInt(33) { // expected-error{{'_BitInt(33)' is an invalid underlying type}}210};211 212void overloaded(int);213void overloaded(_BitInt(32));214void overloaded(_BitInt(33));215void overloaded(short);216//expected-note@+1{{candidate function}}217void overloaded2(_BitInt(32));218//expected-note@+1{{candidate function}}219void overloaded2(_BitInt(33));220//expected-note@+1{{candidate function}}221void overloaded2(short);222 223void overload_use() {224 int i;225 _BitInt(32) i32;226 _BitInt(33) i33;227 short s;228 229 // All of these get their corresponding exact matches.230 overloaded(i);231 overloaded(i32);232 overloaded(i33);233 overloaded(s);234 235 overloaded2(i); // expected-error{{call to 'overloaded2' is ambiguous}}236 237 overloaded2(i32);238 239 overloaded2(s);240}241 242// no errors expected, this should 'just work'.243struct UsedAsBitField {244 _BitInt(3) F : 3;245 _BitInt(3) G : 3;246 _BitInt(3) H : 3;247};248 249struct CursedBitField {250 _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}}251};252 253// expected-error@+1{{mode attribute only supported for integer and floating-point types}}254typedef _BitInt(33) IllegalMode __attribute__((mode(DI)));255 256void ImplicitCasts(_BitInt(31) s31, _BitInt(33) s33, int i) {257 // expected-warning@+1{{implicit conversion loses integer precision}}258 s31 = i;259 // expected-warning@+1{{implicit conversion loses integer precision}}260 s31 = s33;261 s33 = i;262 s33 = s31;263 i = s31;264 // expected-warning@+1{{implicit conversion loses integer precision}}265 i = s33;266}267 268void Ternary(_BitInt(30) s30, _BitInt(31) s31a, _BitInt(31) s31b,269 _BitInt(32) s32, bool b) {270 b ? s30 : s31a;271 b ? s31a : s30;272 b ? s32 : (int)0;273 (void)(b ? s31a : s31b);274 (void)(s30 ? s31a : s31b);275 276 static_assert(is_same<decltype(b ? s30 : s31a), _BitInt(31)>::value, "");277 static_assert(is_same<decltype(b ? s32 : s30), _BitInt(32)>::value, "");278 static_assert(is_same<decltype(b ? s30 : 0), int>::value, "");279}280 281void FromPaper1() {282 // Test the examples of conversion and promotion rules from C2x 6.3.1.8.283 _BitInt(2) a2 = 1;284 _BitInt(3) a3 = 2;285 _BitInt(33) a33 = 1;286 char c = 3;287 288 static_assert(is_same<decltype(a2 * a3), _BitInt(3)>::value, "");289 static_assert(is_same<decltype(a2 * c), int>::value, "");290 static_assert(is_same<decltype(a33 * c), _BitInt(33)>::value, "");291}292 293void FromPaper2(_BitInt(8) a1, _BitInt(24) a2) {294 static_assert(is_same<decltype(a1 * (_BitInt(32))a2), _BitInt(32)>::value, "");295}296