160 lines · c
1// RUN: %clang_cc1 -triple aarch64-unknown-unknown -std=c2x -fsyntax-only -verify -Wno-unused %s2 3// Test that the preprocessor behavior makes sense.4#if 1wb != 15#error "wb suffix must be recognized by preprocessor"6#endif7#if 1uwb != 18#error "uwb suffix must be recognized by preprocessor"9#endif10#if !(-1wb < 0)11#error "wb suffix must be interpreted as signed"12#endif13#if !(-1uwb > 0)14#error "uwb suffix must be interpreted as unsigned"15#endif16 17#if 18446744073709551615uwb != 18446744073709551615ULL18#error "expected the max value for uintmax_t to compare equal"19#endif20 21// Test that the preprocessor gives appropriate diagnostics when the22// literal value is larger than what can be stored in a [u]intmax_t.23#if 18446744073709551616wb != 0ULL // expected-error {{integer literal is too large to be represented in any integer type}}24#error "never expected to get here due to error"25#endif26#if 18446744073709551616uwb != 0ULL // expected-error {{integer literal is too large to be represented in any integer type}}27#error "never expected to get here due to error"28#endif29 30// Despite using a bit-precise integer, this is expected to overflow31// because all preprocessor arithmetic is done in [u]intmax_t, so this32// should result in the value 0.33#if 18446744073709551615uwb + 1 != 0ULL34#error "expected modulo arithmetic with uintmax_t width"35#endif36 37// Because this bit-precise integer is signed, it will also overflow,38// but Clang handles that by converting to uintmax_t instead of39// intmax_t.40#if 18446744073709551615wb + 1 != 0LL // expected-warning {{integer literal is too large to be represented in a signed integer type, interpreting as unsigned}}41#error "expected modulo arithmetic with uintmax_t width"42#endif43 44// Test that just because the preprocessor can't figure out the bit45// width doesn't mean we can't form the constant, it just means we46// can't use the value in a preprocessor conditional.47unsigned _BitInt(65) Val = 18446744073709551616uwb;48 49void ValidSuffix(void) {50 // Decimal literals.51 1wb;52 1WB;53 -1wb;54 _Static_assert((int)1wb == 1, "not 1?");55 _Static_assert((int)-1wb == -1, "not -1?");56 57 1uwb;58 1uWB;59 1Uwb;60 1UWB;61 _Static_assert((unsigned int)1uwb == 1u, "not 1?");62 63 1'2wb;64 1'2uwb;65 _Static_assert((int)1'2wb == 12, "not 12?");66 _Static_assert((unsigned int)1'2uwb == 12u, "not 12?");67 68 // Hexadecimal literals.69 0x1wb;70 0x1uwb;71 0x0'1'2'3wb;72 0xA'B'c'duwb;73 _Static_assert((int)0x0'1'2'3wb == 0x0123, "not 0x0123");74 _Static_assert((unsigned int)0xA'B'c'duwb == 0xABCDu, "not 0xABCD");75 76 // Binary literals.77 0b1wb;78 0b1uwb;79 0b1'0'1'0'0'1wb;80 0b0'1'0'1'1'0uwb;81 _Static_assert((int)0b1wb == 1, "not 1?");82 _Static_assert((unsigned int)0b1uwb == 1u, "not 1?");83 84 // Octal literals.85 01wb;86 01uwb;87 0'6'0wb;88 0'0'1uwb;89 0wbu;90 0WBu;91 0wbU;92 0WBU;93 0wb;94 _Static_assert((int)0wb == 0, "not 0?");95 _Static_assert((unsigned int)0wbu == 0u, "not 0?");96 97 // Imaginary or Complex. These are allowed because _Complex can work with any98 // integer type, and that includes _BitInt.99 1iwb;100 1wbj;101}102 103void InvalidSuffix(void) {104 // Can't mix the case of wb or WB, and can't rearrange the letters.105 0wB; // expected-error {{invalid suffix 'wB' on integer constant}}106 0Wb; // expected-error {{invalid suffix 'Wb' on integer constant}}107 0bw; // expected-error {{invalid digit 'b' in octal constant}}108 0BW; // expected-error {{invalid digit 'B' in octal constant}}109 110 // Trailing digit separators should still diagnose.111 1'2'wb; // expected-error {{digit separator cannot appear at end of digit sequence}}112 1'2'uwb; // expected-error {{digit separator cannot appear at end of digit sequence}}113 114 // Long.115 1lwb; // expected-error {{invalid suffix}}116 1wbl; // expected-error {{invalid suffix}}117 1luwb; // expected-error {{invalid suffix}}118 1ulwb; // expected-error {{invalid suffix}}119 120 // Long long.121 1llwb; // expected-error {{invalid suffix}}122 1uwbll; // expected-error {{invalid suffix}}123 124 // Floating point.125 0.1wb; // expected-error {{invalid suffix}}126 0.1fwb; // expected-error {{invalid suffix}}127 128 // Repetitive suffix.129 1wbwb; // expected-error {{invalid suffix}}130 1uwbuwb; // expected-error {{invalid suffix}}131 1wbuwb; // expected-error {{invalid suffix}}132 1uwbwb; // expected-error {{invalid suffix}}133}134 135void ValidSuffixInvalidValue(void) {136 // This is a valid suffix, but the value is larger than one that fits within137 // the width of BITINT_MAXWIDTH. When this value changes in the future, the138 // test cases should pick a new value that can't be represented by a _BitInt,139 // but also add a test case that a 129-bit literal still behaves as-expected.140 _Static_assert(__BITINT_MAXWIDTH__ <= 128,141 "Need to pick a bigger constant for the test case below.");142 0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1wb; // expected-error {{integer literal is too large to be represented in any signed integer type}}143 0xFFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'FFFF'1uwb; // expected-error {{integer literal is too large to be represented in any integer type}}144}145 146void TestTypes(void) {147 // 2 value bits, one sign bit148 _Static_assert(__builtin_types_compatible_p(__typeof__(3wb), _BitInt(3)));149 // 2 value bits, one sign bit150 _Static_assert(__builtin_types_compatible_p(__typeof__(-3wb), _BitInt(3)));151 // 2 value bits, no sign bit152 _Static_assert(__builtin_types_compatible_p(__typeof__(3uwb), unsigned _BitInt(2)));153 // 4 value bits, one sign bit154 _Static_assert(__builtin_types_compatible_p(__typeof__(0xFwb), _BitInt(5)));155 // 4 value bits, one sign bit156 _Static_assert(__builtin_types_compatible_p(__typeof__(-0xFwb), _BitInt(5)));157 // 4 value bits, no sign bit158 _Static_assert(__builtin_types_compatible_p(__typeof__(0xFuwb), unsigned _BitInt(4)));159}160