| // RUN: %clang_cc1 -triple aarch64-unknown-unknown -std=c2x -fsyntax-only -verify -Wno-unused %s |
| |
| // Test that the preprocessor behavior makes sense. |
| #if 1wb != 1 |
| #error "wb suffix must be recognized by preprocessor" |
| #endif |
| #if 1uwb != 1 |
| #error "uwb suffix must be recognized by preprocessor" |
| #endif |
| #if !(-1wb < 0) |
| #error "wb suffix must be interpreted as signed" |
| #endif |
| #if !(-1uwb > 0) |
| #error "uwb suffix must be interpreted as unsigned" |
| #endif |
| |
| #if 18446744073709551615uwb != 18446744073709551615ULL |
| #error "expected the max value for uintmax_t to compare equal" |
| #endif |
| |
| // Test that the preprocessor gives appropriate diagnostics when the |
| // literal value is larger than what can be stored in a [u]intmax_t. |
| #if 18446744073709551616wb != 0ULL // expected-error {{integer literal is too large to be represented in any integer type}} |
| #error "never expected to get here due to error" |
| #endif |
| #if 18446744073709551616uwb != 0ULL // expected-error {{integer literal is too large to be represented in any integer type}} |
| #error "never expected to get here due to error" |
| #endif |
| |
| // Despite using a bit-precise integer, this is expected to overflow |
| // because all preprocessor arithmetic is done in [u]intmax_t, so this |
| // should result in the value 0. |
| #if 18446744073709551615uwb + 1 != 0ULL |
| #error "expected modulo arithmetic with uintmax_t width" |
| #endif |
| |
| // Because this bit-precise integer is signed, it will also overflow, |
| // but Clang handles that by converting to uintmax_t instead of |
| // intmax_t. |
| #if 18446744073709551615wb + 1 != 0LL // expected-warning {{integer literal is too large to be represented in a signed integer type, interpreting as unsigned}} |
| #error "expected modulo arithmetic with uintmax_t width" |
| #endif |
| |
| // Test that just because the preprocessor can't figure out the bit |
| // width doesn't mean we can't form the constant, it just means we |
| // can't use the value in a preprocessor conditional. |
| unsigned _BitInt(65) Val = 18446744073709551616uwb; |
| |
| void ValidSuffix(void) { |
| // Decimal literals. |
| 1wb; |
| 1WB; |
| -1wb; |
| _Static_assert((int)1wb == 1, "not 1?"); |
| _Static_assert((int)-1wb == -1, "not -1?"); |
| |
| 1uwb; |
| 1uWB; |
| 1Uwb; |
| 1UWB; |
| _Static_assert((unsigned int)1uwb == 1u, "not 1?"); |
| |
| 1'2wb; |
| 1'2uwb; |
| _Static_assert((int)1'2wb == 12, "not 12?"); |
| _Static_assert((unsigned int)1'2uwb == 12u, "not 12?"); |
| |
| // Hexadecimal literals. |
| 0x1wb; |
| 0x1uwb; |
| 0x0'1'2'3wb; |
| 0xA'B'c'duwb; |
| _Static_assert((int)0x0'1'2'3wb == 0x0123, "not 0x0123"); |
| _Static_assert((unsigned int)0xA'B'c'duwb == 0xABCDu, "not 0xABCD"); |
| |
| // Binary literals. |
| 0b1wb; |
| 0b1uwb; |
| 0b1'0'1'0'0'1wb; |
| 0b0'1'0'1'1'0uwb; |
| _Static_assert((int)0b1wb == 1, "not 1?"); |
| _Static_assert((unsigned int)0b1uwb == 1u, "not 1?"); |
| |
| // Octal literals. |
| 01wb; |
| 01uwb; |
| 0'6'0wb; |
| 0'0'1uwb; |
| 0wbu; |
| 0WBu; |
| 0wbU; |
| 0WBU; |
| 0wb; |
| _Static_assert((int)0wb == 0, "not 0?"); |
| _Static_assert((unsigned int)0wbu == 0u, "not 0?"); |
| |
| // Imaginary or Complex. These are allowed because _Complex can work with any |
| // integer type, and that includes _BitInt. |
| 1iwb; |
| 1wbj; |
| } |
| |
| void InvalidSuffix(void) { |
| // Can't mix the case of wb or WB, and can't rearrange the letters. |
| 0wB; // expected-error {{invalid suffix 'wB' on integer constant}} |
| 0Wb; // expected-error {{invalid suffix 'Wb' on integer constant}} |
| 0bw; // expected-error {{invalid digit 'b' in octal constant}} |
| 0BW; // expected-error {{invalid digit 'B' in octal constant}} |
| |
| // Trailing digit separators should still diagnose. |
| 1'2'wb; // expected-error {{digit separator cannot appear at end of digit sequence}} |
| 1'2'uwb; // expected-error {{digit separator cannot appear at end of digit sequence}} |
| |
| // Long. |
| 1lwb; // expected-error {{invalid suffix}} |
| 1wbl; // expected-error {{invalid suffix}} |
| 1luwb; // expected-error {{invalid suffix}} |
| 1ulwb; // expected-error {{invalid suffix}} |
| |
| // Long long. |
| 1llwb; // expected-error {{invalid suffix}} |
| 1uwbll; // expected-error {{invalid suffix}} |
| |
| // Floating point. |
| 0.1wb; // expected-error {{invalid suffix}} |
| 0.1fwb; // expected-error {{invalid suffix}} |
| |
| // Repetitive suffix. |
| 1wbwb; // expected-error {{invalid suffix}} |
| 1uwbuwb; // expected-error {{invalid suffix}} |
| 1wbuwb; // expected-error {{invalid suffix}} |
| 1uwbwb; // expected-error {{invalid suffix}} |
| } |
| |
| void ValidSuffixInvalidValue(void) { |
| // This is a valid suffix, but the value is larger than one that fits within |
| // the width of BITINT_MAXWIDTH. When this value changes in the future, the |
| // test cases should pick a new value that can't be represented by a _BitInt, |
| // but also add a test case that a 129-bit literal still behaves as-expected. |
| _Static_assert(__BITINT_MAXWIDTH__ <= 128, |
| "Need to pick a bigger constant for the test case below."); |
| 0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1wb; // expected-error {{integer literal is too large to be represented in any signed integer type}} |
| 0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1uwb; // expected-error {{integer literal is too large to be represented in any integer type}} |
| } |
| |
| void TestTypes(void) { |
| // 2 value bits, one sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(3wb), _BitInt(3))); |
| // 2 value bits, one sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(-3wb), _BitInt(3))); |
| // 2 value bits, no sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(3uwb), unsigned _BitInt(2))); |
| // 4 value bits, one sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(0xFwb), _BitInt(5))); |
| // 4 value bits, one sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(-0xFwb), _BitInt(5))); |
| // 4 value bits, no sign bit |
| _Static_assert(__builtin_types_compatible_p(__typeof__(0xFuwb), unsigned _BitInt(4))); |
| } |