1 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -fms-extensions -std=c++11 -verify=expected,both %s 2 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -fms-extensions -std=c++20 -verify=expected,both %s 3 // RUN: %clang_cc1 -std=c++11 -fms-extensions -verify=ref,both %s 4 // RUN: %clang_cc1 -std=c++20 -fms-extensions -verify=ref,both %s 5 6 7 using MaxBitInt = _BitInt(128); 8 #define INT_MIN (~__INT_MAX__) 9 10 constexpr _BitInt(2) A = 0; 11 constexpr _BitInt(2) B = A + 1; 12 constexpr _BitInt(2) C = B + 1; // both-warning {{from 2 to -2}} 13 static_assert(C == -2, ""); 14 static_assert(C - B == A, ""); // both-error {{not an integral constant expression}} \ 15 // both-note {{value -3 is outside the range of representable values}} 16 17 static_assert(B - 1 == 0, ""); 18 19 constexpr MaxBitInt A_ = 0; 20 constexpr MaxBitInt B_ = A_ + 1; 21 static_assert(B_ == 1, ""); 22 23 constexpr MaxBitInt BitIntZero{}; 24 static_assert(BitIntZero == 0, ""); 25 constexpr unsigned _BitInt(128) UBitIntZero{}; 26 static_assert(UBitIntZero == 0, ""); 27 28 constexpr _BitInt(2) BitIntZero2{}; 29 static_assert(BitIntZero2 == 0, ""); 30 constexpr unsigned _BitInt(1) UBitIntZero1{}; 31 static_assert(UBitIntZero1 == 0, ""); 32 33 constexpr unsigned _BitInt(2) BI1 = 3u; 34 static_assert(BI1 == 3, ""); 35 36 constexpr _BitInt(4) MulA = 5; 37 constexpr _BitInt(4) MulB = 7; 38 static_assert(MulA * MulB == 50, ""); // both-error {{not an integral constant expression}} \ 39 // both-note {{value 35 is outside the range of representable values of type '_BitInt(4)'}} 40 static_assert(MulA * 5 == 25, ""); 41 static_assert(-1 * MulB == -7, ""); 42 43 44 constexpr _BitInt(4) DivA = 2; 45 constexpr _BitInt(2) DivB = 1; 46 static_assert(DivA / DivB == 2, ""); 47 48 constexpr _BitInt(4) DivC = DivA / 0; // both-error {{must be initialized by a constant expression}} \ 49 // both-note {{division by zero}} 50 51 constexpr _BitInt(7) RemA = 47; 52 constexpr _BitInt(6) RemB = 9; 53 static_assert(RemA % RemB == 2, ""); 54 static_assert(RemA % 0 == 1, ""); // both-error {{not an integral constant expression}} \ 55 // both-note {{division by zero}} 56 57 constexpr _BitInt(32) bottom = -1; 58 constexpr _BitInt(32) top = INT_MIN; 59 constexpr _BitInt(32) nope = top / bottom; // both-error {{must be initialized by a constant expression}} \ 60 // both-note {{value 2147483648 is outside the range}} 61 constexpr _BitInt(32) noooo = top % bottom; // both-error {{must be initialized by a constant expression}} \ 62 // both-note {{value 2147483648 is outside the range}} 63 64 namespace APCast { 65 constexpr _BitInt(10) A = 1; 66 constexpr _BitInt(11) B = A; 67 static_assert(B == 1, ""); 68 constexpr _BitInt(16) B2 = A; 69 static_assert(B2 == 1, ""); 70 constexpr _BitInt(32) B3 = A; 71 static_assert(B3 == 1, ""); 72 constexpr unsigned _BitInt(32) B4 = A; 73 static_assert(B4 == 1, ""); 74 } 75 76 #ifdef __SIZEOF_INT128__ 77 typedef __int128 int128_t; 78 typedef unsigned __int128 uint128_t; 79 static const __uint128_t UINT128_MAX =__uint128_t(__int128_t(-1L)); 80 static_assert(UINT128_MAX == -1, ""); 81 static_assert(UINT128_MAX == 1, ""); // both-error {{static assertion failed}} \ 82 // both-note {{'340282366920938463463374607431768211455 == 1'}} 83 84 static const __int128_t INT128_MAX = UINT128_MAX >> (__int128_t)1; 85 static_assert(INT128_MAX != 0, ""); 86 static_assert(INT128_MAX == 0, ""); // both-error {{failed}} \ 87 // both-note {{evaluates to '170141183460469231731687303715884105727 == 0'}} 88 static const __int128_t INT128_MIN = -INT128_MAX - 1; 89 90 91 namespace PointerArithmeticOverflow { 92 int n; 93 constexpr int *p = (&n + 1) + (unsigned __int128)-1; // both-error {{constant expression}} \ 94 // both-note {{cannot refer to element 3402}} 95 } 96 97 namespace i128 { 98 99 constexpr int128_t I128_1 = 12; 100 static_assert(I128_1 == 12, ""); 101 static_assert(I128_1 != 10, ""); 102 static_assert(I128_1 != 12, ""); // both-error{{failed}} \ 103 // both-note{{evaluates to}} 104 105 static const __uint128_t UINT128_MAX =__uint128_t(__int128_t(-1L)); 106 static_assert(UINT128_MAX == -1, ""); 107 static_assert(UINT128_MAX == 1, ""); // both-error {{static assertion failed}} \ 108 // both-note {{'340282366920938463463374607431768211455 == 1'}} 109 110 constexpr uint128_t TooMuch = UINT128_MAX * 2; 111 112 static const __int128_t INT128_MAX = UINT128_MAX >> (__int128_t)1; 113 static_assert(INT128_MAX != 0, ""); 114 static_assert(INT128_MAX == 0, ""); // both-error {{failed}} \ 115 // both-note {{evaluates to '170141183460469231731687303715884105727 == 0'}} 116 117 constexpr int128_t TooMuch2 = INT128_MAX * INT128_MAX; // both-error {{must be initialized by a constant expression}} \ 118 // both-note {{value 28948022309329048855892746252171976962977213799489202546401021394546514198529 is outside the range of representable}} 119 120 static const __int128_t INT128_MIN = -INT128_MAX - 1; 121 constexpr __int128 A = INT128_MAX + 1; // both-error {{must be initialized by a constant expression}} \ 122 // both-note {{value 170141183460469231731687303715884105728 is outside the range}} 123 constexpr int128_t Two = (int128_t)1 << 1ul; 124 static_assert(Two == 2, ""); 125 static_assert(Two, ""); 126 constexpr bool CastedToBool = Two; 127 static_assert(CastedToBool, ""); 128 129 constexpr uint128_t AllOnes = ~static_cast<uint128_t>(0); 130 static_assert(AllOnes == UINT128_MAX, ""); 131 132 constexpr uint128_t i128Zero{}; 133 static_assert(i128Zero == 0, ""); 134 constexpr uint128_t ui128Zero{}; 135 static_assert(ui128Zero == 0, ""); 136 137 138 enum LargeEnum : signed __int128 { 139 LV = (signed __int128)1 << 127, 140 }; 141 142 constexpr LargeEnum F = LV; 143 static_assert(F == (signed __int128)1 << 127, ""); 144 constexpr LargeEnum getLargeEnum() { 145 return LV; 146 } 147 static_assert(getLargeEnum() == (signed __int128)1 << 127, ""); 148 149 150 151 #if __cplusplus >= 201402L 152 template <typename T> 153 constexpr T CastFrom(__int128_t A) { 154 T B = (T)A; 155 return B; 156 } 157 static_assert(CastFrom<char>(12) == 12, ""); 158 static_assert(CastFrom<unsigned char>(12) == 12, ""); 159 static_assert(CastFrom<long>(12) == 12, ""); 160 static_assert(CastFrom<unsigned short>(12) == 12, ""); 161 static_assert(CastFrom<int128_t>(12) == 12, ""); 162 static_assert(CastFrom<float>(12) == 12, ""); 163 static_assert(CastFrom<double>(12) == 12, ""); 164 static_assert(CastFrom<long double>(12) == 12, ""); 165 166 static_assert(CastFrom<char>(AllOnes) == -1, ""); 167 static_assert(CastFrom<unsigned char>(AllOnes) == 0xFF, ""); 168 static_assert(CastFrom<long>(AllOnes) == -1, ""); 169 static_assert(CastFrom<unsigned short>(AllOnes) == 0xFFFF, ""); 170 static_assert(CastFrom<int>(AllOnes) == -1, ""); 171 static_assert(CastFrom<int128_t>(AllOnes) == -1, ""); 172 static_assert(CastFrom<uint128_t>(AllOnes) == AllOnes, ""); 173 174 template <typename T> 175 constexpr __int128 CastTo(T A) { 176 int128_t B = (int128_t)A; 177 return B; 178 } 179 static_assert(CastTo<char>(12) == 12, ""); 180 static_assert(CastTo<unsigned char>(12) == 12, ""); 181 static_assert(CastTo<long>(12) == 12, ""); 182 static_assert(CastTo<unsigned long long>(12) == 12, ""); 183 static_assert(CastTo<float>(12) == 12, ""); 184 static_assert(CastTo<double>(12) == 12, ""); 185 static_assert(CastTo<long double>(12) == 12, ""); 186 #endif 187 188 constexpr int128_t Error = __LDBL_MAX__; // both-warning {{implicit conversion of out of range value}} \ 189 // both-error {{must be initialized by a constant expression}} \ 190 // both-note {{is outside the range of representable values of type}} 191 192 constexpr uint128_t Zero = 0; 193 static_assert((Zero -1) == -1, ""); 194 constexpr int128_t Five = 5; 195 static_assert(Five - Zero == Five, ""); 196 197 constexpr int128_t Sub1 = INT128_MIN - 1; // both-error {{must be initialized by a constant expression}} \ 198 // both-note {{-170141183460469231731687303715884105729 is outside the range}} 199 } 200 201 namespace AddSubOffset { 202 constexpr __int128 A = 1; 203 constexpr int arr[] = {1,2,3}; 204 constexpr const int *P = arr + A; 205 static_assert(*P == 2, ""); 206 constexpr const int *P2 = P - A; 207 static_assert(*P2 == 1,""); 208 } 209 210 namespace Bitfields { 211 struct S1 { 212 unsigned _BitInt(128) a : 2; 213 }; 214 constexpr S1 s1{100}; // both-warning {{changes value from 100 to 0}} 215 constexpr S1 s12{3}; 216 static_assert(s12.a == 3, ""); 217 218 struct S2 { 219 unsigned __int128 a : 2; 220 }; 221 constexpr S2 s2{100}; // both-warning {{changes value from 100 to 0}} 222 } 223 224 namespace BitOps { 225 constexpr unsigned __int128 UZero = 0; 226 constexpr unsigned __int128 Max = ~UZero; 227 static_assert(Max == ~0, ""); 228 static_assert((Max & 0) == 0, ""); 229 static_assert((UZero | 0) == 0, ""); 230 static_assert((Max ^ Max) == 0, ""); 231 static_assert((Max & 1) == 1, ""); 232 static_assert((UZero | 1) == 1, ""); 233 static_assert((Max ^ UZero) == Max, ""); 234 } 235 236 namespace IncDec { 237 #if __cplusplus >= 201402L 238 constexpr int128_t maxPlus1(bool Pre) { 239 int128_t a = INT128_MAX; 240 241 if (Pre) 242 ++a; // both-note {{value 170141183460469231731687303715884105728 is outside the range}} 243 else 244 a++; // both-note {{value 170141183460469231731687303715884105728 is outside the range}} 245 return a; 246 } 247 static_assert(maxPlus1(true) == 0, ""); // both-error {{not an integral constant expression}} \ 248 // both-note {{in call to}} 249 static_assert(maxPlus1(false) == 0, ""); // both-error {{not an integral constant expression}} \ 250 // both-note {{in call to}} 251 252 constexpr int128_t inc1(bool Pre) { 253 int128_t A = 0; 254 if (Pre) 255 ++A; 256 else 257 A++; 258 return A; 259 } 260 static_assert(inc1(true) == 1, ""); 261 static_assert(inc1(false) == 1, ""); 262 263 constexpr int128_t dec1(bool Pre) { 264 int128_t A = 2; 265 if (Pre) 266 --A; 267 else 268 A--; 269 return A; 270 } 271 static_assert(dec1(true) == 1, ""); 272 static_assert(dec1(false) == 1, ""); 273 #endif 274 } 275 276 #endif 277