1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// RUN: %clang_cc1 -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)));
}
|
