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 
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 
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 
41 TEST(AlignmentTest, AlignConstexprConstant) {
42   constexpr Align kConstantAlign = Align::Of<uint64_t>();
43   EXPECT_EQ(Align(alignof(uint64_t)), kConstantAlign);
44 }
45 
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 
53 TEST(AlignmentTest, AlignDefaultCTor) {
54   EXPECT_EQ(Align().value(), 1ULL);
55 }
56 
57 TEST(AlignmentTest, MaybeAlignDefaultCTor) {
58   EXPECT_FALSE(MaybeAlign().hasValue());
59 }
60 
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 
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 
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 
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 
128 TEST(AlignmentTest, Log2) {
129   for (uint64_t Value : getValidAlignments()) {
130     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
131     EXPECT_EQ(Log2(MaybeAlign(Value)), Log2_64(Value));
132   }
133 }
134 
135 TEST(AlignmentTest, MinAlign) {
136   struct {
137     uint64_t A;
138     uint64_t B;
139     uint64_t MinAlign;
140   } kTests[] = {
141       // MaybeAlign
142       {0, 0, 0},
143       {0, 8, 8},
144       {2, 0, 2},
145       // MaybeAlign / Align
146       {1, 2, 1},
147       {8, 4, 4},
148   };
149   for (const auto &T : kTests) {
150     EXPECT_EQ(commonAlignment(MaybeAlign(T.A), MaybeAlign(T.B)), T.MinAlign);
151     EXPECT_EQ(MinAlign(T.A, T.B), T.MinAlign);
152     if (T.A) {
153       EXPECT_EQ(commonAlignment(Align(T.A), MaybeAlign(T.B)), T.MinAlign);
154     }
155     if (T.B) {
156       EXPECT_EQ(commonAlignment(MaybeAlign(T.A), Align(T.B)), T.MinAlign);
157     }
158     if (T.A && T.B) {
159       EXPECT_EQ(commonAlignment(Align(T.A), Align(T.B)), T.MinAlign);
160     }
161   }
162 }
163 
164 TEST(AlignmentTest, Encode_Decode) {
165   for (uint64_t Value : getValidAlignments()) {
166     {
167       Align Actual(Value);
168       Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
169       EXPECT_EQ(Expected, Actual);
170     }
171     {
172       MaybeAlign Actual(Value);
173       MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
174       EXPECT_EQ(Expected, Actual);
175     }
176   }
177   MaybeAlign Actual(0);
178   MaybeAlign Expected = decodeMaybeAlign(encode(Actual));
179   EXPECT_EQ(Expected, Actual);
180 }
181 
182 TEST(AlignmentTest, isAligned_isAddrAligned) {
183   struct {
184     uint64_t alignment;
185     uint64_t offset;
186     bool isAligned;
187     const void *forgedAddr() const {
188       //  A value of any integral or enumeration type can be converted to a
189       //  pointer type.
190       return reinterpret_cast<const void *>(offset);
191     }
192   } kTests[] = {
193       {1, 0, true},  {1, 1, true},  {1, 5, true},  {2, 0, true},
194       {2, 1, false}, {2, 2, true},  {2, 7, false}, {2, 16, true},
195       {4, 0, true},  {4, 1, false}, {4, 4, true},  {4, 6, false},
196   };
197   for (const auto &T : kTests) {
198     MaybeAlign A(T.alignment);
199     // Test MaybeAlign
200     EXPECT_EQ(isAligned(A, T.offset), T.isAligned);
201     // Test Align
202     if (A) {
203       EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
204       EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
205     }
206   }
207 }
208 
209 TEST(AlignmentTest, offsetToAlignment) {
210   struct {
211     uint64_t alignment;
212     uint64_t offset;
213     uint64_t alignedOffset;
214     const void *forgedAddr() const {
215       //  A value of any integral or enumeration type can be converted to a
216       //  pointer type.
217       return reinterpret_cast<const void *>(offset);
218     }
219   } kTests[] = {
220       {1, 0, 0}, {1, 1, 0},  {1, 5, 0}, {2, 0, 0}, {2, 1, 1}, {2, 2, 0},
221       {2, 7, 1}, {2, 16, 0}, {4, 0, 0}, {4, 1, 3}, {4, 4, 0}, {4, 6, 2},
222   };
223   for (const auto &T : kTests) {
224     const Align A(T.alignment);
225     EXPECT_EQ(offsetToAlignment(T.offset, A), T.alignedOffset);
226     EXPECT_EQ(offsetToAlignedAddr(T.forgedAddr(), A), T.alignedOffset);
227   }
228 }
229 
230 TEST(AlignmentTest, AlignComparisons) {
231   std::vector<uint64_t> ValidAlignments = getValidAlignments();
232   std::sort(ValidAlignments.begin(), ValidAlignments.end());
233   for (size_t I = 1; I < ValidAlignments.size(); ++I) {
234     assert(I >= 1);
235     const Align A(ValidAlignments[I - 1]);
236     const Align B(ValidAlignments[I]);
237     EXPECT_EQ(A, A);
238     EXPECT_NE(A, B);
239     EXPECT_LT(A, B);
240     EXPECT_GT(B, A);
241     EXPECT_LE(A, B);
242     EXPECT_GE(B, A);
243     EXPECT_LE(A, A);
244     EXPECT_GE(A, A);
245 
246     EXPECT_EQ(A, A.value());
247     EXPECT_NE(A, B.value());
248     EXPECT_LT(A, B.value());
249     EXPECT_GT(B, A.value());
250     EXPECT_LE(A, B.value());
251     EXPECT_GE(B, A.value());
252     EXPECT_LE(A, A.value());
253     EXPECT_GE(A, A.value());
254 
255     EXPECT_EQ(std::max(A, B), B);
256     EXPECT_EQ(std::min(A, B), A);
257 
258     const MaybeAlign MA(ValidAlignments[I - 1]);
259     const MaybeAlign MB(ValidAlignments[I]);
260     EXPECT_EQ(MA, MA);
261     EXPECT_NE(MA, MB);
262     EXPECT_LT(MA, MB);
263     EXPECT_GT(MB, MA);
264     EXPECT_LE(MA, MB);
265     EXPECT_GE(MB, MA);
266     EXPECT_LE(MA, MA);
267     EXPECT_GE(MA, MA);
268 
269     EXPECT_EQ(MA, MA ? (*MA).value() : 0);
270     EXPECT_NE(MA, MB ? (*MB).value() : 0);
271     EXPECT_LT(MA, MB ? (*MB).value() : 0);
272     EXPECT_GT(MB, MA ? (*MA).value() : 0);
273     EXPECT_LE(MA, MB ? (*MB).value() : 0);
274     EXPECT_GE(MB, MA ? (*MA).value() : 0);
275     EXPECT_LE(MA, MA ? (*MA).value() : 0);
276     EXPECT_GE(MA, MA ? (*MA).value() : 0);
277 
278     EXPECT_EQ(std::max(A, B), B);
279     EXPECT_EQ(std::min(A, B), A);
280   }
281 }
282 
283 TEST(AlignmentTest, Max) {
284   // We introduce std::max here to test ADL.
285   using std::max;
286 
287   // Uses llvm::max.
288   EXPECT_EQ(max(MaybeAlign(), Align(2)), Align(2));
289   EXPECT_EQ(max(Align(2), MaybeAlign()), Align(2));
290 
291   EXPECT_EQ(max(MaybeAlign(1), Align(2)), Align(2));
292   EXPECT_EQ(max(Align(2), MaybeAlign(1)), Align(2));
293 
294   EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2));
295   EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2));
296 
297   EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4));
298   EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4));
299 
300   // Uses std::max.
301   EXPECT_EQ(max(Align(2), Align(4)), Align(4));
302   EXPECT_EQ(max(MaybeAlign(2), MaybeAlign(4)), MaybeAlign(4));
303   EXPECT_EQ(max(MaybeAlign(), MaybeAlign()), MaybeAlign());
304 }
305 
306 TEST(AlignmentTest, AssumeAligned) {
307   EXPECT_EQ(assumeAligned(0), Align(1));
308   EXPECT_EQ(assumeAligned(0), Align());
309   EXPECT_EQ(assumeAligned(1), Align(1));
310   EXPECT_EQ(assumeAligned(1), Align());
311 }
312 
313 // Death tests reply on assert which is disabled in release mode.
314 #ifndef NDEBUG
315 
316 // We use a subset of valid alignments for DEATH_TESTs as they are particularly
317 // slow.
318 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
319   return {1, 1ULL << 31, 1ULL << 63};
320 }
321 
322 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
323 
324 TEST(AlignmentDeathTest, Log2) {
325   EXPECT_DEATH(Log2(MaybeAlign(0)), ".* should be defined");
326 }
327 
328 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
329   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
330 }
331 
332 TEST(AlignmentDeathTest, Division) {
333   EXPECT_DEATH(Align(1) / 2, "Can't halve byte alignment");
334   EXPECT_DEATH(MaybeAlign(1) / 2, "Can't halve byte alignment");
335 
336   EXPECT_DEATH(Align(8) / 0, "Divisor must be positive and a power of 2");
337   EXPECT_DEATH(Align(8) / 3, "Divisor must be positive and a power of 2");
338 }
339 
340 TEST(AlignmentDeathTest, InvalidCTors) {
341   EXPECT_DEATH((Align(0)), "Value must not be 0");
342   for (uint64_t Value : getNonPowerOfTwo()) {
343     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
344     EXPECT_DEATH((MaybeAlign(Value)),
345                  "Alignment is neither 0 nor a power of 2");
346   }
347 }
348 
349 TEST(AlignmentDeathTest, ComparisonsWithZero) {
350   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
351     EXPECT_DEATH((void)(Align(Value) == 0), ".* should be defined");
352     EXPECT_DEATH((void)(Align(Value) != 0), ".* should be defined");
353     EXPECT_DEATH((void)(Align(Value) >= 0), ".* should be defined");
354     EXPECT_DEATH((void)(Align(Value) <= 0), ".* should be defined");
355     EXPECT_DEATH((void)(Align(Value) > 0), ".* should be defined");
356     EXPECT_DEATH((void)(Align(Value) < 0), ".* should be defined");
357   }
358 }
359 
360 TEST(AlignmentDeathTest, CompareMaybeAlignToZero) {
361   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
362     // MaybeAlign is allowed to be == or != 0
363     (void)(MaybeAlign(Value) == 0);
364     (void)(MaybeAlign(Value) != 0);
365     EXPECT_DEATH((void)(MaybeAlign(Value) >= 0), ".* should be defined");
366     EXPECT_DEATH((void)(MaybeAlign(Value) <= 0), ".* should be defined");
367     EXPECT_DEATH((void)(MaybeAlign(Value) > 0), ".* should be defined");
368     EXPECT_DEATH((void)(MaybeAlign(Value) < 0), ".* should be defined");
369   }
370 }
371 
372 TEST(AlignmentDeathTest, CompareAlignToUndefMaybeAlign) {
373   for (uint64_t Value : getValidAlignmentsForDeathTest()) {
374     EXPECT_DEATH((void)(Align(Value) == MaybeAlign(0)), ".* should be defined");
375     EXPECT_DEATH((void)(Align(Value) != MaybeAlign(0)), ".* should be defined");
376     EXPECT_DEATH((void)(Align(Value) >= MaybeAlign(0)), ".* should be defined");
377     EXPECT_DEATH((void)(Align(Value) <= MaybeAlign(0)), ".* should be defined");
378     EXPECT_DEATH((void)(Align(Value) > MaybeAlign(0)), ".* should be defined");
379     EXPECT_DEATH((void)(Align(Value) < MaybeAlign(0)), ".* should be defined");
380   }
381 }
382 
383 TEST(AlignmentDeathTest, AlignAddr) {
384   const void *const unaligned_high_ptr =
385       reinterpret_cast<const void *>(std::numeric_limits<uintptr_t>::max() - 1);
386   EXPECT_DEATH(alignAddr(unaligned_high_ptr, Align(16)), "Overflow");
387 }
388 
389 #endif // NDEBUG
390 
391 } // end anonymous namespace
392 
393 #ifdef _MSC_VER
394 #pragma warning(pop)
395 #endif
396