1 // RUN: %clang_cc1 -triple aarch64-unknown-unknown -std=c2x -fsyntax-only -verify -Wno-unused %s
2
3 // Test that the preprocessor behavior makes sense.
4 #if 1wb != 1
5 #error "wb suffix must be recognized by preprocessor"
6 #endif
7 #if 1uwb != 1
8 #error "uwb suffix must be recognized by preprocessor"
9 #endif
10 #if !(-1wb < 0)
11 #error "wb suffix must be interpreted as signed"
12 #endif
13 #if !(-1uwb > 0)
14 #error "uwb suffix must be interpreted as unsigned"
15 #endif
16
17 #if 18446744073709551615uwb != 18446744073709551615ULL
18 #error "expected the max value for uintmax_t to compare equal"
19 #endif
20
21 // Test that the preprocessor gives appropriate diagnostics when the
22 // 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 #endif
26 #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 #endif
29
30 // Despite using a bit-precise integer, this is expected to overflow
31 // because all preprocessor arithmetic is done in [u]intmax_t, so this
32 // should result in the value 0.
33 #if 18446744073709551615uwb + 1 != 0ULL
34 #error "expected modulo arithmetic with uintmax_t width"
35 #endif
36
37 // Because this bit-precise integer is signed, it will also overflow,
38 // but Clang handles that by converting to uintmax_t instead of
39 // 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 #endif
43
44 // Test that just because the preprocessor can't figure out the bit
45 // width doesn't mean we can't form the constant, it just means we
46 // can't use the value in a preprocessor conditional.
47 unsigned _BitInt(65) Val = 18446744073709551616uwb;
48
ValidSuffix(void)49 void 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 any
98 // integer type, and that includes _BitInt.
99 1iwb;
100 1wbj;
101 }
102
InvalidSuffix(void)103 void 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
ValidSuffixInvalidValue(void)135 void ValidSuffixInvalidValue(void) {
136 // This is a valid suffix, but the value is larger than one that fits within
137 // the width of BITINT_MAXWIDTH. When this value changes in the future, the
138 // 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
TestTypes(void)146 void TestTypes(void) {
147 // 2 value bits, one sign bit
148 _Static_assert(__builtin_types_compatible_p(__typeof__(3wb), _BitInt(3)));
149 // 2 value bits, one sign bit
150 _Static_assert(__builtin_types_compatible_p(__typeof__(-3wb), _BitInt(3)));
151 // 2 value bits, no sign bit
152 _Static_assert(__builtin_types_compatible_p(__typeof__(3uwb), unsigned _BitInt(2)));
153 // 4 value bits, one sign bit
154 _Static_assert(__builtin_types_compatible_p(__typeof__(0xFwb), _BitInt(5)));
155 // 4 value bits, one sign bit
156 _Static_assert(__builtin_types_compatible_p(__typeof__(-0xFwb), _BitInt(5)));
157 // 4 value bits, no sign bit
158 _Static_assert(__builtin_types_compatible_p(__typeof__(0xFuwb), unsigned _BitInt(4)));
159 }
160