1 //=== - llvm/unittest/Support/Alignment.cpp - Alignment utility tests -----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/Support/Alignment.h"
10 #include "gtest/gtest.h"
11
12 #include <vector>
13
14 #ifdef _MSC_VER
15 // Disable warnings about potential divide by 0.
16 #pragma warning(push)
17 #pragma warning(disable : 4723)
18 #endif
19
20 using namespace llvm;
21
22 namespace {
23
TEST(AlignmentTest,AlignOfConstant)24 TEST(AlignmentTest, AlignOfConstant) {
25 EXPECT_EQ(Align::Of<uint8_t>(), Align(alignof(uint8_t)));
26 EXPECT_EQ(Align::Of<uint16_t>(), Align(alignof(uint16_t)));
27 EXPECT_EQ(Align::Of<uint32_t>(), Align(alignof(uint32_t)));
28 EXPECT_EQ(Align::Of<uint64_t>(), Align(alignof(uint64_t)));
29 }
30
TEST(AlignmentTest,AlignConstant)31 TEST(AlignmentTest, AlignConstant) {
32 EXPECT_EQ(Align::Constant<1>(), Align(1));
33 EXPECT_EQ(Align::Constant<2>(), Align(2));
34 EXPECT_EQ(Align::Constant<4>(), Align(4));
35 EXPECT_EQ(Align::Constant<8>(), Align(8));
36 EXPECT_EQ(Align::Constant<16>(), Align(16));
37 EXPECT_EQ(Align::Constant<32>(), Align(32));
38 EXPECT_EQ(Align::Constant<64>(), Align(64));
39 }
40
TEST(AlignmentTest,AlignConstexprConstant)41 TEST(AlignmentTest, AlignConstexprConstant) {
42 constexpr Align kConstantAlign = Align::Of<uint64_t>();
43 EXPECT_EQ(Align(alignof(uint64_t)), kConstantAlign);
44 }
45
getValidAlignments()46 std::vector<uint64_t> getValidAlignments() {
47 std::vector<uint64_t> Out;
48 for (size_t Shift = 0; Shift < 64; ++Shift)
49 Out.push_back(1ULL << Shift);
50 return Out;
51 }
52
TEST(AlignmentTest,AlignDefaultCTor)53 TEST(AlignmentTest, AlignDefaultCTor) {
54 EXPECT_EQ(Align().value(), 1ULL);
55 }
56
TEST(AlignmentTest,MaybeAlignDefaultCTor)57 TEST(AlignmentTest, MaybeAlignDefaultCTor) {
58 EXPECT_FALSE(MaybeAlign().hasValue());
59 }
60
TEST(AlignmentTest,ValidCTors)61 TEST(AlignmentTest, ValidCTors) {
62 for (uint64_t Value : getValidAlignments()) {
63 EXPECT_EQ(Align(Value).value(), Value);
64 EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
65 }
66 }
67
TEST(AlignmentTest,CheckMaybeAlignHasValue)68 TEST(AlignmentTest, CheckMaybeAlignHasValue) {
69 EXPECT_TRUE(MaybeAlign(1));
70 EXPECT_TRUE(MaybeAlign(1).hasValue());
71 EXPECT_FALSE(MaybeAlign(0));
72 EXPECT_FALSE(MaybeAlign(0).hasValue());
73 EXPECT_FALSE(MaybeAlign());
74 EXPECT_FALSE(MaybeAlign().hasValue());
75 }
76
TEST(AlignmentTest,Division)77 TEST(AlignmentTest, Division) {
78 for (uint64_t Value : getValidAlignments()) {
79 if (Value > 1) {
80 EXPECT_EQ(Align(Value) / 2, Value / 2);
81 EXPECT_EQ(MaybeAlign(Value) / 2, Value / 2);
82 }
83 }
84 EXPECT_EQ(MaybeAlign(0) / 2, MaybeAlign(0));
85 }
86
TEST(AlignmentTest,AlignTo)87 TEST(AlignmentTest, AlignTo) {
88 struct {
89 uint64_t alignment;
90 uint64_t offset;
91 uint64_t rounded;
92 const void *forgedAddr() const {
93 // A value of any integral or enumeration type can be converted to a
94 // pointer type.
95 return reinterpret_cast<const void *>(offset);
96 }
97 } kTests[] = {
98 // MaybeAlign
99 {0, 0, 0},
100 {0, 1, 1},
101 {0, 5, 5},
102 // MaybeAlign / Align
103 {1, 0, 0},
104 {1, 1, 1},
105 {1, 5, 5},
106 {2, 0, 0},
107 {2, 1, 2},
108 {2, 2, 2},
109 {2, 7, 8},
110 {2, 16, 16},
111 {4, 0, 0},
112 {4, 1, 4},
113 {4, 4, 4},
114 {4, 6, 8},
115 };
116 for (const auto &T : kTests) {
117 MaybeAlign A(T.alignment);
118 // Test MaybeAlign
119 EXPECT_EQ(alignTo(T.offset, A), T.rounded);
120 // Test Align
121 if (A) {
122 EXPECT_EQ(alignTo(T.offset, A.getValue()), T.rounded);
123 EXPECT_EQ(alignAddr(T.forgedAddr(), A.getValue()), T.rounded);
124 }
125 }
126 }
127
TEST(AlignmentTest,AlignToWithSkew)128 TEST(AlignmentTest, AlignToWithSkew) {
129 EXPECT_EQ(alignTo(5, Align(8), 0), alignTo(5, Align(8)));
130 EXPECT_EQ(alignTo(5, Align(8), 7), 7U);
131 EXPECT_EQ(alignTo(17, Align(8), 1), 17U);
132 EXPECT_EQ(alignTo(~0LL, Align(8), 3), 3U);
133 }
134
TEST(AlignmentTest,Log2)135 TEST(AlignmentTest, Log2) {
136 for (uint64_t Value : getValidAlignments()) {
137 EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
138 }
139 }
140
TEST(AlignmentTest,MinAlign)141 TEST(AlignmentTest, MinAlign) {
142 struct {
143 uint64_t A;
144 uint64_t B;
145 uint64_t MinAlign;
146 } kTests[] = {
147 // MaybeAlign
148 {0, 0, 0},
149 {0, 8, 8},
150 {2, 0, 2},
151 // MaybeAlign / Align
152 {1, 2, 1},
153 {8, 4, 4},
154 };
155 for (const auto &T : kTests) {
156 EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
157 EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
158 if (T.A) {
159 EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
160 }
161 if (T.B) {
162 EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
163 }
164 if (T.A && T.B) {
165 EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
166 }
167 }
168 }
169
TEST(AlignmentTest,Encode_Decode)170 TEST(AlignmentTest, Encode_Decode) {
171 for (uint64_t Value : getValidAlignments()) {
172 {
173 Align Actual(Value);
174 Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
175 EXPECT_EQ(Expected, Actual);
176 }
177 {
178 MaybeAlign Actual(Value);
179 MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
180 EXPECT_EQ(Expected, Actual);
181 }
182 }
183 MaybeAlign Actual(0);
184 MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
185 EXPECT_EQ(Expected, Actual);
186 }
187
TEST(AlignmentTest,isAligned_isAddrAligned)188 TEST(AlignmentTest, isAligned_isAddrAligned) {
189 struct {
190 uint64_t alignment;
191 uint64_t offset;
192 bool isAligned;
193 const void *forgedAddr() const {
194 // A value of any integral or enumeration type can be converted to a
195 // pointer type.
196 return reinterpret_cast<const void *>(offset);
197 }
198 } kTests[] = {
199 {1, 0, true}, {1, 1, true}, {1, 5, true}, {2, 0, true},
200 {2, 1, false}, {2, 2, true}, {2, 7, false}, {2, 16, true},
201 {4, 0, true}, {4, 1, false}, {4, 4, true}, {4, 6, false},
202 };
203 for (const auto &T : kTests) {
204 MaybeAlign A(T.alignment);
205 // Test Align
206 if (A) {
207 EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
208 EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
209 }
210 }
211 }
212
TEST(AlignmentTest,offsetToAlignment)213 TEST(AlignmentTest, offsetToAlignment) {
214 struct {
215 uint64_t alignment;
216 uint64_t offset;
217 uint64_t alignedOffset;
218 const void *forgedAddr() const {
219 // A value of any integral or enumeration type can be converted to a
220 // pointer type.
221 return reinterpret_cast<const void *>(offset);
222 }
223 } kTests[] = {
224 {1, 0, 0}, {1, 1, 0}, {1, 5, 0}, {2, 0, 0}, {2, 1, 1}, {2, 2, 0},
225 {2, 7, 1}, {2, 16, 0}, {4, 0, 0}, {4, 1, 3}, {4, 4, 0}, {4, 6, 2},
226 };
227 for (const auto &T : kTests) {
228 const Align A(T.alignment);
229 EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
230 EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
231 }
232 }
233
TEST(AlignmentTest,AlignComparisons)234 TEST(AlignmentTest, AlignComparisons) {
235 std::vector<uint64_t> ValidAlignments = getValidAlignments();
236 std::sort(ValidAlignments.begin(), ValidAlignments.end());
237 for (size_t I = 1; I < ValidAlignments.size(); ++I) {
238 assert(I >= 1);
239 const Align A(ValidAlignments[I - 1]);
240 const Align B(ValidAlignments[I]);
241 EXPECT_EQ(A, A);
242 EXPECT_NE(A, B);
243 EXPECT_LT(A, B);
244 EXPECT_GT(B, A);
245 EXPECT_LE(A, B);
246 EXPECT_GE(B, A);
247 EXPECT_LE(A, A);
248 EXPECT_GE(A, A);
249
250 EXPECT_EQ(A, A.value());
251 EXPECT_NE(A, B.value());
252 EXPECT_LT(A, B.value());
253 EXPECT_GT(B, A.value());
254 EXPECT_LE(A, B.value());
255 EXPECT_GE(B, A.value());
256 EXPECT_LE(A, A.value());
257 EXPECT_GE(A, A.value());
258
259 EXPECT_EQ(std::max(A, B), B);
260 EXPECT_EQ(std::min(A, B), A);
261
262 const MaybeAlign MA(ValidAlignments[I - 1]);
263 const MaybeAlign MB(ValidAlignments[I]);
264 EXPECT_EQ(MA, MA);
265 EXPECT_NE(MA, MB);
266
267 EXPECT_EQ(MA, MA ? (*MA).value() : 0);
268 EXPECT_NE(MA, MB ? (*MB).value() : 0);
269
270 EXPECT_EQ(std::max(A, B), B);
271 EXPECT_EQ(std::min(A, B), A);
272 }
273 }
274
TEST(AlignmentTest,Max)275 TEST(AlignmentTest, Max) {
276 // We introduce std::max here to test ADL.
277 using std::max;
278
279 // Uses llvm::max.
280 EXPECT_EQ(max(MaybeAlign(), Align(2)), Align(2));
281 EXPECT_EQ(max(Align(2), MaybeAlign()), Align(2));
282
283 EXPECT_EQ(max(MaybeAlign(1), Align(2)), Align(2));
284 EXPECT_EQ(max(Align(2), MaybeAlign(1)), Align(2));
285
286 EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2));
287 EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2));
288
289 EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4));
290 EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4));
291
292 // Uses std::max.
293 EXPECT_EQ(max(Align(2), Align(4)), Align(4));
294 }
295
TEST(AlignmentTest,AssumeAligned)296 TEST(AlignmentTest, AssumeAligned) {
297 EXPECT_EQ(assumeAligned(0), Align(1));
298 EXPECT_EQ(assumeAligned(0), Align());
299 EXPECT_EQ(assumeAligned(1), Align(1));
300 EXPECT_EQ(assumeAligned(1), Align());
301 }
302
303 // Death tests reply on assert which is disabled in release mode.
304 #ifndef NDEBUG
305
306 // We use a subset of valid alignments for DEATH_TESTs as they are particularly
307 // slow.
getValidAlignmentsForDeathTest()308 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
309 return {1, 1ULL << 31, 1ULL << 63};
310 }
311
getNonPowerOfTwo()312 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
313
TEST(AlignmentDeathTest,CantConvertUnsetMaybe)314 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
315 EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
316 }
317
TEST(AlignmentDeathTest,Division)318 TEST(AlignmentDeathTest, Division) {
319 EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment");
320 EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
321
322 EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
323 EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
324 }
325
TEST(AlignmentDeathTest,InvalidCTors)326 TEST(AlignmentDeathTest, InvalidCTors) {
327 EXPECT_DEATH((Align(0)), "Value must not be 0");
328 for (uint64_t Value : getNonPowerOfTwo()) {
329 EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
330 EXPECT_DEATH((MaybeAlign(Value)),
331 "Alignment is neither 0 nor a power of 2");
332 }
333 }
334
TEST(AlignmentDeathTest,ComparisonsWithZero)335 TEST(AlignmentDeathTest, ComparisonsWithZero) {
336 for (uint64_t Value : getValidAlignmentsForDeathTest()) {
337 EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
338 EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
339 EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined");
340 EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined");
341 EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined");
342 EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined");
343 }
344 }
345
TEST(AlignmentDeathTest,CompareMaybeAlignToZero)346 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
347 for (uint64_t Value : getValidAlignmentsForDeathTest()) {
348 // MaybeAlign is allowed to be == or != 0
349 (void)(MaybeAlign(Value) == 0);
350 (void)(MaybeAlign(Value) != 0);
351 }
352 }
353
TEST(AlignmentDeathTest,AlignAddr)354 TEST(AlignmentDeathTest, AlignAddr) {
355 const void *const unaligned_high_ptr =
356 reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);
357 EXPECT_DEATH(alignAddr(unaligned_high_ptr, Align(16)), "Overflow");
358 }
359
360 #endif // NDEBUG
361
362 } // end anonymous namespace
363
364 #ifdef _MSC_VER
365 #pragma warning(pop)
366 #endif
367