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, 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 
135 TEST(AlignmentTest, Log2) {
136   for (uint64_t Value : getValidAlignments()) {
137     EXPECT_EQ(Log2(Align(Value)), Log2_64(Value));
138   }
139 }
140 
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 
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 
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 
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 
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 
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 
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.
308 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
309   return {1, 1ULL << 31, 1ULL << 63};
310 }
311 
312 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
313 
314 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
315   EXPECT_DEATH((MaybeAlign(0).getValue()), ".*");
316 }
317 
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 
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 
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 
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 
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